January 2026 Monthly report

Overview

Thanks again to Open Source Security, inc and Embecosm for their ongoing support for this project.

Project update

This beginning of the year was quite productive, with 41 pull-requests merged and numerous core problems discovered and addressed.

Our work on getting the kernel to compile is focused on the crates surrounding the main kernel crate. Pierre-Emmanuel has also been focusing on the numerous nightly unstable features used by the kernel, as gccrs will need to support them rather quickly. On a related note, one nightly feature we have implemented this month - but which is not essential to the kernel - is #![no_core]. gccrs now properly tries to link your Rust program with core, which since we cannot compile core yet, means all of our testsuite has to opt out of that linkage using the #![no_core] attribute. Unfortunately, this commit was so big that the changelog for it was rejected by the mailing list’s spam filter. Heh.

In other news, Pierre-Emmanuel updated the GCC wiki with project ideas for this year’s Google Summer of Code: https://gcc.gnu.org/wiki/SummerOfCode%C2%A0

Feel free to propose any project you’d be interested in working on! Please join our Zulip group chat in order to start discussing with the team if you plan on applying for GSoC.

On a final technical note, one of the issues discovered with core this month was an interesting edge-case in our import resolution algorithm we had failed to consider:

Our naive approach to import definitions was to directly insert the ID of the node that the import would resolve to. For example, in the following example,

mod foo { // Definition ID 1
    fn bar() {} // Definition ID 2
}

use foo::bar;

fn main() { // Definition ID 3
    bar();
}

We’d “replace” the import by a direct insert of Definition ID 2, and have the call to bar directly resolve to the function instead of resolving to the import. This is fine in most cases, and went unnoticed for a long period of time.

mod foo { // Definition ID 1
    fn bar() {} // Definition ID 2
}

use foo::bar; // Resolved to Definition ID 2, insert Definition ID 2

fn main() { // Definition ID 3
    bar(); // Resolved to Definition ID 2
}

For the most part, resolving to a reference to a definition or to the definition itself does not make a difference - the proper function gets called, typechecked, and everyone is happy. However, imports must act as a proper definition point, just like functions or modules. The correct way to resolve the above example is as follows:

mod foo { // Definition ID 1
    fn bar() {} // Definition ID 2
}

use foo::bar; // Resolved to ID 2, Definition ID 3

fn main() { // Definition ID 4
    bar(); // Resolved to ID 3
}

Consider this example:

use crate::intrinsics::{self, abort, is_aligned_and_not_null, is_nonoverlapping};

/* snip */

#[lang = "align_offset"]
pub(crate) unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize {
    use intrinsics::{
        unchecked_shl, unchecked_shr, unchecked_sub, wrapping_add, wrapping_mul, wrapping_sub,
    };

    /* snip */
}

Here, the second import within the align_offset function directly points to crate::intrinsics::self as a definition, and must be understood this way. But the import does not contain any function definitions, it merely points to the module which contains them. This means that we must rework how our name resolution algorithm works for itself, and for the output it produces for the rest of the compiler, as later passes do not care about whether something is a definition or a reference to a definition - they only want to work on the actual modules, types and functions.

Up until this point, our name resolution worked with an internal structure that was also its output for later passes - a simple hashmap linking each usage-point to its definition-point:

HashMap<Usage, Definition> usage_map;

With Usage and Definition simply being newtype-patterns for a NodeID, our internal ID structure for our AST nodes.

struct Usage(NodeId);
struct Definition(NodeId);

One possible modification is to modify the Definition type to allow them to become references to other ~Definition~s:

struct Usage(NodeId);
enum Definition {
  ImportOf(NodeId), // A use import
  Actual(NodeId), // Literally anything else that is a definition
}

This transforms our simple map into a graph, which we can then traverse at the end of name resolution to turn it back into a regular map - essentially flat-mapping it for later passes. This approach also allows us to do import loop detection, something we had not given much thought about previously as it is not essential for code-gen.

An issue with this implementation is that when inserting usage-points in our usage_map, we must know whether or not the NodeId that we resolved to in our NameResolutionCtx ribs is an import, or an actual definition. This has multiple ramifications and requires multiple changes to our internal name resolution structures, while also increasing their memory usage. Thankfully, we can easily avoid much of these changes thanks to one trick - if a Definition is also present in the map as a key, then it must mean that it is an import!

By traversing the map recursively as a graph and checking if each definition is also present as a key, we can easily avoid a lot of code churn and still produce the output expected by later compiler passes.

Community call

We will not have a community call this month as most of the team will be traveling. You can subscribe to our calendar to see when the next one will be held. The call is open to everyone, even if you would just like to sit-in and listen. You can also subscribe to our mailing-list or join our Zulip chat to be notified of upcoming events.

• Calendar ID: 7060a0923ffebd3cb52b1afef35a28ff7b64f05962c9af84c23b1847f1f5f894@group.calendar.google.com
• Google calendar link
• iCal link

Call for contribution

• https://github.com/Rust-GCC/gccrs/issues/2500

• https://github.com/Rust-GCC/gccrs/issues/2376

Completed Activities

• util/attributes: Fix ICE on bare #[deprecated] attribute PR4419
• ci: fix send email workflow in case of large commit log PR4416
• Reduce node id sharing PR4408
• Implicitely inject `extern crate core` PR4407
• ast: Fix module path resolution for sibling modules in root PR4406
• Detect macros with duplicate metavariable bindings PR4405
• name resolution: fixes resolution through modules PR4401
• Implement type check & codegen for HIR::StructPatternFieldTuplePat PR4400
• expand: Refactor field expansion and add documentation PR4398
• backend: Factor out asm operand chaining PR4397
• derive: Factor out Eq trait path generation PR4396
• gccrs: replace unreachable with sorry_at PR4391
• util/attributes: handle #[export_name] on static items PR4390
• util/attributes: error on malformed #[export_name] input PR4389
• Handle `export<sub>name</sub>` attribute on functions PR4385
• gccrs: add non upper case globals lint PR4382
• gccrs: add non snake case lint PR4381
• gccrs: fix ice on let else expession PR4378
• Sync with upstream (2026-01-10): 00b6346d5374efab8dabbf99d2647ad69b1df706 PR4371
• testsuite: Adds test from issue 1245 PR4369
• testsuite: Adds test from issue PR4366
• Unused label lint PR4365
• Adds test from issue 1210 and correct error thrown PR4363
• ICE in get_{dereferencedexpr}, at rust/ast/rust-expr.h:435 PR4362
• gccrs: Fix ICE in insert_{associatedtraitimpl} due to recursion PR4361
• gccrs: add redundant semicolon lint PR4360
• util/attributes: Error on malformed lint attributes PR4358
• util/attributes: error on malformed #[link_section] input PR4357
• util/attributes: Check that #[target_feature] is only used on unsafe … PR4356
• util/attributes: Error on #[repr] applied to functions PR4355
• util/attributes: error on malformed #[no_mangle] input PR4354
• util/attributes: error on malformed #[link_name] input PR4353
• util/attributes: Fix/target feature malformed 4233 PR4349
• gccrs: Fix rogue macro error during lowering on expansion failure PR4347
• Add proper prelude imports PR4346
• forever-stack: Display depth in debug string PR4343
• gccrs: Fix empty struct constructors causing ICE during type checking PR4342
• Improve attribute validation Rust-GCC/gccrs#4235 PR4339
• ast: Add new GlobContainer class and use it PR4337
• Improved Expr parser errors PR4330
• name-resolution: Add std/core prelude resolution PR4149

Contributors this month

• Jayant Chauhan (new contributor!)
• Mason (new contributor!)
• Marc Poulhiès
• Harishankar
• Zhi Heng
• Lenny Chiadmi-Delage
• Lucas Ly Ba
• Owen Avery
• Pierre-Emmanuel Patry
• Arthur Cohen

Overall Task Status

Bugs

Test Cases

Milestones Progress

Planned Activities