Speaker: Valentin Clement
OpenACC  is a directive-based programming model to target heterogenous architectures with minimized change in original code. The standard is available for Fortran, C and C++. It is used in variety of scientific applications to exploit the compute power of the biggest supercomputers in the world. While there is a wide range of approaches in C and C++ to target accelerators, Fortran is stuck with directive based programming models like OpenMP and OpenACC. In this lightning talk we are presenting our prototype implementation of an OpenACC dialect in MLIR and support the standard in Flang/LLVM. This project might benefit other efforts like the Clacc  project doing this in clang/LLVM.
 OpenACC standard: https://www.openacc.org/
 Clacc: Translating OpenACC to OpenMP in Clang. Joel E. Denny, Seyong Lee, and Jeffrey S. Vetter. 2018 IEEE/ACM 5th Workshop on the LLVM Compiler Infrastructure in HPC (LLVM-HPC), Dallas, TX, USA, (2018).
2) Fragmenting the DWARF to Enable Dead Debug Data Elimination
Speaker: James Henderson
Standard DWARF defines a series of sections in the output, with one of each per object file. Each of these sections may have information about every function and variable in that unit. Linkers typically leave this information intact, referencing address 0 (or other tombstone value) when a function or variable’s section is discarded, as the debug sections still contain used information. This approach has issues such as potential ambiguity and excessive space usage.
This talk will present a solution to these issues, leveraging existing ELF features, which enables linkers to discard dead pieces of DWARF without the linker requiring any special knowledge of its structure. It will also include performance figures to evaluate the approach.
3) Source-based Code Coverage for Embedded Use Cases
Speaker: Alan Phipps
LLVM Source-based Code Coverage is not well-suited for embedded use cases because of its large code size requirements. All coverage information must reside in memory even though only the counters are actually modified during program execution. In addition, the runtime support is very large and includes features that are mostly unnecessary for embedded use cases. In this talk, I will demonstrate how we can easily reduce the code size overhead of LLVM code coverage, making it a compelling solution for measuring embedded applications.
4) pre-merge checks for LLVM
Speaker: Mikhail Goncharov
Let's talk about the current state, challenges, and plans for LLVM pre-merge checks that run on every diff submitted to the phabricator. Maybe for some folks that will be the first time they hear about the pre-merge checks and they might consider using them too! Ideally, I would like to hear feedback from the community, and the "poster" format should be a good fit. Not sure about the "round table" format as it's not available atm.
5) Getting stack size just right on XCore
Speaker: Jack McCrea
The XCore architecture allows programs to easily run code in separate hardware threads. Calculating stack size requirements for such a program can be error-prone, and a wasteful approach often isn't acceptable. This talk explains how our LLVM backend produces code to facilitate precise worst-case stack allocation, and how we aim to improve it in the future.
6) Using Clang as An Alternative C/C++ Frontend of The ROSE Source-to-Source Compiler
Speaker: Anjia Wang
We are connecting Clang to ROSE, a source-to-source compiler framework aimed to enable programmers to build sophisticated source code transformation and analysis tools for C/C++, Fortran and so on. The motivation of this work is twofold. 1) Using Clang as an alternative C/C++ frontend is beneficial for ROSE, which currently relies on the proprietary EDG frontend to parse C/C++ source code. Public distribution of EDG is limited to its binary formats, which are hard to maintain for different software/hardware configurations. In addition, EDG does not support OpenMP. 2) Connecting Clang to ROSE is also beneficial to the Clang/LLVM community by providing a complementary approach to source-to-source translation. Unlike Clang AST which is immutable, ROSE AST is designed to support direct and complex transformation through easy-to-use APIs. ROSE also comes with a powerful unparser to convert its AST to human-readable, compilable source code. A set of compiler analyses and optimizations are available on top of the ROSE AST to facilitate tool development.