<!--#include virtual="../../header.incl" -->

<div class="www_sectiontitle">2019 European LLVM developers' meeting</div>
<div style="float:left; width:68%;">
<br>
<div style="width:100%;"> 
<table><tr>
<td valign="top">
<ol>
        <li><a href="#about">About</a></li>
	<li><a href="#wict">Women in Compilers and Tools</a></li>
        <li><a href="#talks">Program</a></li>
        <li><a href="#rounds">Round Tables</a></li>
        <li><a href="#grant">Travel Grants for Students</a></li>
        <li><a href="#contact">Contact</a></li>
</ol>
</td>
<td valign="top">
<ul>
   <li><b>Conference Dates</b>: April 8-9, 2019</li>
   <li><b>Location</b>: <a href="https://www.leplaza-brussels.be/en/">
       Le Plaza Brussels, 118 - 126 boulevard Adolphe Max, 1000 Brussels, Belgium</a></li>
    <li><b>Women in Compilers and Tools</b>: April 7, 2019 1:00-6:30pm</li>
<li><b>Location</b>: <a href="https://www.leplaza-brussels.be/en/">
       Le Plaza Brussels, 118 - 126 boulevard Adolphe Max, 1000 Brussels, Belgium</a></li>
</ul>
</td>
</tr></table>
</div>

<div class="www_sectiontitle" id="about">About</div>

<p>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.</p>

<p>What can you can expect at an LLVM developers' meeting?
<dl>
<dt><b>Technical Talks</b></dt>
<dd>These 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.</li>
<br></dd>

<dt><b>Tutorials</b></dt>
<dd>Tutorials are 60 minute sessions that dive down deep into a technical
topic. Expect in depth examples and explanations.</dd>

<dt><b>Lightning Talks</b></dt>
<dd>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.</dd>

<dt><b>Birds of a Feather (BoF)</b></dt>
<dd>BoF sessions are more formal guided discussions about a specific topic. The
presenter typically has slides to guide the discussion. The audience is given
the opportunity to participate in the discussion.
</dd>

<dt><b>Student Research Competition</b> </dt>
<dd>Students present their research using LLVM or related subproject. These are
usually 25 minute technical presentations with Q&amp;A. The audience will vote
at the end for the winning presentation. Students also present their research
during the poster session.</dd>

<dt><b>Poster Session</b></dt>
<dd>An hour long poster session where selected posted are on display.</dd>

<dt><b>Round Table Discussions</b> </dt>
<dd>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.</dd>

<dt><b>Evening Reception</b> </dt>
<dd>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.</dd>
</dl>
</p>

<p>What types of people attend?
<ul>
<li>Active developers of projects in the LLVM Umbrella
(LLVM core, Clang, LLDB, libc++, compiler_rt, klee, lld, etc).</li>
<li>Anyone interested in using these as part of another project.</li>
<li>Students and Researchers</li>
<li>Compiler, programming language, and runtime enthusiasts.</li>
<li>Those interested in using compiler and toolchain technology in novel
and interesting ways.</li>
</ul>
</p>

<p>The LLVM developers' meetings strive to be the <i>best conference</i> to
meet other LLVM developers and users.</p>

<p>For future announcements or questions: please sign up for the
<a href="http://lists.llvm.org/mailman/listinfo/llvm-devmeeting"> LLVM developers' meeting list</a>.
</p>

<div class="www_sectiontitle" id="wict">Women in Compilers and Tools Workshop</div>
<p>
After several Women in Compiler's and Tools events that generated amazing
discussions and ideas, it is now time to turn the focus on action and change.
One such area that has been consistently brought up in conversations between
WiCT attendees, LLVM Developers, and students is how the LLVM project is viewed
from a newcomer's perspective. While our community is open and inviting, our
documentation, tutorials, and web presence is challenging for a newcomer to
navigate and get involved. Changing this is critical to the long term success
of the LLVM project as it is not only a barrier for more women to learn about
LLVM and compilers, but a barrier to everyone. The focus of this workshop will
be on documentation and removing barriers for newcomers.</p>
<p>
If you are interested in helping make the LLVM Project more approachable for
newcomers and increasing diversity, then please attend this workshop!
</p>

<div class="www_sectiontitle" id="talks">Program</div>

<b>Keynote</b>
<ul>
<li><a href="talks.html#Keynote_1">
  MLIR: Multi-Level Intermediate Representation for Compiler Infrastructure</a>
  [ <a href="https://www.youtube.com/watch?v=qzljG6DKgic">Video</a> ]
  [ <a href="slides/Keynote-ShpeismanLattner-MLIR.pdf">Slides</a> ]
  <i>Tatiana Shpeisman (Google), Chris Lattner (Google)</i>
</li>
</ul>

<b>Technical talks</b>
<ul>
<li><a href="talks.html#Talk_1">
  Switching a Linux distribution&#39;s main toolchains to LLVM/Clang</a>
  [ <a href="https://youtu.be/QinoajSKQ1k">Video</a> ]
  [ <a href="slides/TechTalk-Rosenkranzer-Switching_a_Linux_distro.pdf">Slides</a> ]
  <i>Bernhard Rosenkr&auml;nzer (Linaro, OpenMandriva, LinDev)</i>
</li>
<li><a href="talks.html#Talk_2">
  Just compile it: High-level programming on the GPU with Julia</a>
  [ <a href="https://youtu.be/Fz-ogmASMAE">Video</a> ]
  [ <a href="slides/TechTalk-Besard-Just_compile_it_high_level_programming_on_the_GPU_with_Julia.pdf">Slides</a> ]
  <i>Tim Besard (Ghent University)</i>
</li>
<li><a href="talks.html#Talk_3">
  The Future of AST Matcher-based Refactoring</a>
  [ <a href="https://youtu.be/yqi8U8Q0h2g">Video</a> ]
  [ <a href="slides/TechTalk-Kelly-The_future_of_AST_matcherbased_refactoring.pdf">Slides</a> ]
  <i>Stephen Kelly</i>
</li>
<li><a href="talks.html#Talk_4">
  A compiler approach to Cyber-Security</a>
  [ <a href="https://youtu.be/LPj4phdJABw">Video</a> ]
  [ <a href="slides/TechTalk-Ferriere-A_compiler_approach_to_cybersecurity.pdf">Slides</a> ]
  <i>Fran&ccedil;ois de Ferri&egrave;re (STMicroelectronics)</i>
</li>
<li><a href="talks.html#Talk_5">
  Compiler Optimizations for (OpenMP) Target Offloading to GPUs</a>
  [ <a href="https://youtu.be/3AbS82C3X30">Video</a> ]
  [ <a href="slides/TechTalk-Doerfert-Compiler_optimization_for_OpenMP_accelerator_offloading.pdf">Slides</a> ]
  <i>Johannes Doerfert (Argonne National Laboratory), Hal Finkel (Argonne National Laboratory)</i>
</li>
<li><a href="talks.html#Talk_6">
  Handling massive concurrency: Development of a programming model for GPU and CPU</a>
  [ <a href="https://youtu.be/cyK-WIwnlUk">Video</a> ]
  [ <a href="slides/TechTalk-Liedtke-Handling_massive_concurrency.pdf">Slides</a> ]
  <i>Matthias Liedtke (SAP)</i>
</li>
<li><a href="talks.html#Talk_7">
  Automated GPU Kernel Fusion with XLA</a>
  [ <a href="https://youtu.be/u3cWOd99xX0">Video</a> ]
  [ <a href="slides/TechTalk-Joerg-Automated_GPU_Kernel_Fusion_with_XLA.pdf">Slides</a> ]
  <i>Thomas Joerg (Google)</i>
</li>
<li><a href="talks.html#Talk_8">
  The Helium Haskell compiler and its new LLVM backend</a>
  [ <a href="https://youtu.be/x6CBks1paF8">Video</a> ]
  [ <a href="slides/TechTalk-de-Wolff-Helium_Haskell_compiler.pdf">Slides</a> ]
  <i>Ivo Gabe de Wolff (University of Utrecht)</i>
</li>
<li><a href="talks.html#Talk_9">
  Testing and Qualification of Optimizing Compilers for Functional Safety</a>
  [ <a href="https://youtu.be/nSfT4oND9dU">Video</a> ]
  [ <a href="slides/TechTalk-Cabrelles-Testing_and_qualification_of_optimizing_compilers_for_functional_safety.pdf">Slides</a> ]
  <i>Jos&eacute; Luis March Cabrelles (Solid Sands)</i>
</li>
<li><a href="talks.html#Talk_10">
  Improving Debug Information in LLVM to Recover Optimized-out Function Parameters</a>
  [ <a href="https://youtu.be/ih5v65K10M8">Video</a> ]
  [ <a href="slides/TechTalk-Prica-Improving_LLVM_DebugInfo.pdf">Slides</a> ]
  <i>Nikola Prica (RT-RK), Djordje Todorovic (RT-RK), Ananthakrishna Sowda (CISCO), Ivan Baev (CISCO)</i>
</li>
<li><a href="talks.html#Talk_11">
  LLVM IR in GraalVM: Multi-Level, Polyglot Debugging with Sulong</a>
  [ Video ]
  [ <a href="slides/TechTalk-Kreindl-LLVM_IR_in_GraalVM.pdf">Slides</a> ]
  <i>Jacob Kreindl (Johannes Kepler University Linz)</i>
</li>
<li><a href="talks.html#Talk_12">
  LLDB Reproducers</a>
  [ <a href="https://youtu.be/ygdzXnfyvbg">Video</a> ]
  [ <a href="slides/TechTalk-Devlieghere-LLDB_reproducers.pdf">Slides</a> ]
  <i>Jonas Devlieghere (Apple)</i>
</li>
<li><a href="talks.html#Talk_13">
  Sulong: An experience report of using the &quot;other end&quot; of LLVM in GraalVM.</a>
  [ < a href="https://youtu.be/zvsR90T_4ME">Video</a> ]
  [ <a href="slides/TechTalk-Schatz-Sulong_an_experience_report.pdf">Slides</a> ]
  <i>Roland Schatz (Oracle Labs), Josef Eisl (Oracle Labs)</i>
</li>
<li><a href="talks.html#Talk_14">
  SYCL compiler: zero-cost abstraction and type safety for heterogeneous computing</a>
  [ <a href="https://youtu.be/rfg19iODkhI">Video</a> ]
  [ <a href="slides/TechTalk-Savonichev-SYCL_compiler.pdf">Slides</a> ]
  <i>Andrew Savonichev (Intel)</i>
</li>
<li><a href="talks.html#Talk_15">
  Handling all Facebook requests with JITed C++ code</a>
  [ <a href="https://youtu.be/01WoFnyw6zE">Video</a> ]
  [ <a href="slides/TechTalk-Guo-Zhou-Handling_all_Facebook_requests_with_JITed_C++_code.pdf">Slides</a> ]
  <i>Huapeng Zhou (Facebook), Yuhan Guo (Facebook)</i>
</li>
<li><a href="talks.html#Talk_16">
  clang-scan-deps: Fast dependency scanning for explicit modules</a>
  [ <a href="https://youtu.be/Ptr6e4CVTd4">Video</a> ]
  [ <a href="slides/TechTalk-Lorenz-clang-scan-deps_Fast_dependency_scanning_for_explicit_modules.pdf">Slides</a> ]
  <i>Alex Lorenz (Apple), Michael Spencer (Apple)</i>
</li>
<li><a href="talks.html#Talk_17">
  Clang tools for implementing cryptographic protocols like OTRv4</a>
  [ <a href="https://youtu.be/TthVG_GdzHU">Video</a> ]
  [ <a href="slides/TechTalk-Celi-Clang_tools_for_implementing_cryptographic_protocols_like_OTRv4.pdf">Slides</a> ]
  <i>Sofia Celi (Centro de Autonomia Digital)</i>
</li>
<li><a href="talks.html#Talk_18">
  Implementing the C++ Core Guidelines&#39;; Lifetime Safety Profile in Clang</a>
  [ <a href="https://youtu.be/VynWyOIb6Bk">Video</a> ]
  [ <a href="slides/TechTalk-Horvath-Implementing_the_C++_Core_Guidelines_Lifetime.pdf">Slides</a> ]
  <i>Gabor Horvath (Eotvos Lorand University), Matthias Gehre (Silexica GmbH), Herb Sutter (Microsoft)</i>
</li>
<li><a href="talks.html#Talk_19">
  Changes to the C++ standard library for C++20</a>
  [ <a href="https://youtu.be/coXGSfUak-Q">Video</a> ]
  [ <a href="slides/TechTalk-Clow-Changes_to_the_C++_standard_library_for_C++20.pdf">Slides</a> ]
  <i>Marshall Clow (CppAlliance)</i>
</li>
<li><a href="talks.html#Talk_20">
  Adventures with RISC-V Vectors and LLVM</a>
  [ <a href="https://youtu.be/dyrh2ZZX8EY">Video</a> ]
  [ <a href="slides/TechTalk-Kruppe-Espasa-RISC-V_Vectors_and_LLVM.pdf">Slides</a> ]
  <i>Robin Kruppe (TU Darmstadt), Roger Espasa (Esperanto Technologies)</i>
</li>
<li><a href="talks.html#Talk_21">
  A Tale of Two ABIs: ILP32 on AArch64</a>
  [ <a href="https://youtu.be/8RVRQrf15yY">Video</a> ]
  [ <a href="slides/TechTalk-Northover-A_tale_of_two_ABIs_ILP32_on_AArch64.pdf">Slides</a> ]
  <i>Tim Northover (Apple)</i>
</li>
<li><a href="talks.html#Talk_22">
  LLVM Numerics Improvements</a>
  [ <a href="https://youtu.be/9pqobu3zQ7E">Video</a> ]
  [ <a href="slides/TechTalk-Berg-LLVM_numerics_improvements.pdf">Slides</a> ]
  <i>Michael Berg (Apple), Steve Canon (Apple)</i>
</li>
<li><a href="talks.html#Talk_23">
  DOE Proxy Apps: Compiler Performance Analysis and Optimistic Annotation Exploration</a>
  [ <a href="https://youtu.be/slrU-mz8if4">Video</a> ]
  [ <a href="slides/TechTalk-Homerding-DOE_proxy_apps_compiler_performance_analysis_and_optimistic_annotation_exploration.pdf">Slides</a> ]
  <i>Brian Homerding (Argonne National Laboratory), Johannes Doerfert (Argonne National Laboratory)</i>
</li>
<li><a href="talks.html#Talk_24">
  Loop Fusion, Loop Distribution and their Place in the Loop Optimization Pipeline</a>
  [ <a href="https://youtu.be/-JQr9aNagQo">Video</a> ]
  [ <a href="slides/TechTalk-Barton-Loop_fusion_loop_distribution_and_their_place_in_the_loop_optimization_pipeline.pdf">Slides</a> ]
  <i>Kit Barton (IBM), Johannes Doerfert (Argonne National Lab), Hal Finkel (Argonne National Lab), Michael Kruse (Argonne National Lab)</i>
</li>
</ul>

<b>Tutorials</b>
<ul>
<li><a href="talks.html#Tutorial_1">
  Tutorial: Building a Compiler with MLIR</a>
  [ <a href="https://www.youtube.com/watch?v=cyICUIZ56wQ">Video</a> ]
  [ <a href="slides/Tutorial-AminiVasilacheZinenko-MLIR.pdf">Slides</a> ]
  <i>Amini Mehdi (Google), Nicolas Vasilache (Google), Alex Zinenko (Google)</i>
</li>
<li><a href="talks.html#Tutorial_2">
  Building an LLVM-based tool: lessons learned</a>
  [ <a href="https://youtu.be/Yvj4G9B6pcU">Video</a> ]
  [ <a href="slides/Tutorial-Denisov-Building_an_LLVM_based_tool.pdf">Slides</a> ]
  <i>Alex Denisov</i>
</li>
<li><a href="talks.html#Tutorial_3">
  LLVM IR Tutorial - Phis, GEPs and other things, oh my!</a>
  [ <a href="https://youtu.be/m8G_S5LwlTo">Video</a> ]
  [ <a href="slides/Tutorial-Bridgers-LLVM_IR_tutorial.pdf">Slides</a> ]
  <i>Vince Bridgers (Intel Corporation), Felipe de Azevedo Piovezan (Intel Corporation)</i>
</li>
</ul>

<b>Student Research Competition</b>
<ul>
<li><a href="talks.html#SRC_1">
  Safely Optimizing Casts between Pointers and Integers</a>
  [ <a href="https://youtu.be/CPokKMqAVdY">Video</a> ]
  [ <a href="slides/SRC-Lee-Safely_optimizing_casts_between_pointers_and_integers.pdf">Slides</a> ]
  <i>Juneyoung Lee (Seoul National University, Korea), Chung-Kil Hur (Seoul National University, Korea), Ralf Jung (MPI-SWS, Germany), Zhengyang Liu (University of Utah, USA), John Regehr (University of Utah, USA), Nuno P. Lopes (Microsoft Research, UK)</i>
</li>
<li><a href="talks.html#SRC_2">
  An alternative OpenMP Backend for Polly</a>
  [ <a href="https://youtu.be/-j9qjfTwt3k">Video</a> ]
  [ <a href="slides/SRC-Halkenhauser-An_alternative_OpenMP_backend_for_Polly.pdf">Slides</a> ]
  <i>Michael Halkenh&auml;user (TU Darmstadt)</i>
</li>
<li><a href="talks.html#SRC_3">
  Implementing SPMD control flow in LLVM using reconverging CFGs</a>
  [ <a href="https://youtu.be/8K8ClHoZzHw">Video</a> ]
  [ <a href="slides/SRC-Wahlster-Implementing_SPMD_control_flow_in_LLVM_using_reconverging_CFGs.pdf">Slides</a> ]
  <i>Fabian Wahlster (Technische Universit&auml;t M&uuml;nchen), Nicolai
  H&auml;hnle (Advanced Micro Devices)</i>
</li>
<li><a href="talks.html#SRC_4">
  Function Merging by Sequence Alignment</a>
  [ <a href="https://youtu.be/sOCFYfF3iwE">Video</a> ]
  [ <a href="slides/SRC-Rocha-Function_merging_by_sequence_alignment.pdf">Slides</a> ]
  <i>Rodrigo Rocha (University of Edinburgh), Pavlos Petoumenos (University of Edinburgh), Zheng Wang (Lancaster University), Murray Cole (University of Edinburgh), Hugh Leather (University of Edinburgh)</i>
</li>
<li><a href="talks.html#SRC_5">
  Compilation and optimization with security annotations</a>
  [ <a href="https://youtu.be/rMOfcvMYev8">Video</a> ]
  [ <a href="slides/SRC-TuanVu-Compilation_and_optimization_with_security_annotations.pdf">Slides</a> ]
  <i>Son Tuan Vu (LIP6), Karine Heydemann (LIP6), Arnaud de Grandmaison (ARM), Albert Cohen (Google)</i>
</li>
<li><a href="talks.html#SRC_6">
  Adding support for C++ contracts to Clang</a>
  [ <a href="https://youtu.be/FpCFl-JHcrs">Video</a> ]
  [ <a href="slides/SRC-Lopez-Gomez-Adding_support_for_C++_contracts_to_clang.pdf">Slides</a> ]
  <i>Javier L&oacute;pez-G&oacute;mez (University Carlos III of Madrid), J.
    Daniel Garc&iacute;a (University Carlos III of Madrid)</i>
</li>
</ul>

<b>Lightning talks</b>
<ul>
<li><a href="talks.html#LightningTalk_1">
  LLVM IR Timing Predictions: Fast Explorations via lli</a>
  [ Video ]
  [ Slides ]
  <i>Alessandro Cornaglia (FZI - Research Center for Information Technology)</i>
</li>
<li><a href="talks.html#LightningTalk_2">
  Simple Outer-Loop-Vectorization == LoopUnroll-And-Jam + SLP</a>
  [ Video ]
  [ <a href="slides/Lightning-Das-AMD_OLV.pdf">Slides</a> ]
  <i>Dibyendu Das (AMD)</i>
</li>
<li><a href="talks.html#LightningTalk_3">
  Clacc 2019: An Update on OpenACC Support for Clang and LLVM</a>
  [ Video ]
  [ <a href="slides/Lightning-Denny-clacc.pdf">Slides</a> ]
  <i>Joel E. Denny (Oak Ridge National Laboratory), Seyong Lee (Oak Ridge National Laboratory), Jeffrey S. Vetter (Oak Ridge National Laboratory)</i>
</li>
<li><a href="talks.html#LightningTalk_4">
  Targeting a statically compiled program repository with LLVM</a>
  [ Video ]
  [ <a href="slides/Lightning-Camp-Program_Repo.pdf">Slides</a> ]
  <i>Phil Camp (SN Systems (Sony Interactive Entertainment)), Russell Gallop (SN Systems (Sony Interactive Entertainment))</i>
</li>
<li><a href="talks.html#LightningTalk_5">
  Does the win32 clang compiler executable really need to be over 21MB in size?</a>
  [ Video ]
  [ <a href="slides/Lightning-Gallop-Does_win32_clang_compiler.pdf">Slides</a> ]
  <i>Russell Gallop (SN Systems), Greg Bedwell (SN Systems)</i>
</li>
<li><a href="talks.html#LightningTalk_6">
  Resolving the almost decade old checker dependency issue in the Clang Static Analyzer</a>
  [ Video ]
  [ <a href="slides/Lightning-Umann-Resolving_the_almost.pdf ">Slides</a> ]
  <i>Krist&oacute;f Umann (Ericsson Hungary, E&ouml;tv&ouml;s Lor&aacute;nd University)</i>
</li>
<li><a href="talks.html#LightningTalk_7">
  Adopting LLVM Binary Utilities in Toolchains</a>
  [ Video ]
  [ <a href="slides/Lightning-Rupprecht-Adopting_LLVM_binary_utilities.pdf">Slides</a> ]
  <i>Jordan Rupprecht (Google)</i>
</li>
<li><a href="talks.html#LightningTalk_8">
  Multiplication and Division in the Range-Based Constraint Manager</a>
  [ Video ]
  [ <a href="slides/Lightning-Balogh-Multiplication_and_Division_in_the_Range-Based_Constraint_Manager.pdf">Slides</a> ]
  <i>&Aacute;d&aacute;m Balogh (Ericsson Hungary Ltd.)</i>
</li>
<li><a href="talks.html#LightningTalk_9">
  Statistics Based Checkers in the Clang Static Analyzer</a>
  [ Video ]
  [ <a href="slides/Lightning-Balogh-Statistics_based_checkers_in_the_Clang_Static_Analyzer.pdf">Slides</a> ]
  <i>&Aacute;d&aacute;m Balogh (Ericsson Hungary Ltd.)</i>
</li>
<li><a href="talks.html#LightningTalk_10">
  Flang Update</a>
  [ Video ]
  [ <a href="slides/Lightning-Scalpone-Flang_update.pdf">Slides</a> ]
  <i>Steve Scalpone (NVIDA / PGI / Flang)</i>
</li>
<li><a href="talks.html#LightningTalk_11">
  Swinging Modulo Scheduling together with Register Allocation</a>
  [ <a href="https://youtu.be/o4R3SqyNbqU">Video</a> ]
  [ Slides ]
  <i>Lama Saba (Intel)</i>
</li>
<li><a href="talks.html#LightningTalk_12">
  LLVM for the Apollo Guidance Computer</a>
  [ <a href="https://youtu.be/k9D2yanT6Oo">Video</a> ]
  [ Slides ]
  <i>Lewis Revill (University of Bath)</i>
</li>
<li><a href="talks.html#LightningTalk_13">
  Catch dangling inner pointers with the Clang Static Analyzer</a>
  [ Video ]
  [ <a href="slides/Lightning-Kovacs-Dangling_pointer_checker.pdf">Slides</a> ]
  <i>R&eacute;ka Kov&aacute;cs (E&ouml;tv&ouml;s Lor&auml;nd University)</i>
</li>
<li><a href="talks.html#LightningTalk_14">
  Cross translation unit test case reduction</a>
  [ Video ]
  [ <a href="slides/Lightning-Kovacs-Cross_TU_reduction.pdf">Slides</a> ]
  <i>R&eacute;ka Kov&aacute;cs (E&ouml;tv&ouml;s Lor&auml;nd University)</i>
</li>
</ul>

<b>BoFs</b>
<ul>
<li><a href="talks.html#BoF_1">
  RFC: Towards Vector Predication in LLVM IR</a>
  <i>Simon Moll (Saarland University), Sebastian Hack (Saarland University)</i>
</li>
<li><a href="talks.html#BoF_2">
  IPO --- Where are we, where do we want to go?</a>
  <i>Johannes Doerfert (Argonne National Laboratory), Kit Barton (IBM Toronto Lab)</i>
</li>
<li><a href="talks.html#BoF_3">
  LLVM binutils</a>
  [ <a href="http://lists.llvm.org/pipermail/llvm-dev/2019-April/132032.html">Notes</a> ]
  [ <a href="slides/BoF-HendersonRupprecht-LLVM_binutils.pdf">Slides</a> ]
  <i>James Henderson (SN Systems (Sony Interactive Entertainment)), Jordan Rupprecht (Google)</i>
</li>
<li><a href="talks.html#BoF_4">  RFC: Reference OpenCL Runtime library for LLVM</a>
  <i>Andrew Savonichev (Intel), Alexey Sachkov (Intel)</i>
</li>
<li><a href="talks.html#BoF_5">
  LLVM Interface Stability Guarantees BoF</a>
  <i>Stephen Kelly</i>
</li>
<li><a href="talks.html#BoF_6">
  Clang Static Analyzer BoF</a>
  <i>Artem Dergachev (Apple), Devin Coughlin (Apple), Gabor Horvath (Eotvos Lorand University)</i>
</li>
<li><a href="talks.html#BoF_7">
  LLVM Numerics Improvements</a>
  <i>Michael Berg (Apple), Steve Canon (Apple)</i>
</li>
<li><a href="talks.html#BoF_8">
  LLVM Foundation BoF</a>
  <i>LLVM Foundation Board of Directors</i>
</li>
</ul>

<b>Posters</b>
<ul>
<li><a href="talks.html#Poster_1">
  Clava: C/C++ source-to-source from CMake using LARA</a>
  [ <a href="slides/Poster-Bispo-Clava_CC++_source_to_source_from_CMake_using_LARA.pdf">Poster</a> ]
  <i>Jo&atilde;o Bispo (FEUP/INESCTEC)</i>
</li>
<li><a href="talks.html#Poster_2">
  Safely Optimizing Casts between Pointers and Integers</a>
  [ <a href="slides/Poster-Lee-Safely_optimizing_casts_between_pointers_and_integers.pdf">Poster</a> ]
  <i>Juneyoung Lee (Seoul National University, Korea), Chung-Kil Hur (Seoul National University, Korea), Ralf Jung (MPI-SWS, Germany), Zhengyang Liu (University of Utah, USA), John Regehr (University of Utah, USA), Nuno P. Lopes (Microsoft Research, UK)</i>
</li>
<li><a href="talks.html#Poster_3">
  Scalar Evolution Canon: Click! Canonicalize SCEV and validate it by Z3 SMT solver!</a>
  [ Poster ]
  <i>Lin-Ya Yu (Xilinx), Alexandre Isoard (Xilinx)</i>
</li>
<li><a href="talks.html#Poster_4">
  Splendid GVN: Partial Redundancy Elimination for Algebraic Simplification</a>
  [ <a href="slides/Poster-Her-SplendidGVN_Partial_redundancy_elimination.pdf">Poster</a> ]
  <i>Li-An Her (National Tsing Hua University), Jenq-Kuen Lee (National Tsing Hua University)</i>
</li>
<li><a href="talks.html#Poster_5">
  An alternative OpenMP Backend for Polly</a>
  [ <a href="slides/Poster-Halkenhauser-An_alternative_OpenMP_backend_for_Polly.pdf">Poster</a> ]
  <i>Michael Halkenh&auml;user (TU Darmstadt)</i>
</li>
<li><a href="talks.html#Poster_6">
  Does the win32 clang compiler executable really need to be over 21MB in size?</a>
  [ <a href="slides/Poster-Gallop-Does_the_win32_clang_compiler_reaaly_nee_to_be_over_21MB_in_size.png">Poster</a> ]
  <i>Russell Gallop (SN Systems), G Bedwell (SN Systems)</i>
</li>
<li><a href="talks.html#Poster_7">
  Enabling Multi- and Cross-Language Verification with LLVM</a>
  [ <a href="slides/Poster-Garzella-Enabling_multi_and_cross_language_verification_with_LLVM.pdf">Poster</a> ]
  <i>Jack J. Garzella (University of Utah), Marek Baranowski (University of Utah),
    Shaobo He (University of Utah), Zvonimir Rakamaric (University of Utah)</i>
</li>
<li><a href="talks.html#Poster_8">
  Instruction Tracing and dynamic codegen analysis to identify unique llvm performance issues.</a>
  [ <a href="slides/Poster-Biplop-Tracing.pdf">Poster</a> ]
  <i>Biplob (IBM)</i>
</li>
<li><a href="talks.html#Poster_9">
  Handling all Facebook requests with JITed C++ code</a>
  [ <a href="slides/Poster-Zhou-Handling_all_Facebook_requests_with_JITed_C++_code.pdf">Poster</a> ]
  <i>Huapeng Zhou (Facebook), Yuhan Guo (Facebook)</i>
</li>
<li><a href="talks.html#Poster_10">
  Implementing SPMD control flow in LLVM using reconverging CFGs</a>
  [ <a href="slides/Poster-Wahlster-Implementing_SPMD_control_flow_in_LLVM_using_reconverging_CFG.pdf">Poster</a> ]
  <i>Fabian Wahlster (Technische Universit&auml;t M&uuml;nchen), Nicolai H&auml;hnle (Advanced Micro Devices)</i>
</li>
<li><a href="talks.html#Poster_11">
  LLVM for the Apollo Guidance Computer</a>
  [ Poster ]
  <i>Lewis Revill (University of Bath)</i>
</li>
<li><a href="talks.html#Poster_12">
  LLVM Miner: Text Analytics based Static Knowledge Extractor</a>
  [ <a href="slides/Poster-Hameeza-LLVM_Miner_Text_Analytics_based_Static_Knowledge_Extractor.pdf">Poster</a> ]
  <i>Hameeza Ahmed (NED University of Engineering and Technology), Muhammad Ali Ismail (NED University of Engineering and Technology)</i>
</li>
<li><a href="talks.html#Poster_13">
  Function Merging by Sequence Alignment</a>
  [ <a href="slides/Poster-Rocha-Function_merging_by_sequence_alignment.pdf">Poster</a> ]
  <i>Rodrigo Rocha (University of Edinburgh), Pavlos Petoumenos (University of Edinburgh), Zheng Wang (Lancaster University), Murray Cole (University of Edinburgh), Hugh Leather (University of Edinburgh)</i>
</li>
<li><a href="talks.html#Poster_14">
  Compilation and optimization with security annotations</a>
  [ <a href="slides/Poster-TuanVu-Compilation_and_optimization_with_security_annotations.pdf">Poster</a> ]
  <i>Son Tuan Vu (LIP6), Karine Heydemann (LIP6), Arnaud de Grandmaison (ARM), Albert Cohen (Google)</i>
</li>
<li><a href="talks.html#Poster_16">
  Leveraging Polyhedral Compilation in Chapel Compiler</a>
  [ <a href="slides/Poster-Yerawar-ChapelPolly.pdf">Poster</a> ]
  <i>Sahil Yerawar (IIT Hyderabad), Siddharth Bhat (IIIT Hyderabad), Michael Ferguson (Cray Inc.), Philip Pfaffe (Karlsruhe Institute of Technology), Ramakrishna Upadrasta (IIT Hyderabad)</i>
</li>
<li><a href="talks.html#Poster_17">
  LLVM on AVR - textual IR as a powerful tool for making &quot;impossible&quot; compilers</a>
  [ Poster ]
  <i>Carl Peto (Swift for Arduino/Petosoft)</i>
</li>
<li><a href="talks.html#Poster_18">
  Vectorizing Add/Sub Expressions with SLP</a>
  [ <a href="slides/Poster-Porpodas-Supernode_SLP.pdf">Poster</a> ]
  <i>Vasileios Porpodas (Intel Corporation, USA), Rodrigo C. O. Rocha (University
  of Edinburgh, UK), Evgueni Brevnov (Intel Corporation, USA), Lu&iacute;s F.
  W. G&oacute;es (PUC Minas, Brazil), Timothy Mattson (Intel Corporation,
USA)</i>
</li>
<li><a href="talks.html#Poster_19">
  Adding support for C++ contracts to Clang</a>
  [ <a href="slides/Poster-Lopez-Gomez-Adding_support_for_C++_contracts_to_Clang.pdf">Poster</a> ]
  <i>Javier L&oacute;pez-G&oacute;mez (University Carlos III of Madrid), J.
  Daniel Garc&iacute;a (University Carlos III of Madrid)</i>
</li>
<li><a href="talks.html#Poster_20">
  Optimizing Nondeterminacy: Exploiting Race Conditions in Parallel Programs</a>
  [ Poster ]
  <i>William S. Moses (MIT CSAIL)</i>
</li>
</ul>

<div class="www_sectiontitle" id="rounds">Round Tables</div>

<table>
<tr><td>Time Slot</td><td>Topic</td></tr>
<tr><td>April 8, 11:40-12:05</td><td>LLVM/Clang & OpenMP</td></tr>
<tr><td>April 8, 11:40-12:05</td><td>Spectre - Mitigations and APIs in LLVM</td></tr>
<tr><td>April 8, 2:00-2:30</td><td>Index-While-Building & clangd</td></tr>
<tr><td>April 8, 2:00-2:30</td><td>Polly Labs speaks to MLIR</td></tr>
<tr><td>April 8, 2:35-3:05</td><td>Scalable Vector Next Steps</td></tr>
<tr><td>April 8, 2:35-3:05</td><td>GPU in LLVM: Thread groups, warps, wavefronts, and convergence</td></tr>
<tr><td>April 8, 3:10-3:40</td><td>Clang Static Analyzer</td></tr>
<tr><td>April 8, 4:15-4:45</td><td>IPO - Interprocedural Optimizations</td></tr>
<tr><td>April 8, 4:15-4:45</td><td>Integrating new LLVM Tutorials into the documentation</td></tr>
<tr><td>Apri; 8, 4:50-5:20</td><td>Meetup organizers</td></tr>
<tr><td>April 8, 4:50-5:20</td><td>Building LLVM with GN</td></tr>
<tr><td>April 8, 5:25-5:55</td><td>Variable names standard - hopes & fears</td></tr>
<tr><td>April 9, 11:25-11:55</td><td>Bazel for LLVM and Clang builds</td></tr>
<tr><td>April 9, 11:25-11:55</td><td>Flang F18 Fortran Front End Project</td></tr>
<tr><td>April 9, 11:25-11:55</td><td>JIT</td></tr>
<tr><td>April 9, 12:35-1:05</td><td>-Og (optimized but debuggable) level</td></tr>
<tr><td>April 9, 2:00-2:30</td><td>IDEs, Indexing, Refactoring and Modules</td></tr>
<tr><td>April 9, 2:00-2:30</td><td>LLVM Binutils</td></tr>
<tr><td>April 9, 2:00-2:30</td><td>Restrict</td></tr>
<tr><td>April 9, 2:35-3:05</td><td>16-bit bytes in llvm</td></tr>
<tr><td>April 9, 2:35-3:05</td><td>Future Refactoring with AST Matchers</td></tr>

</table>

<div class="www_sectiontitle" id="grant">Travel Grants for Students</div>
<p>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.</p>
<p>The deadline for applications was January 25th, so they are now closed.</p>

<div class="www_sectiontitle" id="CodeOfConduct">Code of Conduct</div>
<p>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 <a href="http://llvm.org/docs/CodeOfConduct.html">LLVM Code of Conduct</a>.
</p>

<div class="www_sectiontitle" id="contact">Contact</div>
<p>To contact the organizers, email
<a href="mailto:eurollvm-organizers@lists.llvm.org">eurollvm-organizers@lists.llvm.org</a>
</p>
</div>

<!-- *********************************************************************** -->

<!--#include virtual="sponsors.incl" -->

<hr>

<!--#include virtual="../../footer.incl" -->
