rustc-dev-guide VS inkwell

yes, it's possible! that list doesn't exist today but i would love to create it. i wrote a draft a few years ago before shifting to other work; someone recently expressed interest in reviving that project: https://github.com/rust-lang/rustc-dev-guide/pull/1463

<3 i'm glad you enjoyed it

It's possible - you could open an issue on the rustc-dev-guide repo if you'd like. https://github.com/rust-lang/rustc-dev-guide/

I'm very confident that this would be well received! I'm not sure where the source code for rustdoc lives, but I know that the internals getting started guide is here: https://github.com/rust-lang/rustc-dev-guide/blob/master/src/rustdoc.md. That would be a good place to start if you're looking into how the HTML is generated.

Do you have links to any good info about how much rustc reuses from previous runs? This is the first time i hear about reuse at the function level. I guess the rustc-dev-guide would be a good place for me to start?

Inspired by the rust compiler, you could represent the entire state of the application as a graph of operations with inputs and outputs. You can hash all the inputs and use that to memoize the operations, so that you don't have to repeat them, you can cache them in memory or on disk, and it helps you track which parts of the app state actually change between user operations and you can then be sure you put all the changes in the undo/redo stack, and so that you don't have to store duplicate copies of things that don't change. (How's that for a run-on sentence?) You could run a general binary diff algorithm between subsequent versions of the same operation with different inputs to try to reduce the memory used by storing the different versions, and have specialized diff algorithms for specific types of data. (How do you identify related operations? How much CPU does this use?) You can have a background task that compresses older versions with LZ4 or zstd. You can have a background task that saves older versions on-disk when there's memory pressure.

I contributed a couple small bugfixes for issues I ran into along the way as well. 1, 2

It's rustdoc: https://github.com/rust-lang/rustc-dev-guide/blob/master/src...

> Rustdoc actually uses the rustc internals directly. It lives in-tree with the compiler and standard library. This chapter is about how it works. For information about Rustdoc's features and how to use them, see the Rustdoc book. For more details about how rustdoc works, see the "Rustdoc internals" chapter.

Secondly, I have learned about LLVM, and I have learned about the Inkwell library on Rust (It's a New Kind of Wrapper for Exposing LLVM (Safely)). Has anyone used this library before? Is this a good practice? Is it suitable for my compiler? Can I write some optimization passes of my own using this library?

I am trying to use the inkwell Rust crate for working with LLVM. In Cargo.toml, I have specified the LLVM version using features = ["llvm15-0"]

inkwell is a great llvm binding for rust and it has an implementation of kaleidoscope

I'm working on a compiler that uses the LLVM wrapper Inkwell for compilation. In order to compile something in inkwell, unless I'm missing something (which I very well might be), you need two structs:

Compiler backends (If building JIT/machine compiled langauges) 1. cranelift 2. inkwell - safe rust wrapper around llvm

Haha small world. I think we go to the same university and I took the same or similar course a few years ago. If somebody hasn't done the work for you, you may have to do some instrumentation yourself depending on what you want to track IMO https://github.com/TheDan64/inkwell is the best LLVM wrapper for Rustland (Python's llvmlite is a bit easier to use though)

I'm currently using the Inkwell bindings for Rust, which I've found actually pretty nice. In terms of generating LLVM IR, the C bindings (which is what Inkwell uses internally) can do anything you want them to (definitely not limited to trivial languages as someone else here said.) I'm even using the LLVM garbage collection infrastructure, with no problems (well, no problems in generating it; the LLVM GC infrastructure works pretty well but is sparsely documented, so actually writing a GC is fairly difficult, but it's doable). The C bindings are actually more stable than the C++ bindings (!), although not quite as stable as the textual IR format; but without the bindings you would have to write code to generate the IR yourself, the compiler would be slower as it must be emitted as text and then reparsed in a different process, and you would have less control over optimization.

safe llvm bindings https://github.com/TheDan64/inkwell

As we reviewed in this article LLVM IR has many use-cases and allows us to analyze and optimize source code through its passes. Knowing IR language itself will help us to write our passes and build projects around it for debugging, testing, optimizing. Currently, LLVM IR doesn't have Rust API. It's mainly used through the C++ library. However, some user-created repos are available on crates.io. There is a Rust binding to LLVM's C API - llvm-sys and two other, more Rusty APIs that are using LLVM: inkwell and llvm-ir. And finally, if you want to learn how to write a LLVM pass you should start here.