1) Please Stop Adding Attributes - Attributes are often used in LLVM to communicate interesting facts (that might be computed by a static analysis, or might be supplied by a front end) to optimization passes. The problem is that while it isn't super difficult to add a new attribute and make an optimization pass use it, it is more difficult to precisely nail down the semantics of the attribute, and in particular how it interacts with every other feature in LLVM IR. This leads to technical debt in the form of latent ambiguity in the IR semantics, some of which we've attacked while adding support for them to Alive2, which of course requires a full formal semantics for every attribute that it supports. In this talk we'll try to convince the LLVM community to be pretty cautious when defining new attributes! 2) ORAQL: Optimistic Responses to Alias Queries in LLVM - This lightning talk presents ORAQL, an alias analysis pass and probing tool that help quantify the potential benefits of further developments to alias analysis or code annotation for a given input program. 3) Automated LLVM flag mining, theory and practice - Compiler flag mining is a compelling way to achieve higher binary performance. The right combination of flags can provide significantly higher performance, all without changing the code. The process of finding a well-performing flag combination, however, is very challenging due to the huge number of possible configurations. In this presentation, we will discuss ways to automatically mine LLVM compiler flags, and survey practical examples of how this is performed in the industry. 4) What's New in IR Similarity Identification and Outlining - After introducing, and integrating, the LLVM IR Outliner last year, we examined potential avenues to expand code size reductions by using the LLVM IR Outliner. In the past year, we have developed cross basic block similarity schemes, and expanded the amount of outlinable instructions to increase our size reductions from an average of 1.3% to 2.2%, a 70% increase, across CTMark. We also profiled several programs to analyze the relationship between the amount of outlined code and execution time. 5) Fixing False Assumptions: Inter-Function vs Intra-Function Machine Outlining - The MachineOutliner is an LLVM pass that attempts to deduplicate long sequences of instructions by creating a new function out of those sequences and then replacing each code sequence with a call to the new function. The outliner makes an assumption when deciding whether to outline code: code-size savings in the translation unit are directly result in code-size savings in the final binary. This assumption is incorrect, and in this talk, I will show an edge case where that assumption will lead to the outliner being too aggressive in its decision to outline, why it might not have been caught before, and a new command-line option that will tell the MachineOutliner whether to trust this assumption or not. 6) Clacc 2021: An Update on OpenACC Support for Clang and LLVM - 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. Where the OpenMP standard does not support features required by OpenACC, we design and prototype OpenMP extensions. As our Clacc implementation matures, we are beginning to upstream it into Clang and LLVM, including both Clacc’s OpenACC support and its related OpenMP extensions. This activity not only benefits 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.