Pre-LLVM-DEV'23 - Embedded Toolchains Workshop Agenda and Who's Coming?

The Embedded Toolchains pre conference Workshop will take place on Tuesday the 10th October from 8:30 to 12:30 (Agenda: 2023 LLVM Developers' Meeting).

At the recent Embedded Toolchains Call we drafted a first draft of an agenda. The purpose of this post is to share the initial draft and ask whom is likely to attend. Ultimately the final agenda will be determined by what the people that turn up are interested in.

The format we’d like to take for the workshop is to pick a few large topics of interest and use a birds of a feather (BOF) format, with 2-5 slides to set the context followed by a discussion. In each case we don’t expect to be making decisions on details, but we would like to be able set a general direction for further discussions. We expect each major topic to last 45 minutes to 1 hour. Topics are not in any particular order.

Topic 1: LTO and linker scripts.
There have been two presentations on linker scripts in past LLVM dev meetings 2022 ( and , but nothing has landed upstream yet. We would like to get requirements for what needs to be supported as well as agree on a general direction. Ideally an RFC will be available for discussion prior to the event.

Topic 2: LLVM libc and libc++ in embedded systems
A combined topic of llvm-libc and libc++ in embedded systems. Including:

  • Subsets of libc libc++ that are suitable for embedded systems without a full POSIX compliant OS.
  • Support for threading and concurrency primitives without a POSIX API, is there a lower-level API that could be designed?
  • Interaction between llvm-libc and libc++

Topic 3: Code coverage and profiling
The runtime in compiler-rt is not suitable for the smallest embedded systems, while it is possible to hand roll a minimal runtime ideally this should be available in tree. There are also other concerns such as whether counters need to be in memory, or can they be held off target.

  • Requirements for embedded systems
  • MC/DC and other code-coverage suitable for embedded systems.
  • Performance profiling on embedded systems.

Topic 4: Embedded linker features and diagnostics
This is likely to be a more open session, towards the end of the day. Embedded systems often require complex linker scripts and often require more diagnostics to work out if the output is correct. Ideally we can work out what is feasible in LLD, and find out who is willing to collaborate on implementations.

We will likely have some backup topics if people aren’t available on the day.

As mentioned previously, the final agenda will be determined by the people that turn up. It would be helpful if you can reply to this thread if you will or are likely to attend, and let us know if we’ve missed out a topic you would be interested in? I do not expect many will want to commit at this point, but any indication will be helpful.

I’m tagging some of the experts/maintainers that Petr Hosek mentioned in Pre-LLVM-DEV'23 -- Embedded Toolchains Workshop - #2 by petrhosek
@MaskRay for LLD
@snidertm and @ilovepi for LTO and linker scripts
@barrelshifter @ellishg @evodius96 for Code coverage
@sivachandra @michaelrj-google @ldionne for libc++ and llvm-libc

If you know of someone else, please do add to this thead.

1 Like

Hi, I am coming from the libc side, and have already registered. The topics look fine to me.


I will be attending.

I will post at least a baseline RFC by the end of September for adding linker-generated attributes to the combined IR module that is input to the LTO recompile (as I talked about in the 2022 presentation referenced above).

~ Todd Snider

I plan to attend as well.
-Alan Phipps

A small update. Looks like the workshop will be moved to the afternoon. I can’t edit the original post, but I’m hoping will soon be visible in the conference agenda.

I’m likely to attend, and I’m particularly interested in the discussion on linker/linking/LTO topics.

I am very likely to attend, and I’d be interested in the libc++ related topics. I could present the approach we’ve taken so far to support embedded platforms in libc++ in a few slides.

I would like to attend for code coverage.

Hello everyone,

It is only a couple of weeks to the workshop. Here’s a quick update based on the last Embedded Toolchains Call.

The workshop is expected to be well attended, and we should have enough people to cover all the topics described earlier in the thread with the same format. I will prepare some backup material if we are short of key people on the day.

One topic that it will help from some prework is LTO. In particular we would like to collect requirements for LTO and linker scripts. For example:

  • Given an existing embedded project that does not use LTO, I should be able to enable LTO and have my project build with no (or minimal) intervention.
  • Given an executable that is partitioned into a safety-critical part and a non-safety-critical part. I need to make sure that when LTO is on, safety-critical
    code does not inline non-safety-critical code (although the reverse is permitted).

Please have a think about what use cases and requirements you have for LTO as we would like to come up with a design that supports as many of these as possible.

I have submitted a proposal for an Embedded Toolchains Roundtable for the main conference. I expect that to have more open and user focused topics than theworkshop.

Confirmed topics

Topic 1: LTO and linker scripts
Topic 2: LLVM Libc and libc++ in embedded systems
Topic 3: Code coverage and profiling
Topic 4: Embedded linker features and diagnostics

Look forward to seeing you there


I’ll be attending the workshop and I’m interested in all the proposed topics.