5 ms·
What's new for RISC-V in LLVM 17
- sylware 3y agoThe poor souls having to deal with that c++ monstruosity which is LLVM for legac y support in the RISC-V world have my sympathy. The RISC-V world was made mostly for assembly written software (without abusing a preprocessor, namely trying to write c++ or even C with a preprocessor...). That because it is a world wide standard, free from royalties and licencing (not like arm and intel).
- remexre 3y agoIn what way is RISC-V more suited for writing assembly than, say, AArch64? From what I know of each, they're fairly close together, but a few small things like the clever encoding of logical immediates (e.g. and x1, x1, 0x3fff70000000 is a single instruction; you don't need to waste a register to load the immediate) in AArch64 make it seem friendlier to me.
- cmrdporcupine 3y ago100%. RISC-V at least requires a macro assembler of some kind to be more pleasant. That's not to say RISC-V isn't a good ISA. The whole point of RISC is to be a good target for compilation, not humans.
- sylware 3y agoI severely disagree, I think that a "good enough" and "free" and world-wide ISA standard is meant for assembly programming. I meant a lot more, like all system components and very high level language interpreters (javascript/lua/python/insert_your_high_level_language_here). I did not mean zero preprocessor, I meant a conservative/frugal usage a simple pre-processor to avoid to spawn another insanely complex SDK dependency of the code which will be a pain to create a real life alternative. Basically, RISC-V is meant for multi-instructions per line assemblers (semi-colon...).
- snvzz 3y agoThere's no real reason to code in machine code, or to give up the convenience of a macro assembler and use a micro assembler. But you can do both with RISC-V, there's nothing to stop you.
- cmrdporcupine 3y agoAbsolutely, and I've done it. But as far as various assemblers go, RISC-V is one of the least ergonomic. It's consistent, certainly. But tedious.
- snvzz 3y agoI have done it, too. RISC-V Feels like MIPS, except better. m68k used to be my favorite, until RISC-V happened.
- pjmlp 3y agoTraditional with the MIPS CPU linage, as many instructions common in other ISAs, only exist as macros.
- snvzz 3y ago>In what way is RISC-V more suited for writing assembly than, say, AArch64? Not them, but I would say it's backwards compatibility guaranteed for RV64GC, which happens to be very nice and clean, free of the baggage other ISAs have.
- sylware 3y agoaarch64 is not a world-wide free standard. You have acquire a licence from arm if you want to create cpu support aarch64. That's what apple is doing. The licence fee is only valid in some countries though.
- rwmj 3y ago> The RISC-V world was made mostly for assembly written software I can assure you this is not the case. In fact RISC-V is somewhat annoying to write software for directly in assembly because of the lack of support for loading large constants (directly), and making large jumps.
- sylware 3y agoI don't agree. It is fine if you use a multi-instructions-per-line assembler.
- trealira 3y agoWhy is that different from "abusing a preprocessor"? Because it's built into the assembler?
- sylware 3y agoThe preprocessor can be independent from the assembler. For instance when I code x86_64 assembly I use a C preprocessor (and I am not doing weird things with it)... but I use 3 assemblers (fasmg/nasm/gas), I still use their internal preprocessor, but hardly, only to smooth their syntax to have only 1 source file I can assemble with fasmg/nasm/gas. The main issue with a "preprocessor" it is when it's ultra complex and powerful, for instance with fasmg and to a lesser extend nasm: devs are literaly jerking off using as much as possible the complexity of the preprocessor, making their assembly code hardly assembly anymore, and you end up having to learn their whole new language they did built with it, and the really annoying thing their "assembly" code becomes strongely dependent on that specific preprocessor and the "technical exit cost" is astronomical. This is no better than to depend on a c++ compiler.
- trealira 3y agoI guess that makes sense. RISC-V assembly doesn't actually seem that difficult to hand write, especially given that pseudo-instructions exist. I don't see why you wouldn't just write in C, though, aside from a few functions where hand-written assembly is necessary. C compilers are more complex than assemblers, but they're still really common and, and they're doable for the average person to learn to write on their own.
- rwmj 3y agoLLVM needs a way to be able to turn off compressed instructions entirely at configuration time. Some of the RISC-V server platforms which will appear in the next few years won't have them.
- LoganDark 3y agoThose server platforms will make sure LLVM supports whatever they have, because a loss of Rust would be a very large blow, unless rustc_codegen_gcc is production-ready by then.
- asb 3y agoYou could certainly change the default `-march` to rv64g (plus whatever extensions you want) rather than rv64gc. That provides mostly what you'd want, though there's some small chance that inline asm or hand-written assembly using `.option rvc` or `.option arch, +c` inappropriately causes issues. I just posted some thoughts on this here: https://lists.riscv.org/g/tech-profiles/message/348 https://lists.riscv.org/g/tech-profiles/message/348
- rwmj 3y agoUsing 'clang -march=rv64g' does work but it's a pain in the neck for Linux distros. [Edit] The question is, is there a way to change this at llvm build time? I wasn't able to find a way. For GNU binutils it is relatively simple. BTW I've been writing a document on the topic of how Linux distros will support hardware with and without compressed: https://github.com/rwmjones/rhrq-riscv-extensions/blob/main/compressed.md https://github.com/rwmjones/rhrq-riscv-extensions/blob/main/...
- asb 3y ago99.9% of my clang invocations are from the build dir of the git tree I'm working on, so I could be missing something known to others on the distribution side - but let me try my best answer. Firstly, as you probably know the Clang/LLVM model is quite different to gcc/binutils in terms of build-time configuration. Any clang can target any architecture (unless it was disabled at build time) using --target=$TRIPLE (see <https://clang.llvm.org/docs/CrossCompilation.html#target-triple https://clang.llvm.org/docs/CrossCompilation.html#target-tri...>). In practice it's not as useful as it sounds of course because you need appropriate sysroots. You can control the default with LLVM_DEFAULT_TARGET_TRIPLE, but without patching clang it's going to enabled compressed for the riscv64-unknown-linux-gnu triple. I think the standard way of controlling other default flags would be to deploy a configuration file <https://clang.llvm.org/docs/UsersManual.html#configuration-files https://clang.llvm.org/docs/UsersManual.html#configuration-f...> - though I'd need to check which logic took precedent if you explicitly passed --target=riscv64-unknown-linux-gnu. Ultimately we'd need to change the meaning of the current linux triples, or decide upon new ones I think. Thanks for sharing that doc - really helpful. I don't know if it's different with GNU as, but not that if a file contains `.option rvc` that _isn't_ sufficient to set the EF_RISCV_RVC ELF flag with LLVM. Additionally, I'd imagine in general that people using .option in inline asm may see different behaviour for Clang vs GCC. Clang doesn't generate assembly output that then gets passed to the assembly - ELF emission happens directly (of course, with the assembler being invoked as needed for inline asm blocks), and so it's rather difficult to replicate the effect you'd see with GCC generating a .s file that's then assembled.
- nikic 3y agoWhat's with RISC-V and these peculiar extension names?
- jcranmer 3y agoSomeone thought Intel was too clear in their naming of ISA extensions? One a more serious note, it looks like RISC-V extensions are single letters, except for X (vendor extensions), S (collection of supervisor-mode extensions), and Z (collection of user-mode extensions).
- lifthrasiir 3y agoAnd RISC-V is designed to be highly modular that the "base" instruction set is really tiny, it even lacks integer multiplication and division (provided via M standard extension). For this reason there are a tremendous number of extensions, and most recent extensions are using the Z prefix, where the second letter is often a relevant single-letter extension (e.g. `Zmmul` is a subset of M with only multiplication) or a mnemonic (e.g. `Zk` prefix is dedicated for cryptographic extensions). No wonder why extension names look so crowded.
- sobkas 3y agoI dream of library for example named libcpu that have backends compiled from Verilog/VHDLl(or even get traction under something better)so people could play with existing CPUs by implementing them and/or creating something complete different without the need for expensive FPGAs and not constrained by their size. Building emulated machine by using some connecting code(maybe a framework) and hard part hidden in libcpu for major chips.
- RetroTechie 3y agoYou may want to check out Verilator: https://verilator.org/ https://verilator.org/