Loading…
For full conference details, see the website: http://llvm.org/devmtg/2019-10/

Sign up or log in to bookmark your favorites and sync them to your phone or calendar.

Tutorial [clear filter]
Tuesday, October 22
 

10:20am

An overview of LLVM
Abstract coming soon

Speakers
avatar for Eric Christopher

Eric Christopher

Google, Inc
avatar for Johannes Doerfert

Johannes Doerfert

Argonne National Laboratory


Tuesday October 22, 2019 10:20am - 11:30am
Breakout Room-2 (LL21CD)

11:30am

An overview of Clang
Abstract coming soon.

Speakers
avatar for Anastasia Stulova

Anastasia Stulova

Senior Compiler Engineer, Arm
GPGPU, OpenCL, Parallel Programming, Frontend, SPIR-V


Tuesday October 22, 2019 11:30am - 12:40pm
Breakout Room-2 (LL21CD)

2:00pm

How to Contribute to LLVM
Tutorial on how to contribute to LLVM.

Speakers
avatar for Kit Barton

Kit Barton

Technical lead for LLVM on Power and XL Compilers, IBM Canada


Tuesday October 22, 2019 2:00pm - 3:10pm
Breakout Room-2 (LL21CD)

3:10pm

Writing an LLVM Pass: 101
This is a tutorial on writing LLVM passes targeting beginners and
newcomers. It focuses on out-of-tree development and is based on LLVM 9
(i.e. the latest release). You will learn how to register a pass (legacy
vs new pass manager) and how to build a standalone LLVM-based analysis
and transformation tools. Testing will be set-up using LIT - LLVM's
testing infrastructure. You will see how to configure the necessary
scripts, implement tests and fix them when failing.

This tutorial is self-contained and no prior knowledge of LLVM or
compilers is required. Some familiarity with CMake and LLVM IR (or any
other assembly language) will be helpful, but is not essential. The
presented examples can be tested with pre-build packages available
online (i.e. building LLVM from sources is optional). All examples will
be available on GitHub.

Content:
* implementing a pass (including CMake set-up)
* registering a pass, new vs legacy pass manager
* examples of analysis and transformation passes (IR <-> IR)
* running and debugging an out-of-tree pass
* integrating a pass into an out-of-tree LLVM-based tool
* setting up and running LIT tests for out-of-tree passes
* integration with clang/opt/bugpoint


Tuesday October 22, 2019 3:10pm - 4:20pm
Breakout Room-2 (LL21CD)

4:40pm

Getting Started with the LLVM Testing Infrastructure
A strong testing infrastructure is critical for compilers to maintain a high quality of correctness and performance.  This tutorial will cover the various elements of the LLVM testing infrastructure.  The focus will be to for newcomers to learn to write and run the unit, regression and whole program tests in the LLVM infrastructure as well as the integration of external suites into the LLVM test suite. We will additionally cover the various frameworks and tools used within the test suites, including using LNT to track performance data.

Speakers
BH

Brian Homerding

Argonne National Laboratory
MK

Michael Kruse

Argonne National Laboratory


Tuesday October 22, 2019 4:40pm - 5:50pm
Breakout Room-2 (LL21CD)
 
Wednesday, October 23
 

10:45am

Developing the Clang Static Analyzer
This tutorial is about getting around the internals of the static analyzer. You'll learn how to figure out what exactly is the static analyzer thinking when it analyzes any particular code. You'll learn how to debug false positives and other bugs in a methodical, principled manner. We'll show how the analyzer represents program behavior as a graph and walk through a few such graphs step-by-step and then see how to debug it further when we believe that anything about these graphs is incorrect.
This tutorial will be useful to anybody who wants to get involved in the development of the static analyzer, sub-project of LLVM that is both complex and also friendly to newcomers. The tutorial is a complement to the talk “How to Write a Checker in 24 Hours” from LLVM DevMtg'2012; here we will focus on getting started contributing to the analyzer core.

Speakers

Wednesday October 23, 2019 10:45am - 11:55am
Breakout Room-2 (LL21CD)

10:45am

Getting Started With LLVM: Basics
This tutorial serves as a tour of LLVM, geared towards beginners interested in implementing LLVM passes. Both LLVM middle-end (IR) and back-end (MIR) passes are covered. At the end of this tutorial, newcomers will be armed with the tools necessary to create their own passes, and improve upon existing passes.
This tutorial contains
- A brief, high-level explanation of LLVM’s pass-based architecture.
- An explanation of analysis and tranformation passes, and how they interact.
- Examples of important analysis passes, such as Dominator Trees and Target Transform Information.
- An introduction to fundamental data structures and APIs for LLVM pass development.
- A sample project which ties together the tutorial material, for use as a reference.

Speakers

Wednesday October 23, 2019 10:45am - 11:55am
Breakout Room-1 (LL21AB)

1:45pm

ASTImporter: Merging Clang ASTs
ASTImporter is part of Clang's core library, the AST library. There are cases when we have to work with more than one AST contexts, but we would like to view the set of the ASTs as if they were one big AST resulting from the parsing of all files together. ASTImporter imports nodes of an AST context into another AST context.
Existing clients of the ASTImporter library are Cross Translation Unit (CTU) static analysis and the LLDB expression parser. CTU static analysis imports a definition of a function if its definition is found in another translation unit (TU). This way the analysis can breach out from the single TU limitation. LLDB’s "expr" command parses a user-defined expression, creates an ASTContext for that and then imports the missing definitions from the AST what we got from the debug information (DWARF, etc).

Speakers

Wednesday October 23, 2019 1:45pm - 2:55pm
Breakout Room-2 (LL21CD)

1:45pm

The Attributor: A Versatile Inter-procedural Fixpoint Iteration Framework
This is a tutorial on the Attributor. There is a technical talk as well: link


In this tutorial we will:
  1. create a new llvm::Attribute, incl. all the pluming,
  2. deduce it with the Attributor, and
  3. se the new attribute to improve alias information :)

Please consider joining us in the Attributor talk prior to attending this tutorial, though it is not strictly required.

---

 The Attributor fixpoint iteration framework is a new addition to LLVM that, first and foremost, offers powerful inter-procedural attribute deduction. While it was initially designed as a replacement for the existing “function attribute deduction” pass, the Attributor framework is already more than that. The framework, as well as the deduced information which does not directly translate to LLVM-IR attributes, can be used for various other purposes where information about the code is required.In this talk we will give an overview about the design, showcase current and future use cases, discuss the interplay with other (inter-procedural) passes, highlight ongoing and future extensions, and finally present an evolution. Actual deduction (and use) of attributes will be described but also discussed in our lighting talk presentations and poster.

Speakers
avatar for Johannes Doerfert

Johannes Doerfert

Argonne National Laboratory


Wednesday October 23, 2019 1:45pm - 2:55pm
Breakout Room-1 (LL21AB)

2:55pm

My first clang warning
Abstract coming soon

Speakers

Wednesday October 23, 2019 2:55pm - 4:00pm
Breakout Room-2 (LL21CD)

2:55pm

Writing Loop Optimizations in LLVM
LLVM contains an evolving set of classes and tools specifically designed to interact with loops. The Loop and LoopInfo classes are being continually improved, as are supporting data structures such as the Data Dependence Graph (DDG) and Program Dependence Graph (PDG). The pass manager infrastructure (both New and Legacy pass managers) provide infrastructure to write both function passes and loop passes. However, putting all of these concepts together to write a functioning loop optimization pass can still be a somewhat daunting task. 
This tutorial will start by introducing basic terminology that is used within LLVM to describe loops (for example, many of the concepts introduced in https://reviews.llvm.org/D65164). It will then look at the Loop and LoopInfo classes, and go over the interfaces they have to work with loops. It will provide examples of how these classes can be used to implement different types of loop optimizations, using examples from both the Loop Fusion and Loop Distribution passes. It will discuss the differences between a function pass and a loop pass, including a discussion of the advantages and disadvantages of each one when writing loop optimizations. It will also provide guidance on when each type of pass should be used. Finally, it will go through many of the useful utility functions that need to be used in order to write a loop optimization efficiently (e.g., updating the dominator tree, updating Scalar Evolution, etc.).

Speakers
ET

Ettore Tiotto

Senior Developer, IBM Canada
avatar for Hal Finkel

Hal Finkel

Argonne National Laboratory
avatar for Johannes Doerfert

Johannes Doerfert

Argonne National Laboratory
MK

Michael Kruse

Argonne National Laboratory
avatar for Kit Barton

Kit Barton

Technical lead for LLVM on Power and XL Compilers, IBM Canada


Wednesday October 23, 2019 2:55pm - 4:00pm
Breakout Room-1 (LL21AB)