Wolfgang Grieskamp’s Post

We forked circom compiler, implemented AST to JSON serialization, compiled it to WASM, and uploaded to NPM. Let me tell you why this is huge. 1. Circom is a popular zero knowledge circuits compiler that bridges the gap between human-readable zero knowledge circuits code and snarkjs by compiling circuits to R1CS binary and WASM witness programs. These outputs may then be passed to snarkjs to compute ZK proofs and generate Solidity ZK verifiers for on-chain proving usage. 2. Abstract Syntax Tree (AST) is a special data structure that is constructed by a parser and contains information about the structure of the program. Usually, this information is the source code itself, yet structured, and split into meaningful statements that are processed down in the subsequent stages of the compilation process. 3. Exposure to an AST enables third-party source code analyzers to be implemented. For example, these can be bindings generators (Typescript/Golang/Java), linters, static analyzers, documentation generators, etc. 4. We added the AST serialization to the compiler, stripped down some of the platform-dependent precompiles (fs in rust uses C dlls), compiled everything to WASM, and uploaded to NPM. 5. This unlocks the wide range of products to be implemented. We are already thinking of Typescript bindings generator (aiming to be like Typechain) for circom. Imagine writing tests and generating ZK proofs knowing that every signal is passed correctly and in the right, unaltered order. - This was a bit of a deep dive, but, you know, the future is ZKP. https://lnkd.in/di9gtjbg #solidity #zkp #circom

Next update on the road to our first release for Ferrocene - our qualified version of the upstream Rust compiler. What do we mean with "upstream"? It's a word from the open source world that describes our relationship with the main #Rust compiler - we qualify it as-is and propose changes to the Rust project directly whenever possible. That also means that we have a lot of machinery to keep track of current changes and frequently (every night!) assess how they impact us. In this article, we get deeper into the details of the why and how of that. https://lnkd.in/e6C_KnMd (Also, don't forget to sign up to our party next week): https://lnkd.in/ePBDt5iE #rustlang #safety #ferrocene

Check out this blog to learn more about our recent improvements to vector initialization for NEON on compiler optimizations in GCC: https://ow.ly/5JoT50PUZBE #toolchain #opensource #software

I was surprised that rustc only now get regular runtime performance benchmarks: > Were there really no runtime benchmarks before? Now, you might be wondering whether Rust really had no runtime performance benchmarks before my project, as that seems unlikely. And indeed, the compiler, and especially the standard library, has lots of benchmarks that leverage the normal Rust benchmark machinery (using the #[bench] attribute and cargo bench). However, these benchmarks are microbenchmarks that usually measure only very small pieces of Rust code (for example, common iterator adaptor chains). But most importantly, these microbenchmarks are executed only manually by rustc developers, typically when they are trying to optimize some part of the standard library or the compiler. #rust https://lnkd.in/e_Mx947A

Hi friends, today I wrote an article about what a compiler is and its journey and how our source code is converted into machine-level code. #compiler #developers #OperatingSystem #SoftwareDevelopment #CodeOptimization, #TechArticle

We love hearing from people who use Time Travel Debugging (TTD) to dramatically reduce the time spent diagnosing issues. Our security team recently worked with the compiler team to solve a nasty deadlock when using ASAN and shared their journey. In the narrative below they make use of the reproducibility that trace files offer along with hardware breakpoints to solve the problem. If you already know how to debug with Windbg the barrier of entry to TTD is low. As a bonus tip, you can use the timeline view to construct call queries or memory queries instead of using breakpoints and stepping through execution. Or, you can use “dx -g” with a call or memory query to generate a table of information about the call parameters / memory values / etc (my favorite!) Do you have a good story to tell? Please share as inspiration for all of us! ----- When rolling ASAN out across Windows, we hit an interesting bug on a particular build target. Without ASAN the program worked as expected, however when we turned on ASAN we experienced a deadlock every time. I threw the program into TTD and the problem reproduced immediately. From the trace, I could see all threads were blocked on a lock. From there, I rewound the trace to the start, setting a breakpoint on the locking functions, conditional on my specific blocking lock, then executed forward. Very quickly I could see that one location locked the lock, but its epilog ended up calling unlock with a different point. Returning to the trace with the compiler team later, we were able to narrow down the issue to a specific place where, under ASAN combined with a tailcall, the stack would not be appropriately adjusted causing the saved registers to be clobbered. These clobbered registers then got fed into the unlock routine, leading to the inconsistent lock state and eventual deadlock. The fix for this issue is in VS 2022 17.10 Preview 3. Start to finish, from reproducing outside of the debugger to identifying the offending codegen took around four hours, with another hour spent later with the compiler team to identify the specific behavior that was at fault. Without a TTD trace, root causing this would have taken much, much longer. While I find TTD valuable in day-to-day debugging, especially in instances of toolchain issues, the time saved by the replayability is incredible.

Use case of address sanitizer's and Time Travel Debugging (TTD)  for C/C++.

Exploring the Vyper Compiler Nonreentrancy Guard Bug

Implementing highly performant production systems requires the constant pursuit of speed – without compromising correctness. 🎯 HRT C++ developers achieve this by investigating compiler behavior and leveraging compiler optimisations. In the latest post on the #HRTBeat, London-based SWE Iwona Kotlarska explores compiler optimisations, virtual functions, noteworthy limitations, and how to write code that harnesses these techniques to maintain fast and accurate trading systems. Catch the full story here: https://lnkd.in/esWDpAay #Devirtualisation #CompilerOptimisation #CppProgramming