[llvm-dev] Announcing the 2020 Virtual LLVM Developers' Meeting Program!

[Tanya Lattner via llvm-dev]

I am pleased to announce the 2020 Virtual LLVM Developers’ Meeting <https://llvm.org/devmtg/2020-09/> program! Registration will be opening this week and an announcement will be sent to the mailing lists and posted on the webpage. You can also follow LLVM.org on Twitter <https://twitter.com/llvmorg> or Facebook <https://www.facebook.com/LLVMORG>.

Keynote:
Undef and Poison: Present and Future - J. Lee

Technical Talks:

Clang & Linux: Asm Goto with Outputs - B. Wendling; N. Desaulniers
LLVM Libc: Current Status, Challenges and Future Plans	- S. Reddy; G. Chatelet; P. Asker; D. Finkelstein
Branch Coverage: Squeezing more out of LLVM Source-based Code Coverage	 - A. Phipps
Memory tagging in LLVM and Android - E. Stepanov; K. Serebryany; P. Collingbourne; M. Phillips
Towards a representation of arbitrary alias graph in LLVM IR for Fortran code - K. Li; T. Islam
Control-flow sensitive escape analysis in Falcon JIT - A. Pilipenko
Extending Clang for checking compliance with automotive coding standards - M. Vujosevic Janicic
An Update on Optimizing Multiple Exit Loops - P. Reames
Code Size Compiler Optimizations and Techniques - A. Kumar
Accelerate Matrix Multiplication Using the New POWER Outer Product Instructions - B. Saleil; J. Carvalho
CIL : Common MLIR Dialect for C/C++ and Fortran - P. NR; V. M; Ranjith; Srihari
Building compiler extension for LLVM 10.0.1 - S. Guelton
LLVM-based mutation testing for C and C++ - A. Denisov; S. Pankevich
Matrix Support in Clang and LLVM	 - F. Hahn
Adding CUDA® Support to Cling: JIT Compile to GPUs - S. Ehrig
The Present and Future of Interprocedural Optimization in LLVM	 - J. Doerfert; B. Homerding; S. Baziotis; S. Stipanovic; H. Ueno; K. Dinel; S. Okumura; L. Chen
Pushing Back Lit's Boundaries to Test Libc++ - L. Dionne
Evolving “convergent”: Lessons from Control Flow in AMDGPU - N. Hähnle
How to update debug info in compiler transformations - A. Prantl; V. Kumar
Proposal for A Framework for More Effective Loop Optimizations - M. Kruse; H. Finkel
Changing Everything With Clang Plugins: A Story About Syntax Extensions, Clang's AST, and Quantum Computing - H. Finkel; A. Mccaskey
(OpenMP) Parallelism-Aware Optimizations - J. Doerfert; S. Stipanovic; H. Mosquera; J. Chesterfield; G. Georgakoudis; J. Huber
Checked C: Adding memory safety support to LLVM - M. Grang; K. Kjeer

Tutorials:

Everything I know about debugging LLVM - N. Desaulniers
LLVM in a Bare Metal Environment - H. Qadeer
PGO: Add per-callsite counters - P. Kosov; Y. Sergey
Understanding Changes made by a Pass in the Opt Pipeline. - J. Schmeiser
Using clang-tidy for customized checkers and large scale source tree refactoring - V. Bridgers
Finding Your Way Around the LLVM Dependence Analysis Zoo - S. Baziotis; S. Moll
Using the clang static analyzer to find bugs - V. Bridgers
A Deep Dive into the Interprocedural Optimization Infrastructure - J. Doerfert; B. Homerding; S. Baziotis; S. Stipanovic; H. Ueno; K. Dinel; S. Okumura; L. Chen
MLIR Tutorial - M. Amini

Lightning Talks:

Finding and Outlining Similarities in LLVM IR	- A. Litteken
A fast algorithm for global code motion of congruent instructions - A. Kumar; S. Pop
From Implicit Pass Dependencies to Effectiveness Prediction - H. Ueno; J. Doerfert; E. Park; G. Georgakoudis; T. Jayatilaka; S. Badruswamy
Using Clang as An Alternative C/C++ Frontend of The ROSE Source-to-Source Compiler - A. Wang; P. Lin; C. Liao; Y. Yan
OpenACC support in Flang with a MLIR dialect - V. Clement; J. Vetter
Fragmenting the DWARF to Enable Dead Debug Data Elimination - J. Henderson
Source-based Code Coverage for Embedded Use Cases - A. Phipps; C. Addison
pre-merge checks for LLVM - M. Goncharov; C. Kühnel
Getting stack size just right on XCore - J. McCrea
Compile Faster with the Program Repository and ccache - Y. Yi; P. Bowen-Huggett
GWP-TSan: Zero-Cost Detection of Data Races in Production - M. Morehouse; K. Serebryany
CompilerInvocation to -cc1 command line - D. Grumberg
Outer-Loop Vectorization Legality Analysis for RV: One Step Closer to a Powerful Vectorizer for LLVM - S. Baziotis
Flang Update - S. Scalpone
Code Feature Analysis, Tracking, and Future Usage - T. Jayatilaka; J. Doerfert; G. Georgakoudis; E. Park; H. Ueno; S. Badruswamy
Lowering XLA HLO using RISE - A Functional Pattern-based MLIR Dialect - M. Lücke; A. Smith; M. Steuwer
SYCL for CUDA: An overview of implementing PI for CUDA - A. Johnston
Extending LLDB to More Scripting Languages - J. Devlieghere
Adding a Subtarget Support to LLVM in Five Minutes - E. Yakubova

Birds of a Feather:

ClangBuiltLinux BoF - N. Desaulniers
Loop Optimization BoF - M. Kruse; K. Barton
LLVM Just-In-Time Compilers BoF - L. Hames
Code Size Optimization - S. Bartell; V. Adve


Student Research Competition

Enzyme: High-Performance Automatic Differentiation of LLVM - W. Moses; V. Churavy
SPAM: Stateless Permutation of Application Memory with LLVM - M. Ziad; M. Arroyo; S. Sethumadhavan
HPVM-FPGFA: Leveraging Compiler Optimizations for Hardware-Agnostic FPGA Programming	- A. Ejjeh; K. Kanwar; M. Kotsifakou; V. Adve; R. Rutenbar
Guided Linking: shrinking and speeding up dynamically linked code - S. Bartell; V. Adve
ApproxTuner: A Compiler and Runtime System for Adaptive Approximations - H. Sharif; M. Kotsifakou; Y. Zhao; A. Kothari; B. Schreiber; E. Wang; Y. Sarita; N. Zhao; K. Joshi; V. Adve; S. Misailovic; S. Adve

Posters:

CIRCT: MLIR for Hardware Design - S. Neuendorffer; C. Lattner; A. Wilson
An Approach to Generate Correctly Rounded Math Libraries for New Floating Point Variants - J. Lim; M. Aanjaneya; J. Gustafson; S. Nagarakatte
Compiling a Higher-Order Smart Contract Language to LLVM - V. Nagaraj; J. Johannsen; A. Trunov; G. Pirlea; A. Kumar; I. Sergey
To -jInfinity & Beyond - W. Moses; K. Kwok; L. Sha
llvm-diva – Debug Information Visual Analyzer - C. Enciso
Quickly Finding RISC-V Code Quality Issues with Differential Analysis - L. Marques
Error estimates of floating-point numbers and Jacobian matrix computation in Clad - V. Vassilev; A. Penev; R. Shakhov
Data Dependency using MSSA: Analysis and Contrast  - R. Sharma
Connecting Clang to The ROSE Source-to-Source Compiler - A. Wang; P. Lin; C. Liao; Y. Yan
Incremental Compilation Support in Clang - V. Vassilevv; D. Lange





-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20200824/1b47cade/attachment.html>