2019 LLVM Developers' Meeting

• Conference Dates: October 22-23, 2019
• Location: San Jose Convention Center, San Jose, CA
• Event Site: https://llvm.org/devmtg/2019-10/

About

The LLVM Developers’ Meeting is a bi-annual gathering of the entire LLVM Project community. The conference is organized by the LLVM Foundation and many volunteers within the LLVM community. Developers and users of LLVM, Clang, and related subprojects will enjoy attending interesting talks, impromptu discussions, and networking with the many members of our community. Whether you are a new to the LLVM project or a long time member, there is something for each attendee.

To see the agenda, speakers, and register, please visit the Event Site here: https://llvm.org/devmtg/2019-10/

What can you can expect at an LLVM Developers’ Meeting?

• Technical Talks

  These 25 minute talks cover all topics from core infrastructure talks, to project’s using LLVM’s infrastructure. Attendees will take away technical information that could be pertinent to their project or general interest.

• Tutorials

  Tutorials are 60 minute sessions that dive down deep into a technical topic. Expect in depth examples and explanations.

• Lightning Talks

  These are fast 5 minute talks that give you a taste of a project or topic. Attendees will hear a wide range of topics and probably leave wanting to learn more.

• Panels

  Panel sessions are guided discussions about a specific topic. The panel consists of ~3 developers who discuss a topic through prepared questions from a moderator. The audience is also given the opportunity to ask questions of the panel.

• Student Research Competition

  Students present their research using LLVM or related subproject. These are usually 20 minute technical presentations with Q&A. The audience will vote at the end for the winning presentation and paper.

• Poster Session

  An hour long session where selected posters are on display, with the presenters available for learning more on each poster.

• Round Table Discussions

  Informal and impromptu discussions on a specific topic. During the conference there are set time slots where groups can organize to discuss a problem or topic.

• Evening Reception

  After a full day if technical talks and discussions, join your fellow attendees for an evening reception to continue the conversation and meet even more attendees.

What types of people attend?

• Active developers of projects in the LLVM Umbrella (LLVM core, Clang, LLDB, libc++, compiler_rt, flang, lld, MLIR, etc).
• Anyone interested in using these as part of another project.
• Students and Researchers
• Compiler, programming language, and runtime enthusiasts.
• Those interested in using compiler and toolchain technology in novel and interesting ways.

The LLVM Developers’ Meeting strives to be the best conference to meet other LLVM developers and users.

Please visit the event site for all the information, call for papers, and more: https://llvm.org/devmtg/2019-10/

For future announcements or questions: Please visit the LLVM Discourse forums. Most posts are in the Announcements or Community categories and tagged with usllvmdevmtg.

Program

Keynote

Generating Optimized Code with GlobalISel

Even Better C++ Performance and Productivity: Enhancing Clang to Support Just-in-Time Compilation of Templates

Technical Talks

Using LLVM's portable SIMD with Zig

Code-Generation for the Arm M-profile Vector Extension

Alive2: Verifying Existing Optimizations

The clang constexpr interpreter

Souper-Charging Peepholes with Target Machine Info

Transitioning the Networking Software Toolchain to Clang/LLVM

Link Time Optimization For Swift

Hot Cold Splitting Optimization Pass In LLVM

Making UB hurt less: security mitigations through automatic variable initialization

Propeller: Profile Guided Large Scale Performance Enhancing Relinker

From C++ for OpenCL to C++ for accelerator devices

LLVM-Canon: Shooting for Clear Diffs

Better C++ debugging using Clang Modules in LLDB

Ownership SSA and Semantic SIL

arm64e: An ABI for Pointer Authentication

Porting by a 1000 Patches: Bringing Swift to Windows

The Penultimate Challange: Constructing bug reports in the Clang Static Analyzer

Address Spaces in LLVM

An MLIR Dialect for High-Level Optimization of Fortran

Loop-transformation #pragmas in the front-end

Optimizing builds on Windows: some practical considerations

LLVM-Reduce for testcase reduction

Memoro: Scaling an LLVM-based Heap profiler

The Attributor: A Versatile Inter-procedural Fixpoint Iteration Framework

LLVM Tutorials: How to write Beginner-Friendly, Inclusive Tutorials

Maturing an LLVM backend: Lessons learned from the RISC-V target

Tutorials

Getting Started With LLVM: Basics

ASTImporter: Merging Clang ASTs

Developing the Clang Static Analyzer

Writing an LLVM Pass: 101

Writing Loop Optimizations in LLVM

The Attributor: A Versatile Inter-procedural Fixpoint Iteration Framework

Getting Started with the LLVM Testing Infrastructure

An overview of Clang

An overview of LLVM

How to Contribute to LLVM

My First Clang Warning

Student Research Competition

Cross-Translation Unit Optimization via Annotated Headers

Quantifying Dataflow Analysis with Gradients in LLVM

Floating Point Consistency in the Wild: A practical evaluation of how compiler optimizations affect high performance floating point code

Static Analysis of OpenMP Data Mapping for Target Offloading

Panels

Panel: Inter-procedural Optimization (IPO)

The Loop Optimization Working Group

Birds of a Feather

LLDB

Towards Better Code Generator Design and Unification for a Stack Machine

Debug Info

Lightning Talks

GWP-ASan: Zero-Cost Detection of Memory Safety Bugs in Production

When 3 Memory Models Aren’t Enough – OpenVMS on x86

FileCheck: learning arithmetic

-Wall Found Programming Errors and Engineering Effort to Enable Across a Large Codebase

Handling 1000s of OpenCL builtin functions in Clang

NEC SX-Aurora as a Scalable Vector Playground

Implementing Machine Code Optimizations for RISC-V

Optimization Remarks Update

Supporting Regular and Thin LTO with a Single LTO Bitcode Format

Transitioning Apple’s Downstream llvm-project Repositories to the Monorepo

A Unified Debug Server For Deeply Embedded Systems and LLDB

State of LLDB and Deeply Embedded RISC-V

Supporting a Vendor ABI Variant in Clang

Speculative Compilation in ORC JIT

Optimization Remarks for Human Beings

Improving the Optimized Debugging Experience

Improving your TableGen Descriptions

Loom: Weaving Instrumentation for Program Analysis

Clang Interface Stubs: Syntax Directed Stub Library Generation.

Flang Update

Lowering tale: Supporting 64 bit pointers in RISCV 32 bit LLVM backend

Virtual Function Elimination in LLVM

Making a Language Cross Platform: Libraries and Tooling

Grafter - A use case to implement an embedded DSL in C++ and perform source to source traversal fusion transformation using Clang

Posters

TON Labs Backend for TON Blockchain

LLVM Build Times Using a Program Repository

RISC-V Bit Manipulation Support in the Clang/LLVM Toolchain

Attributor, a Framework for Interprocedural Information Deduction

Overflows Be Gone: Checked C for Memory Safety

Cross-Translation Unit Optimization via Annotated Headers

Quantifying Dataflow Analysis with Gradients in LLVM

Floating Point Consistency in the Wild: A practical evaluation of how compiler optimizations affect high performance floating point code

Static Analysis of OpenMP Data Mapping for Target Offloading

NEC SX-Aurora as a Scalable Vector Playground

A Unified Debug Server For Deeply Embedded Systems and LLDB

Speculative Compilation in ORC JIT

Loom: Weaving Instrumentation for Program Analysis

Lowering tale: Supporting 64 bit pointers in RISCV 32 bit LLVM backend

Code of Conduct

The LLVM Foundation is dedicated to providing an inclusive and safe experience for everyone. We do not tolerate harassment of participants in any form. By registering for this event, we expect you to have read and agree to the LLVM Code of Conduct.

Contact

To contact the organizer, email events@llvm.org.