Jonas Devlieghere

Jonas Devlieghere

Sign in Subscribe

Google Summer of Code 2021

Today Google announced the list of open-source organiations [https://summerofcode.withgoogle.com/organizations/] participating in the 2021 Google Summer of Code program. Together with Raphael and Pedro, I'll be mentoring the following two projects: * A structured approach to diagnostics in LLDB [https://llvm.org/OpenProjects.html#lldb_diagnostics] * Lua scripted

Statistics in dsymutil

To make incremental builds fast on macOS, the static linker (ld) ignores the debug information. It can easily be a magnitude bigger than the rest of the program and slow down link time. Instead the linker emits a debug map which contains the location of all the object files it

LLDB Column Breakpoints

If you've ever used the debugger, chances are you've used a file and line number to set a breakpoint. Most of the time this provides enough granularity. Sometimes, though, more fine grained control would be helpful. Consider the following example: 1 int foo() { 2 return 1; 3 } 4 int bar(

Lua Scripting in LLDB

LLDB [https://lldb.llvm.org] is the debugger developed as part of the LLVM project. It is probably most known as the debugger in Xcode, but many use it as an alternative to GDB [https://www.gnu.org/software/gdb/]. Scripting in LLDB One thing that makes LLDB really powerful

Sanitizing C++ Python Modules

Python has great interoperability with C and C++ through extension modules. There are many reasons to do this, such as improving performance, accessing APIs not exposed by the language, or interfacing with libraries written in C or C++. Unlike Python however, C and C++ are not memory safe. Luckily, great

Calling Into C or C++ Code From Python

Recently I wanted to call some C code from Python to check who was sending a particular signal. Apparently this functionality is only available as of Python 3 so I decided to write a custom module. Doing so is relatively easy but all the documentation I found only was using

Using LSP & clangd in Vim

After having used YouCompleteMe [https://jonasdevlieghere.com/a-better-youcompleteme-config/], I finally decided to give one of the Language Server Protocol (LSP) [https://microsoft.github.io/language-server-protocol/] implementations a spin. As an LLVM developer I've been following clangd's development and wanted to try it out. At the time of writing, several LSP

Finding Reviewers for Your Patch

Finding the right people to review your patch can be tough. I see the question "who should I add as reviewer for this patch?" popping up on IRC quite regularly and not something I'm unfamiliar with myself. Not every project has a list of code owners and as soon as

Reference Counting PIMPL Idiom

The pointer to implementation or PIMPL idiom is a popular C++ idiom for decoupling the representation and implementation of a class. It reduces compilation times and enables a stable API while allowing the internals to change. Reference counting is another ubiquitous programming technique, used to manage an object's lifetime by

Exposing Containers of Unique Pointers

Exposing Containers of Unique Pointers

The std::unique_ptr is probably one of my favorite and most used features in modern C++. The unique pointer is as powerful as it is simple, and assuming you've used it before, you surely know how awesome it is. There are many great articles written about unique pointers, so

One Year At GuardSquare

One Year At GuardSquare

Today marks my one year anniversary at GuardSquare. On the one hand it feels like yesterday (as cliché as that might sound) but on the other hand it feels like ages ago, considering how much we have been able to do in just one year's time. -------------------------------------------------------------------------------- For those that

Building a Workstation

Building a Workstation

January 2017 marks the sixth birthday of my desktop computer. When I purchased my trusty Intel Core i5-2500K, I would've never guessed that I'd use it for that long. However, rather than jumping to the recently released Kaby Lake CPUs, I'm building my new workstation around two Intel Xeon E5-2670s.

Escape Analysis & Capture Tracking in LLVM

Escape Analysis & Capture Tracking in LLVM

Pointer analysis is an important topic in compiler optimization. One interesting aspect is the dynamic scope of pointers. LLVM differentiates between two situations: * Pointer Capture: A pointer value is captured if the function makes a copy of any part of the pointer that outlives the call. * Pointer Escape: A pointer

Order Your Members

The C++ standard guarantees that the members of a class or struct appear in memory in the same order as they are declared. > Nonstatic data members of a (non-union) class with the same access control are allocated so that later members have higher addresses within a class object. The order

Guaranteed Copy Elision

The new C++17 standard brings many exciting new features. A smaller, more subtle improvement it brings is guaranteed copy elision. The keyword is guaranteed, as copy elision itself has always been part of the standard. Although it might not be a change as radical as, say, structured bindings, I'm

LibEBC & ebcutil

In a previous blog post [https://jonasdevlieghere.com/embedded-bitcode/] I wrote about bitcode. Embedding it was already possible for quite some time with Apple's fork of LLVM that ships with Xcode. Recently, Apple upstreamed (parts of) their implementation making it possible to do the same with the open source clang

Embedded Bitcode

Little over a year ago, Apple announced at WWDC 2015 the ability to embed bitcode in Mach-O [https://raw.githubusercontent.com/corkami/pics/master/Mach-O101.png] files. Bitcode is the intermediate representation used by the LLVM compiler and contains all the information required to recompile an application. Having the bitcode

MAsCOT

Self-Adaptive Opportunistic Offloading for Cloud-Enabled Smart Mobile Applications with Probabilistic Graphical Models at Runtime I'm proud to announce that the paper summarizing the findings in my master's thesis (Intelligent Offloading Decisions for Mobile Cloud Applications) will be presented at the 49th Hawaii International Conference on System Sciences (HICSS). Abstract: Although

Understanding the Clang AST

Understanding the Clang AST

Clang is everywhere; It is the core of my favorite Vim plugin YouCompleteMe [https://jonasdevlieghere.com/a-better-youcompleteme-config/], it recently got supported by Microsoft Visual Studio [http://blogs.msdn.com/b/vcblog/archive/2015/12/04/introducing-clang-with-microsoft-codegen-in-vs-2015-update-1.aspx] , it is mentioned in numerous episodes of CppCast [http://cppcast.com/] and it

A better YouCompleteMe Config

If you're like me and have (1) been using Vim for a while and (2) have been programming in C++, you've likely heard about YouCompleteMe [https://github.com/Valloric/YouCompleteMe]. YCM is an awesome auto-completion engine for Vim. For C++ and other C-based languages it uses the libclang under the

Packages I Wish I Knew When Starting LaTeX

I've been using LaTeX for almost a decade now. Even after that much time, I keep running into new problems that require a solution I wasn't aware of. LaTeX has a great community and usually there's someone that already faced your problem. Every time I learn something new. This post

Word Search Solver

Word Search Solver

When browsing the Medium homepage I came across this post about #wordsearchwednesday [https://medium.com/@Medium/wordsearchwednesday-a519722b5afd]. Although I enjoy a puzzle as much as the next guy, I immediately thought that this was something Haskell lends itself to very well. Less than an hour later I had a working

Arduino Display

Arduino Display

As I already mentioned in a previous post [https://jonasdevlieghere.com/proper-printing-with-hd44780-style-lcd/], I recently purchased a 4 line LCD display to play around with. It provides an I2C Bus [http://en.wikipedia.org/wiki/I%C2%B2C] which means that it can be connected to your Arduino or similar microcontroller

Proper Printing with HD44780 LCD

Proper Printing with HD44780 LCD

I recently purchased a very simple, Hitachi HD44780 compatible LCD screen for an Arduino project. It's a 20x4 I2C display, which apparently is constructed as a combination of 2 two-line display controllers. This wouldn't really matter except for the fact that when printing strings longer than a single line, they

Course Notes & Summaries

Computer Science

Course Notes & Summaries

For some of the courses I took during my studies in computer science at the University of Leuven, I've combined the course material, typically with the help of others, into structured and easy to study documents. Hoping that other students could also benefit from these notes, I've made them publicly