1) Removal of Undef: Move Uninitialized Memory to Poison - John McIver LLVM is working toward the eventual replacement of undef with poison. One of the issues remaining is load semantics with uninitialized memory. During GSoC 2022 we have been investigating and implementing potential solutions to these issues. This poster will outline changes that have been proposed to clang to resolve bit-fields, freeze poison insertion for optimization, and overall performance impacts of these changes. 2) Optimizing Julia's ORC JIT - Prem Chintalapudi Julia uses LLVM's ORC JIT compilation framework to compile code just before it is executed. Although ORC provides its own LLJIT and LLLazyJIT engines, Julia does not use either of those, opting for a custom JIT stack for more control over code execution and memory management. Julia's ORC JIT compiler cannot compile code in parallel, and this talk will cover some of the reasons that make parallelization challenging as well as work that is being done to solve those challenges. This talk will cover a general overview of how the Julia compilation pipeline works as well as the improvements to the compiler that will enable multithreaded compilation. 3) Clacc 2022: An Update on OpenACC Support for Clang and LLVM - Joel Denny Clacc is developing production-quality OpenACC compiler, runtime, and profiling support by extending Clang and LLVM for the Exascale Computing Project. A key Clacc design decision is to translate OpenACC to OpenMP in order to leverage the OpenMP offloading support that is actively being developed for Clang and LLVM. As our Clacc implementation matures, we continue to contribute mutually beneficial changes upstream, including improvements to LLVM’s testing infrastructure, Clang, standard OpenMP support, and OpenMP extensions that Clacc requires for OpenACC support. This activity not only paves the way for fully contributing Clacc’s OpenACC support to upstream Clang, but it also benefits Flang’s OpenACC support for Fortran via a shared runtime implementation. The purpose of this talk is to provide an update on recent Clacc progress, to present the plan for the road ahead, and to invite research and development participation from others. 4) An LLVM-Based Compiler for Quantum-Classical Applications - Xin-Chuan Wu In this work, we design a quantum language extension to C++ and create a quantum compiler based on the LLVM framework. This compiler is integrated into Intel® Quantum SDK. It is a software package which allows users to interface with the Intel’s quantum computing stack. We utilize the LLVM Pass infrastructure to define custom transformation passes that perform IR to IR translation for the quantum program, as well as leverage LLVM’s built-in passes. These passes and tools are used to extract, manipulate, and decompose the quantum logic. The quantum runtime library is capable of handling dynamic parameters for quantum computing. A quantum-classical variational algorithm can be specified in a single-source code and only needs to be compiled once for all iterations. 5) Specializing Code to New Architectures via Dynamic Adaptive Recompilation - Quinn Pham, Dhanrajbir Singh Hira Modern microprocessors introduce performance-improving features that can only be accessed through novel instructions. Furthermore, new compiler releases are extended not only to make use of these new instructions but also to generate better schedules for the new hardware. Therefore, applications distributed as binaries need to be recompiled to tap into such features and improvements. However, applications are generally distributed with binaries compiled with a subset of instructions common to a family of processors. Such practice is widely adopted by Independent Software Vendors (ISVs) as a strategy to reduce the costs of deploying a large number of binaries. This talk presents DAR, a dynamic adaptive recompilation approach that recompiles segments of a program for target-specific specialization. DAR aims at allowing end-users to benefit from sub-target specialization and improvements in the compiler technology — that might have emerged after the binary was created —, while still letting ISVs release just a couple binaries for each architecture. DAR generates fat binaries with the IR of program segments that can benefit recompilation. The talk aims at discussing methods to identify program segments that might benefit from recompilation and share our experience while implementing a prototype of DAR in LLVM. 6) LLFPTrax: Tracking ill-conditioned floating-point inputs using relative error amplification in LLVM - Tanmay Tirpankar Floating-point errors occur due to the inherent rounding that takes place due to the limited precision offered by the floating-point format. Many state-of-art tools use a high-precision oracle to estimate the absolute error and find high-error triggering (ill-conditioned) inputs through optimization techniques that help maximize the error. By switching to relative errors, we obtain a more meaningful metric when searching for ill-conditioned inputs, as they directly relate to the precision loss. This talk presents the details of LLFPTrax's implementation and preliminary results. 7) LLVM continuous upstream integration and testing - Jay Azurin, Keerthana Subramani This poster will describe the automation tools used at Qualcomm to maintain and test a downstream version of the llvm-project. 8) Automatic indirect memory access instructions generation for pointer chasing patterns - Adam Perdeusz Poster is describing how newly introduced feature into real HW can be adopted into Clang and LLVM and thanks to it easily available for the user. Indirect Memory Access Instructions (IMAI) can provide significant performance improvement but its usability is limited with particular HW restrictions. We tried to reconcile HW limitations, complexity of IMAI and ease of use by handling dedicated pragma in Clang and applying Complex Patterns in DAG in LLVM Backend.