The LLVM Compiler Infrastructure
Site Map:
Download!
Download now: LLVM 9.0.0
All Releases
APT Packages
Win Installer

View the open-source
license

Search this Site


Useful Links
Release Emails
9.0.0: Sep 2019
8.0.1: Aug 2019
8.0.0: Mar 2019
7.0.1: Dec 2018
7.0.0: Sep 2018
6.0.1: July 2018
5.0.2: May 2018
6.0.0: Mar 2018
5.0.1: Dec 2017
5.0.0: Sep 2017
4.0.1: Jul 2017
4.0.0: Mar 2017
3.9.1: Dec 2016
3.9.0: Sep 2016
3.8.1: July 2016
3.8.0: Mar 2016
3.7.1: Jan 2016
3.7.0: Sep 2015
3.6.2: Jul 2015
3.6.1: May 2015
3.5.2: Apr 2015
3.6: Feb 2015
Older News

Maintained by the
llvm-admin team
2019 LLVM Developers' Meeting - Bay Area

  1. About
  2. Important Dates
  3. Registration
  4. Newcomer Orientation
  5. Women in Compilers & Tools Workshop
  6. Program
  7. Round Tables
  8. Travel Grants for Students
  9. Logistics
  10. Code of Conduct
  11. Contact
About

The LLVM Developers' Meeting is a bi-annual 2 day 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.

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

Technical Talks
These 20-30 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 50-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 poster session where selected posted are on display.
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, klee, lld, 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.

For future announcements or questions: Please sign up for the LLVM Developers' Meeting list.

Important Dates

  • July 1 - Meeting Registration opens at 9AM PDT
  • July 1 - Call for Presentations
  • July 1 - Newcomer Orientation Registration opens
  • July 14 - Travel Grant Applications Open
  • July 15 - Women in Compilers and Tools Workshop registration opens
  • Aug 16 - Travel Grant Application Deadline
  • Aug 12 - Presentation Proposal Deadline
  • Aug 27 - Presentation Notification
  • Sept 6 - Travel Grant Notification
  • Sept 22 - Late Registration Starts
  • Oct 12 - Registration Closes
  • Oct 21 - Women in Compilers and Tools Workshop
  • Oct 21 - Newcomer orientation
  • Oct 22/23 - LLVM Developers' Meeting
Registration

Registration opens July 1st.

Women in Compilers and Tools Workshop

The LLVM Foundation will host a half day Women in Compilers and Tools Workshop held the day before the 2019 LLVM Developers’ Meeting - Bay Area. The workshop will be held at the Fairmont Hotel on October 21st from 12:30-5:30PM and includes a cocktail reception.

This event aims to connect women in the field of compilers and tools and provide them with ideas and techniques to overcome barriers or enhance their careers. It also is open to anyone (not just women) who are interested in increasing diversity within the LLVM community, their workplace or university.

More details will be coming soon but registration is open.

Program

The online schedule may be found here: https://llvmdevmtg2019.sched.com. Bookmark this on your mobile device.

Keynotes

Technical Talks Tutorials Student Research Competition Panels Birds of a Feather Lightning Talks Posters

Round Tables

Round Table Registration

Round tables are informal get togethers where attendees talk about a specific subject. Each group will be given a round table and a flip chart to discuss and brainstorm ideas on a specific topic. If you are interested in organizing a round table discussion, please use the link above.

Round tables may be arranged during the conference, but it is better to schedule in advance so it appears ahead of time on the online schedule. During the conference we will attempt to put the topics online, but we will also list them on a flip chart outside the room where you can add it yourself.

Tuesday, Oct 22, 10:20-11:30

  • MLIR meets LLVM: MLIR (Multi-Level IR) has been recently accepted as a sub-project in LLVM. Let's talk about what it means, what are the opportunities for LLVM users, and future evolution for the project.
  • Well-defined C++ APIs for LLVM libraries: This Round Table is for users of the LLVM C++ APIs. We will discuss next steps for formalizing the C++ APIs within LLVM, how to reduce the number of symbols exported by LLVM shared libraries, the feasibility of a stabilizing parts of the API and other related topics.

Tuesday, Oct 22, 11:30-12:40

  • Discuss llvm-libc: A good number of people have expressed interest in llvm-libc during the discussion on the RFC thread. We would like to get everyone interested in this new project to get together and discuss the direction in which we would like to take it forward.
  • VPlan: Next Steps There are a number of features people are working on and we need to make sure we don't duplicate efforts and have a common understanding of the overall design.
  • sourcekit-lsp and clangd Discuss topics related to implementing the language server protocol, code indexing, editor support, build system integration, etc. in clangd and sourcekit-lsp.
  • Debug Info for optimized code: Do you want to discuss implementation details for representing optimized code debug info? Do you have a question about LiveDebugValues? Do you wonder what's up with entry values? Or do you just wonder how to make your pass debug-info invariant?

Tuesday, Oct 22 2:00-3:10

  • Flang: Discuss flang, old flang, and Fortran

Tuesday, Oct 22 3:10-4:20

  • Improving LLVM's buildbot instance: http://lab.llvm.org:8011/console is a mess. It has too many builders, yet is missing builders for some platforms. It's slow to load, many of the builders are perma-red, many take hours to cycle, the buildbot page itself is slow to load, etc. Can we improve this?
  • OpenMP in LLVM: Opportunity to discuss anything OpenMP related that happens under the LLVM umbrella
  • Challenges using LLVM for GPU compilation: Canonicalization vs. GPUs: Type mutation, Control flow mutation (and that graphics shaders are more sensitive to this.), Divergence/reconvergence sensitivity, Address-space awareness
  • End-to-end Testing Discussion of end-to-end testing; what kinds of tests we want; logistics
  • Security Hardening Features in clang: We will discuss the status of security hardening features in clang, (e.g. -fstack-clash-protection, -D_FORTIFY_SOURCE, and others) look at how clang compares to gcc and talk about future work in this area.
  • LLVM for Embedded Baremetal Targets: We will discuss how to build and test LLVM based toolchains that work for Baremetal targets.

Tuesday, Oct 22, 4:40-5:50

  • SYCL: Let's talk about SYCL -- the programming model, the open standard, the effort to add SYCL support to clang, etc.
  • Upstreaming SYCL C++: SYCL is a single-source C++ standard from Khronos Group (OpenGL, Vulkan, OpenCL, SPIR...) for heterogeneous computing targeting various accelerators (CPU, GPU, DSP, FPGA...). There are several implementations available and one has even started to be upstreamed into Clang/LLVM: https://github.com/intel/llvm
    This is a huge collaborative effort and a great opportunity to have wide & strong support for modern C++ on a wide range of accelerators from many vendors. Come to learn about SYCL, how to help reviewing the patches, how it interacts with existing off-loading support, OpenMP, OpenCL, CUDA, address spaces, SPIR-V...
  • Loop Optimizations in LLVM: Discuss current problems, progress and future plans for optimizing loops, existing passes and new passes and analysis being worked on.
  • full restrict support in llvm: Now that patches for full restrict are available, this roundtable gives a chance to discuss the design and the patches in person.

Wednesday, Oct 23 10:45-11:55

  • Complex Types in LLVM: A discussion on supporting native complex types in LLVM IR for performance and diagnostics.
  • Development practices to help avoid security vulnerabilities in llvm: The goal for this round table is to explore what development practices the LLVM community could consider adopting to reduce the probability of security vulnerabilities in some or all of its components.Let's get together at this round table to discuss which development practices - and to which degree - could be good to adopt for which LLVM components. A few examples that could kick off the discussion are: • Using static analyzers. • Using code standard checkers (e.g. clang-tidy -checks=cert-*,bugprone-*,llvm-*). • Using fuzzers more extensively (oss-fuzz does fuzzing on some LLVM components, but do bug reports get reacted on?). • Requiring full code coverage by unit tests on code that is newly added. • Making certain build options on by default (e.g. stack protection). Many of these techniques require buy-in from the whole community to get accepted - a round-table discussion is hopefully a first step towards understanding cost/benefit tradeoffs.
  • CMake in LLVM: Discuss the current state of CMake and future areas for improvement.

Wednesday, Oct 23 11:55-12:30

  • Interpreting C++: "C++ JITs and REPLs are useful in number of areas such as education and science. The LLDB's expression evaluator, Cling and ClangJIT are based on Clang and its incremental processing facility. The C++ interpreters target to solve different sets of issues, however they share common requirements.
    We would like to use the round table to discuss common requirements when interpreting C++. We would like to invite developers and users interested in interpreting C++. We would like to discuss a possible way forward for implementing JIT and REPL support infrastructure in Clang and LLVM."
  • LLVM Releases: Discuss the current release process and possible areas for improvement.
  • Vector Predication: Support for predicated SIMD/vector in LLVM is lacking. At this table, we are discussing concrete steps to change that.

Wednesday, Oct 23 1:45-2:55

  • Floating point: Discussions related to FENV_ACCESS support, fast math, FMA, complex, etc.
  • ClangBuiltLinux: Building the Linux kernel with Clang and LLVM utils

Wednesday, Oct 23 2:55-4:00

  • GitHub Next-step: bug-tracker (GitHub issues?) & workflows (pre-merge testing, pull-request, etc.): "We're almost on GitHub! It is a good opportunity to brainstorm on possible evolutions of the workflow and the infrastructure. There are opportunities around being able to run builds and test on code before pushing, and the possibility of using pull-requests either for the purpose of pre-merge testing or for code reviews! Also is bugzilla still providing what we want to track issues? Should we consider GitHub issues? Are there other options?"
  • ASTImporter: Discuss future work and direction of ASTImporter
  • State of the GN build: LLVM's GN build is an (unsupported!) faster alternative to the CMake build. Try it out, learn about the current state, wallow in build system arcana.
  • Clang Static Analyzer: Let's talk about where we are and how we want to move forward with the Static Analyzer.

Wednesday, Oct 23 5:00-5:35

  • GSoC: LLVM Google Summer of Code: organization, ideas, projects, etc.
  • Scalable Vector Extension: Discuss current progress and forward plans for both SVE and RiscV implementations, focusing on agreed IR representations more than looking at each back-end independently.

Wednesday, Oct 23 5:35-6:10

Travel Grants for Students

The LLVM Foundation sponsors student travel to attend the LLVM Developers' Meeting. Travel grants cover some or all of travel related expenses. This program is open to full time undergraduate and graduate students.

To apply for a travel grant, please fill out this form by August 16th.

Logistics

We have reserved a block of rooms at the Fairmont a block away from the San Jose convention center at a $309.00/night rate. Please use this link for your reservation. Guest rooms will be available on a first come, first serve basis until October 1, 2019.

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 Tanya Lattner

Diamond Sponsors:

Platinum Sponsors:

Gold Sponsors:

Corporate Supporters

Thank you to our sponsors!