About the Project

Welcome to the final work product submission for my Google Summer of Code project.

This book serves as the comprehensive final report and technical documentation for my work on the gccrs compiler (the Rust front-end for GCC).

Below is a summary of the project. For in-depth technical details, methodologies, and code architecture, please navigate through the chapters using the sidebar.

What Were the Project Goals?

The primary goal of this project was to implement the compiler infrastructure required to compile Rust’s alloc crate natively within gccrs. This involved identifying, designing, and implementing missing lang items, compiler intrinsics, built-in attributes, and complex architectural features (like DSTs, Fat Pointers, and Unsized Coercions). For the underlying reasoning, refer to Why Compile the ‘alloc’ Crate?.

What Was Accomplished?

I addressed all the missing pieces required by the alloc crate. During development, my primary priority was always a full, end-to-end implementation.

In cases where a full implementation was strictly blocked by upstream compiler limitations, features were safely registered as stubs. Every stub was a deliberate, well-considered decision made to unblock standard library parsing without introducing unsound behavior. Detailed breakdowns can be found in What Has Been Done? and the complete list of PRs in Contributions.

What is the Current State?

The architectural groundwork for alloc is firmly in place. Currently, we can successfully compile the alloc crate up to the name resolution phase using a custom mock core module. Every individual feature and intrinsic implemented during this project is fully functional and covered by isolated regression tests in the gccrs test suite. This architecture is detailed in Current State & Mock Core Architecture.

What is Left to Do?

From a strictly alloc-specific perspective, the fundamental infrastructure is complete. The remaining work involves routine maintenance on the newly merged patches. The ultimate goal—compiling alloc end-to-end—is currently bottlenecked by the ongoing development of the upstream core crate support. As the gccrs mature, the temporary stubs we established will be cleanly replaced with their final backend implementations. For future projections, see Roadmap & Next Steps.

Note

To Reproduce the Work: If you wish to build the compiler and test these changes locally, I have created a fully reproducible Nix flake environment. View Setup Instructions

Why Compile the ‘alloc’ Crate?

The gccrs project has already made significant strides in compiling the core crate. Successfully compiling the alloc crate is the natural and most critical next milestone for several strategic reasons.

The “Rust for Linux” Initiative

One of the primary driving forces behind gccrs is the ability to compile the Linux kernel (Rust for Linux). While kernel development strictly avoids the standard library (std), it heavily relies on the core crate and a specialized subset of alloc for dynamic memory management. For gccrs to compile kernel drivers, the compiler must fully understand alloc’s underlying mechanisms, such as dynamic sized types (DSTs), allocator intrinsics, and pointer coercions.

The Bridge to std

The Rust standard library is built as a layered architecture:

┌──────────────┐
│ std          │
│ ┌──────────┐ │
│ │ alloc    │ │
│ │ ┌──────┐ │ │
│ │ │ core │ │ │
│ │ └──────┘ │ │
│ └──────────┘ │
└──────────────┘

Compiling alloc is a strict prerequisite. We cannot achieve our long-term goal of compiling the full std library without first establishing a robust foundation for memory allocation.

Real-World Applications

Almost all practical, user-space Rust program relies on dynamic memory. Data structures like Vec<T>, String, Box<T>, and Rc<T> all live in alloc. Teaching the compiler how to handle these structures is essential for gccrs to become a viable alternative for compiling everyday Rust programs.

Note

The motivations outlined here reflect the technical context of my GSoC project. For the official and most up-to-date roadmap of the overall compiler, please refer to the documentation and presentations published by the gccrs core team.

Why I Chose This Challenge

As a student interested in compiler engineering—and a passionate Rustacean—working on the alloc crate presented an ideal set of technical challenges.

Compiling alloc goes far beyond simply registering missing lang items or attributes. Each feature required a complete engineering loop:

Analyzing rustc source code, language specifications, and documentation to verify expected behaviors.
Debugging and extending various compiler passes—ranging from AST lowering and early type checking to vtable generation and backend code generation.
Translating Rust’s memory semantics into GCC’s internal representations (such as GIMPLE and Tree structures).

This project provided a unique hands-on opportunity to gain deep insights into Rust’s type system, layout engine, and dynamic allocation mechanics while directly contributing to production compiler infrastructure.

About the ‘alloc’ Crate

The alloc crate introduces dynamic memory (heap) allocation capabilities to the Rust language. While the core crate is strictly limited to stack-based and statically sized operations, alloc provides the foundational primitives for heap management, such as the Box<T>, Vec<T>, and Reference Counted pointers (Rc<T>, Arc<T>).

However, enabling these capabilities comes with a high cost for the compiler.

To successfully compile alloc, the compiler must flawlessly support several advanced language features:

Dynamic Sized Types (DSTs): Handling types whose size is unknown at compile time (like [T] and str).
Fat Pointers & Vtables: Generating and managing the memory layout for trait objects (dyn Trait).
Unsized Coercions & Auto-Deref: Automatically converting thin pointers to fat pointers and resolving method calls on heap-allocated structs (like Box).

The “Mock Core” Strategy

Architecturally, alloc sits directly on top of core and strictly demands full core support to function. Currently, gccrs is not yet able to compile the entire standard core crate end-to-end.

To bypass this blocker and make independent progress, we employ a “mock core” strategy in our test suite. By injecting a stripped-down, primitive core implementation as a submodule, we can isolate and test the new compiler features we built for alloc.

Missing Pieces

When the project started, the goal was clear: compile the alloc crate. However, alloc is a massive codebase heavily coupled with core. To understand exactly what gccrs was missing, we needed to map out the crate’s internal dependencies and reverse-engineer its requirements from the bottom up.

The Dependency Analysis Methodology

Instead of blindly feeding the entire crate to the compiler and chasing a wall of errors, I performed a strict static analysis of the alloc source code.

Mapping core Usage: I scanned every file in alloc (e.g., alloc.rs, boxed.rs, vec.rs) to extract all core:: import statements, macros, lang items, and built-in attributes.

Grouping by Logical Chunks: alloc contains deeply intertwined files. By analyzing internal dependencies (e.g., vec.rs relies on raw_vec.rs, which relies on alloc.rs), I divided the entire crate into 5 logical, manageable chunks.

Filtering Supported Features: I cross-referenced the extracted list against the current gccrs codebase to filter out features that were already supported (like standard traits, core::fmt, basic macros, and standard attributes).

What remained was the exact recipe of technical gaps blocking the compilation of alloc.

The Missing Pieces: What We Found

We categorized these missing pieces into three major domains:

Missing Lang Items

alloc_layout, box_free, coerce_unsized, dispatch_from_dyn, drop, drop_in_place, exchange_malloc, future_trait, generator, generator_state, maybe_uninit, oom, owned_box, pending, pin, poll, range_inclusive_new, ready, unsize, unpin, unsafe_cell,

Missing Intrinsics

arith_offset, assert_zero_valid, min_align_of, min_align_of_val, size_of_val, write_bytes

Missing Attributes

needs_allocator, rustc_allocator, rustc_allocator_nounwind, rustc_conversion_suggestion, rustc_std_internal_symbol

Missing Infrastructure

Dynamic Sized Types (DSTs): Slices ([T]) and Trait Objects (dyn Trait) don’t have a known size at compile time. This is supported, but it needs to be extended to include ADTs.

Fat Pointers & Vtables: Pointers to DSTs require two machine words (data address + size/vtable address). The compiler’s vtable generation needed a major refactor.

Unsized Coercions: The ability to automatically coerce a thin pointer to an array (&[i32; 3]) into a fat pointer to a slice (&[i32]), or to a trait object.

If you are a compiler developer and want to see the exact file-by-file raw data, dependency mappings, and how the crate was grouped, just continue to the next page.

Current Status & Progress: Skip the raw data and see what we actually accomplished.

Dependency Analysis

This page contains the raw data and dependency mappings generated during the initial static analysis of the alloc crate. This data was used to isolate the compiler’s missing pieces and construct the “mock core” needed for testing.

Note

Click on the sections below to expand and view the raw data.

First, I identified which core structures each alloc file uses to establish a baseline of requirements.

Core Dependencies by File

#![allow(unused)]
fn main() {
// lib.rs

pub use core::format_args; // built-in
pub use core::ops; // RangeFull

// alloc.rs

use core::intrinsics::{min_align_of_val, size_of_val, assume};
use core::ptr::{ NonNull, Unique, copy_nonoverlapping };
pub use core::alloc::*;

panic!
debug_assert!

#[lang = "oom"];
#[rustc_std_internal_symbol]
#[rustc_allocator]
#[rustc_allocator_nounwind]
#[lang = "exchange_malloc"]

// borrow.rs

use core::cmp::Ordering;
use core::hash::{Hash, Hasher};
use core::ops::{Add, AddAssign, Deref};
pub use core::borrow::{Borrow, BorrowMut};

unrachable!

// boxed.rs

use core::any::Any;
use core::borrow::{Borrow, BorrowMut};
use core::cmp::Ordering;
use core::convert::{From, TryFrom};
use core::fmt::{Display, Debug,Formatter, Result,Pointer};
use core::future::Future;
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator, Iterator};
use core::marker::{Unpin, Unsize};
use core::mem::{ManuallyDrop,MaybeUninit};
use core::ops::{
CoerceUnsized, Deref, DerefMut, DispatchFromDyn, Generator, GeneratorState, Receiver,
};
use core::pin::Pin;
use core::ptr::{read,copy_nonoverlapping, Unique};
use core::task::{Context, Poll};

#[lang = "owned_box"]
#[fundamental]

// fmt.rs

pub use core::fmt::rt; // ? non-used
pub use core::fmt::Alignment;
pub use core::fmt::Error;
pub use core::fmt::{write, ArgumentV1, Arguments};
pub use core::fmt::{Binary, Octal};
pub use core::fmt::{Debug, Display};
pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
pub use core::fmt::{Formatter, Result, Write};
pub use core::fmt::{LowerExp, UpperExp};
pub use core::fmt::{LowerHex, Pointer, UpperHex};

// macros.rs

macro_rules!
#[macro_export]

// raw_vec.rs

use core::alloc::LayoutErr;
use core::cmp::{max};
use core::intrinsics::{assume};
use core::mem::{size_of,align_of, ManuallyDrop, MaybeUninit};
use core::ops::Drop;
use core::ptr::{read, NonNull, Unique};
use core::slice::from_raw_parts_mut;

debug_assert_ne!
debug_assert!
assert!
debug_assert_eq!
panic!

#[may_dangle]

// rc.rs

use core::any::Any;
use core::borrow::Borrow;
use core::cell::Cell;
use core::cmp::Ordering;
use core::convert::{From, TryFrom};
use core::fmt::{Display, Debug,Formatter, Result,Pointer};
use core::hash::{Hash, Hasher};
use core::intrinsics::abort;
use core::iter::{FromIterator,IntoIterator,TrustedLen,Iterator};
use core::marker::{Send,Sync, PhantomData, Unpin, Unsize};
use core::mem::{MaybeUninit,forget,ManuallyDrop,swap, align_of_val_raw, forget, size_of_val};
use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
use core::pin::Pin;
use core::ptr::{read,drop_in_place,write,copy_nonoverlapping,slice_from_raw_parts_mut, NonNull};
use core::slice::from_raw_parts_mut;

debug_assert_eq!
write!

#[repr(C)]
#[may_dangle]
#[rustc_unsafe_specialization_marker]

// slice.rs

use core::borrow::{Borrow, BorrowMut};
use core::cmp::Ordering;
use core::cmp::Ordering::Less;
use core::mem::{size_of, ManuallyDrop};
use core::ptr::{copy_nonoverlapping,read};
pub use core::slice::ArrayChunks;
pub use core::slice::ArrayChunksMut;
pub use core::slice::ArrayWindows;
pub use core::slice::SliceIndex;
pub use core::slice::{from_mut, from_ref};
pub use core::slice::{from_raw_parts, from_raw_parts_mut};
pub use core::slice::{Chunks, Windows};
pub use core::slice::{ChunksExact, ChunksExactMut};
pub use core::slice::{ChunksMut, Split, SplitMut};
pub use core::slice::{Iter, IterMut};
pub use core::slice::{RChunks, RChunksExact, RChunksExactMut, RChunksMut};
pub use core::slice::{RSplit, RSplitMut};
pub use core::slice::{RSplitN, RSplitNMut, SplitN, SplitNMut};

sort_by_key! __not_core!

#[lang = "slice_u8_alloc"]
#[lang = "slice_alloc"]
#[derive(Clone, Copy)]
#[rustc_conversion_suggestion]

// str.rs

use core::borrow::{Borrow, BorrowMut};
use core::iter::FusedIterator;
use core::mem::{take};
use core::ptr; // ? non-used
use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
use core::unicode::conversions::{to_lower,to_upper};
pub use core::str::pattern;
pub use core::str::EncodeUtf16;
pub use core::str::SplitAsciiWhitespace;
pub use core::str::SplitWhitespace;
pub use core::str::{from_utf8, from_utf8_mut, Bytes, CharIndices, Chars};
pub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError};
pub use core::str::{EscapeDebug, EscapeDefault, EscapeUnicode};
pub use core::str::{FromStr, Utf8Error};
pub use core::str::{Lines, LinesAny};
pub use core::str::{MatchIndices, RMatchIndices};
pub use core::str::{Matches, RMatches};
pub use core::str::{RSplit, Split};
pub use core::str::{RSplitN, SplitN};
pub use core::str::{RSplitTerminator, SplitTerminator};
use core::unicode::derived_property::{Case_Ignorable, Cased};

debug_assert!
spezialize_for_lengths! __not_core!
assert!
copy_slice_and_advance! __not_core!

#[lang = "str_alloc"]

// string.rs

use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
use core::fmt::{Formatter,Debug,Result,Display,Write};
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{Index,Range,RangeTo,RangeFrom,RangeFull,RangeInclusive,RangeToInclusive,IndexMut,Deref,DerefMut, Add, AddAssign, Index, IndexMut, Range, RangeBounds};
use core::ptr::copy;
use core::str::{lossy, pattern::Pattern};
core::convert::Infallible;

panic!
debug_assert!
assert!
format_args!

#[rustc_conversion_suggestion]
#[derive(Debug, Clone, PartialEq, Eq,)]
#[derive(PartialOrd, Ord)]

// sync.rs

use core::any::Any;
use core::borrow::Borrow;
use core::cmp::Ordering;
use core::convert::{From, TryFrom};
use core::fmt::{Pointer,Formatter,Result,Debug,Result};
use core::hash::{Hash, Hasher};
use core::hint::spin_loop;
use core::intrinsics::abort;
use core::iter::{Iterator,FromIterator,IntoIterator, TrustedLen};
use core::marker::{PhantomData, Unpin, Unsize};
use core::mem::{swap,drop,MaybeUninit,forget,ManuallyDrop, align_of_val, size_of_val};
use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
use core::pin::Pin;
use core::ptr::{write,drop_in_place,read,copy_nonoverlapping,slice_from_raw_parts_mut, NonNull};
use core::slice::from_raw_parts_mut;
use core::sync::atomic::{fence,AtamicUsize};
use core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst};

write!
debug_assert_eq!
acquire! __non_core!
debug_assert!

#[may_dangle]
#[repr(C)]

// task.rs

use core::mem::ManuallyDrop;
use core::task::{RawWaker, RawWakerVTable, Waker};

// vec.rs

use core::cmp::{max, Ordering};
use core::convert::TryFrom;
use core::fmt::{Debug,Formatter,Result,Display};
use core::hash::{Hash, Hasher};
use core::intrinsics::{arith_offset, assume};
use core::iter::{ FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess };
use core::marker::PhantomData;
use core::mem::{size_of,zeroed,forget,replace,align_of, ManuallyDrop, MaybeUninit};
use core::ops::{DerefMut,Deref, Index, IndexMut, Range, RangeBounds};
use core::ptr::{replace,copy,write,read,write_bytes ,copy_nonoverlapping ,slice_from_raw_parts_mut,drop_in_place, NonNull};
use core::slice::{from_raw_parts_mut,from_raw_parts,to_vec,into_vec,Iter,IterMut,, SliceIndex};

debug_assert!
panic!
impl_is_zero! __not_core!
debug_assert_eq!
macro_rules!

#[derive(Debug)]
#[rustc_specialization_trait]
#[rustc_unsafe_specialization_marker]
#[cold]

// collections/mod.rs

use core::fmt::Display;
core::result::Result;
core::fmt::Error

// collections/linked_list.rs

use core::cmp::Ordering;
use core::fmt::{Debug,Formatter, Result};
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem::{forget,replace,swap,take,};
use core::ptr::NonNull;
core::hint::unreachable_unchecked()

assert!

#[may_dangle]

// collections/vec_deque.rs

use core::array::IntoIter;
use core::cmp::{min,max,, Ordering};
use core::fmt::{Debug,Formatter, Result};
use core::hash::{Hash, Hasher};
use core::iter::{repeat_with, FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem::{size_of, replace, ManuallyDrop};
use core::ops::{Index, IndexMut, Range, RangeBounds, Try};
use core::ptr::{drop_in_place,read,write,copy,copy_nonoverlapping,swap,slice_from_raw_parts_mut, NonNull};
use core::slice::{from_raw_parts_mut,from_raw_parts};
core::mem::size_of

macro_rules!
debug_assert_eq!
assert!
debug_assert!

#[may_dangle]
#[derive(Clone)]

// collections/vec_deque/drain.rs

use core::iter::FusedIterator;
use core::ptr::{NonNull,read,};
use core::fmt::{Debug,Formatter, Result};
use core::mem::forget;

// collections/btree/append.rs

use core::iter::FusedIterator;

unrachable!

// collections/btree/borrow.rs

use core::marker::PhantomData;
use core::ptr::NonNull;

// collections/btree/map.rs

use core::borrow::Borrow;
use core::cmp::Ordering;
use core::fmt::{Debug,Formatter,Result};
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, FusedIterator};
use core::marker::PhantomData;
use core::mem::{replace,swap,take,forget, ManuallyDrop};
use core::ops::{Index, RangeBounds};
use core::ptr::read;

unreachable!

#[may_dangle]
#[derive(Debug)]

// collections/btree/map/entry.rs

use core::fmt::{Result,Formatter, Debug};
use core::marker::PhantomData;
use core::mem::replace;

// collections/btree/mem.rs

use core::intrinsics::abort;
use core::mem::forget;
use core::ptr::{read,write};

// collections/btree/merge_iter.rs

use core::cmp::Ordering;
use core::fmt::{Formatter,Result, Debug};
use core::iter::FusedIterator;

#[derive(Clone, Debug)]

// collections/btree/mod.rs

core::intrinsics::unreachable();

cfg!
panic!

// collections/btree/navigate.rs

use core::borrow::Borrow;
use core::cmp::Ordering;
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::RangeBounds;
use core::ptr::read;

panic!
unreachable!

// collections/btree/node.rs

use core::cmp::Ordering;
use core::marker::PhantomData;
use core::mem::{replace, MaybeUninit};
use core::ptr::{read,copy,copy_nonoverlapping, NonNull, Unique};
use core::marker::PhantomData;

assert!
unreachable!
debug_assert!
debug_assert_eq!

#[repr(C)]

// collections/btree/remove.rs

use core::mem::replace;
use core::ptr::read;

unreachable!

// collections/btree/search.rs

use core::borrow::Borrow;
use core::cmp::Ordering;

// collections/btree/set.rs

use core::borrow::Borrow;
use core::cmp::Ordering::{Equal, Greater, Less};
use core::cmp::{max, min};
use core::fmt::{Formatter,Result, Debug};
use core::iter::{FromIterator, FusedIterator, Peekable};
use core::ops::{BitAnd, BitOr, BitXor, RangeBounds, Sub};

#[derive(Debug)]

// collections/btree/split.rs

use core::borrow::Borrow;

debug_assert!
unreachable!

// collections/binary_heap.rs

use core::fmt::{Debug,Formatter, Result};
use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen};
use core::mem::{forget, swap, ManuallyDrop};
use core::ops::{Deref, DerefMut};
use core::ptr::{swap,read,copy_nonoverlapping};

debug_assert!

#[derive(Clone, Debug)]

}

The initial raw list contained significant repetition and was difficult to track. Furthermore, it didn’t distinguish between features already supported by the compiler and those that were missing.

To resolve this, I analyzed the internal dependencies within alloc itself. By grouping interdependent files together and deduplicating the required structures, I created a much cleaner recipe. I then cross-referenced this recipe against the gccrs codebase to check off the structures that were already supported.

Result

// lib.rs

pub use core::format_args;                           ok
pub use core::ops;                                   ok

// target files
1  | alloc.rs
5  | macros.rs
22 | collections/btree/borrow.rs
25 | collections/btree/mem.rs
26 | collections/btree/merge_iter.rs

-----------------------------------------------------------
// use statements

pub use core::alloc::*;                             ok
core::intrinsics::min_align_of_val;                 !intrinsic
core::intrinsics::size_of_val;                      !intrinsic
core::intrinsics::assume;                           ok
core::ptr::NonNull;                                 ok
core::ptr::Unique;                                  ok
core::ptr::copy_nonoverlapping; #1                  ok
core::marker::PhantomData; #22                      ok
core::intrinsics::abort;                            ok
core::mem::forget;                                  ok
core::ptr::read;                                    ok
core::ptr::write; #25                               ok
core::cmp::Ordering;                                ok
core::fmt::Formatter                                ok
core::fmt::Result;                                  ok
core::fmt::Debug;                                   ok
core::iter::FusedIterator; #26                      ok

-----------------------------------------------------------
// macros

panic!                                              ok
debug_assert! #1                                    ok
macro_rules! #5                                     ok

-----------------------------------------------------------
// lang items

#[lang = "box_free"]                                !
#[lang = "oom"];                                    !
#[lang = "exchange_malloc"] #1                      !

-----------------------------------------------------------
// derive macros

#[derive(Clone)]                                    ok
#[derive(Debug)] #26                                ok

-----------------------------------------------------------
// attributes

#[rustc_allocator]                                  !
#[rustc_allocator_nounwind]                         !
#[rustc_std_internal_symbol] #1                     !

7  | rc.rs
16 | prelude/v1.rs
24 | collections/btree/map/entry.rs
34 | collections/binary_heap.rs

-----------------------------------------------------------

core::cell::Cell;                                   ok
core::iter::IntoIterator;                           ok
core::marker::Send;                                 ok
core::marker::Sync;                                 ok
core::mem::align_of_val_raw;                        !intrinsic
core::mem::size_of_val; #7                          !intrinsic

-----------------------------------------------------------

write!     ok

2  | borrow.rs
3  | boxed.rs
4  | fmt.rs
6  | raw_vec.rs
8  | slice.rs
9  | str.rs
10 | string.rs
14 | vec.rs
17 | collections/mod.rs
18 | collections/linked_list.rs
19 | collections/vec_deque.rs
20 | collections/vec_deque/drain.rs
21 | collections/append.rs
23 | collections/map.rs
27 | collections/btree/mod.rs
28 | collections/btree/navigate.rs
29 | collections/btree/node.rs
30 | collections/btree/remove.rs
31 | collections/btree/search.rs
32 | collections/btree/set.rs
33 | collections/btree/split.rs

-----------------------------------------------------------

core::borrow::Borrow;                               ok
core::borrow::BorrowMut;                            ok
core::hash::Hash;                                   ok
core::hash::Hasher;                                 ok
core::ops::Add;                                     ok
core::ops::AddAssign;                               ok
core::ops::Deref;                                   ok
core::any::Any;                                     ok
core::convert::From;                                ok
core::convert::TryFrom;                             ok
core::fmt::Display;                                 ok
core::fmt::Debug;                                   ok
core::fmt::Pointer;                                 ok
core::future::Future;                               !lang
core::iter::FromIterator;                           ok
core::iter::Iterator;                               ok
core::marker::Unpin;                                !lang
core::marker::Unsize;                               !lang
core::mem::ManuallyDrop;                            ok
core::mem::MaybeUninit;                             !lang
core::ops::DerefMut;                                ok
core::ops::DispatchFromDyn;                         !lang
core::ops::Generator;                               !lang
core::ops::GeneratorState;                          !lang
core::ops::Receiver;                                ok
core::ops::CoerceUnsized;                           !lang
core::pin::Pin;                                     !lang
core::task::Context;                                ok
core::task::Poll;                                   !lang
core::fmt::rt; //                                   ok
core::fmt::Alignment;                               ok
core::fmt::Error;                                   ok
core::fmt::write;                                   ok
core::fmt::ArgumentV1;                              ok
core::fmt::Arguments;                               ok
core::fmt::Binary;                                  ok
core::fmt::Octal;                                   ok
core::fmt::DebugList;                               ok
core::fmt::DebugMap;                                ok
core::fmt::DebugSet;                                ok
core::fmt::DebugStruct;                             ok
core::fmt::DebugTuple;                              ok
core::fmt::Formatter;                               ok
core::fmt::Write;                                   ok
core::fmt::LowerExp;                                ok
core::fmt::UpperExp;                                ok
core::fmt::LowerHex;                                ok
core::fmt::UpperHex;                                ok
core::alloc::LayoutErr;                             ok
core::cmp::max;                                     ok
core::mem::size_of                                  ok
core::mem::align_of;                                !intrinsic
core::ops::Drop;                                    !lang
core::slice::from_raw_parts_mut;                    ok
core::slice::ArrayChunks;                           ok
core::slice::ArrayChunksMut;                        ok
core::slice::ArrayWindows;                          ok
core::slice::SliceIndex;                            ok
core::slice::from_mut;                              ok
core::slice::from_ref;                              ok
core::slice::from_raw_parts;                        ok
core::slice::Chunks;                                ok
core::slice::Windows;                               ok
core::slice::ChunksExact;                           ok
core::slice::ChunksExactMut;                        ok
core::slice::ChunksMut;                             ok
core::slice::Split;                                 ok
core::slice::SplitMut;                              ok
core::slice::Iter;                                  ok
core::slice::IterMut;                               ok
core::slice::RChunks;                               ok
core::slice::RChunksExact;                          ok
core::slice::RChunksExactMut;                       ok
core::slice::RChunksMut;                            ok
core::slice::RSplit;                                ok
core::slice::RSplitMut;                             ok
core::slice::RSplitN;                               ok
core::slice::RSplitNMut;                            ok
core::slice::SplitN;                                ok
core::slice::SplitNMut;                             ok
core::mem::take;                                    ok
core::str::pattern::DoubleEndedSearcher;            ok
core::str::pattern::Pattern;                        ok
core::str::pattern::ReverseSearcher;                ok
core::str::pattern::Searcher;                       ok
core::unicode::conversions::to_upper;               ok
core::unicode::conversions::to_lower;               ok
core::str::pattern;                                 ok
core::str::EncodeUtf16;                             ok
core::str::SplitAsciiWhitespace;                    ok
core::str::SplitWhitespace;                         ok
core::str::from_utf8;                               ok
core::str::from_utf8_mut;                           ok
core::str::Bytes;                                   ok
core::str::CharIndices;                             ok
core::str::Chars;                                   ok
core::str::from_utf8_unchecked;                     ok
core::str::from_utf8_unchecked_mut;                 ok
core::str::ParseBoolError;                          ok
core::str::EscapeDebug;                             ok
core::str::EscapeDefault;                           ok
core::str::EscapeUnicode;                           ok
core::str::FromStr;                                 ok
core::str::Utf8Error;                               ok
core::str::Lines;                                   ok
core::str::LinesAny;                                ok
core::str::MatchIndices;                            ok
core::str::RMatchIndices;                           ok
core::str::Matches;                                 ok
core::str::RMatches;                                ok
core::str::Split;                                   ok
core::str::RSplit;                                  ok
core::str::RSplitN;                                 ok
core::str::SplitN;                                  ok
core::str::RSplitTerminator;                        ok
core::str::SplitTerminator;                         ok
core::unicode::derived_property::Case_Ignorable;    ok
core::unicode::derived_property::Cased;             ok
core::char::decode_utf16;                           ok
core::char::REPLACEMENT_CHARACTER;                  ok
core::ops::Bound::Excluded;                         ok
core::ops::Bound::Included;                         ok
core::ops::Bound::Unbounded;                        ok
core::ops::Index;                                   ok
core::ops::Range;                                   ok
core::ops::RangeTo;                                 ok
core::ops::RangeFrom;                               ok
core::ops::RangeFull;                               ok
core::ops::RangeInclusive;                          !lang
core::ops::RangeToInclusive;                        ok
core::ops::IndexMut;                                ok
core::ops::RangeBounds;                             ok
core::ptr::copy;                                    ok
core::str::lossy::Utf8Lossy;                        ok
core::str::lossy::Utf8LossyChunk                    ok
core::convert::Infallible;                          ok
core::intrinsics::arith_offset;                     !intrinsic
core::iter::InPlaceIterable;                        ok
core::iter::SourceIter;                             ok
core::iter::TrustedLen;                             ok
core::iter::TrustedRandomAccess;                    ok
core::mem::zeroed;                                  !intrinsic
core::mem::forget;                                  ok
core::mem::replace;                                 ok
core::ptr::replace;                                 ok
core::ptr::write_bytes;                             !intrinsic
core::ptr::slice_from_raw_parts_mut;                ok
core::ptr::drop_in_place;                           !lang
core::slice::to_vec;                                ok
core::slice::into_vec;                              ok
core::result::Result;                               ok
core::mem::swap;                                    ok
core::hint::unreachable_unchecked();                ok
core::array::IntoIter;                              ok
core::cmp::min;                                     ok
core::iter::repeat_with;                            ok
core::ops::Try;                                     ok
core::ptr::swap;                                    ok
core::intrinsics::unreachable;                      ok
core::iter::Peekable;                               ok
core::ops::BitAnd;                                  ok
core::ops::BitOr;                                   ok
core::ops::BitXor;                                  ok
core::ops::Sub;                                     ok


-----------------------------------------------------------

unreachable!                                        ok
debug_assert_ne!                                    ok
assert!                                             ok
debug_assert_eq!                                    ok
format_args!                                        ok
cfg!                                                ok

-----------------------------------------------------------

#[lang = "owned_box"]                               !
#[lang = "slice_u8_alloc"]                          ok
#[lang = "slice_alloc"]                             ok
#[lang = "str_alloc"]                               ok
#[lang = "slice"]                                   ok
#[lang = "slice_u8"]                                ok
#[lang = "str"]                                     ok
#[lang = "char"]                                    ok
-----------------------------------------------------------

#[derive(Copy)]                                     ok
#[derive(PartialEq)]                                ok
#[derive(Eq)]                                       ok
#[derive(PartialOrd)]                               ok
#[derive(Ord)]                                      ok
#[repr(C)]                                          ok

-----------------------------------------------------------

#[fundamental]                                      ok
#[may_dangle]                                       ok
#[rustc_specialization_trait]                       ok
#[rustc_unsafe_specialization_marker]               ok
#[cold]                                             ok

11 | sync.rs
15 | prelude/mod.rs

-----------------------------------------------------------
core::hint::spin_loop;                              ok
core::mem::drop;                                    ok
core::mem::align_of_val;                            ok
core::sync::atomic::fence;                          ok
core::sync::atomic::AtomicUsize;                    ok
core::sync::atomic::Ordering::Acquire;              ok
core::sync::atomic::Ordering::Relaxed;              ok
core::sync::atomic::Ordering::Release;              ok
core::sync::atomic::Ordering::SeqCst;               ok

12 | task.rs

-----------------------------------------------------------

core::task::RawWaker;                               ok
core::task::RawWakerVTable;                         ok
core::task::Waker;                                  ok

Some of the structures marked here don’t require specific compiler magic, but identifying these gaps was crucial. It provided a clear blueprint of exactly which core structures needed to be implemented in our “mock core” to allow alloc to compile.

With this step, the massive alloc crate was successfully divided into 5 manageable chunks, giving us a precise roadmap of the compiler’s shortcomings.

If you are wondering about the index numbers at the beginning of the file names in the previous section, those are internal IDs I assigned to avoid clutter during the dependency resolution process. Here is the raw internal dependency mapping I extracted from alloc:

Internal Dependencies of alloc

* lib.rs
*
1 alloc.rs                                 | 1:
2 borrow.rs                                | 2: 4 10
3 boxed.rs                                 | 3: 1 2 6 9 14
4 fmt.rs                                   | 4: 10
5 macros.rs                                | 5:
6 raw_vec.rs                               | 6: 1 3 17
7 rc.rs                                    | 7: 1 2 3 10 14
8 slice.rs                                 | 8: 2 3 14
9 str.rs                                   | 9: 2 3 8 10 14
10 string.rs                               | 10: 2 3 9 14 17
11 sync.rs                                 | 11: 1 2 3 7 10 14
12 task.rs                                 | 12: 11
14 vec.rs                                  | 14: 2 3 6 17
15 prelude/mod.rs                          | 15: 16
16 prelude/v1.rs                           | 16: 2 3 10 14
17 collections/mod.rs                      | 17: 1 18 19 27
18 collections/linked_list.rs              | 18: 3 17
19 collections/vec_deque.rs                | 19: 6 14 17 20
20 collections/vec_deque/drain.rs          | 20: 19
21 collections/btree/append.rs             | 21: 23 26 29
22 collections/btree/borrow.rs             | 22:
23 collections/btree/map.rs                | 23: 22 27 29 31
24 collections/btree/map/entry.rs          | 24: 22 23 29
25 collections/btree/mem.rs                | 25:
26 collections/btree/merge_iter.rs         | 26:
27 collections/btree/mod.rs                | 27: 21 22 23 25 26 28 29 30 31 32 33
28 collections/btree/navigate.rs           | 28: 27 29 31
29 collections/btree/node.rs               | 29: 1 3
30 collections/btree/remove.rs             | 30: 23 27 29
31 collections/btree/search.rs             | 31: 29
32 collections/btree/set.rs                | 32: 23 26 27
33 collections/btree/split.rs              | 33: 23 29 31
34 collections/binary_heap.rs              | 34: 8 14 17

What Has Been Done?

We have made significant progress in bringing alloc support to gccrs. You can inspect all individual patches in detail in the Contributions Overview section.

Resolved Lang Items

exchange_malloc: Fully implemented. Resolves the allocation method called during Box heap allocation.
owned_box: Fully implemented end-to-end for box expressions. This includes the underlying DST support, auto-dereferencing, and method dispatch logic.
pin / unpin: Implemented the necessary auto-trait and negative trait implementation infrastructure. The actual pinning logic is handled by library code, so no further compiler magic was required.
alloc_layout / oom: Supported (generates the necessary symbols).
unsize: Fully supported.
coerce_unsized: The backend code generation is fully functional. Currently, the type-checking phase relies on hardcoded compiler rules rather than being fully trait-based. This is a temporary measure; once the gccrs trait engine matures, delegating this check will be straightforward.
dispatch_from_dyn: Partially implemented (currently supported specifically for Box).
unsafe_cell: Supported. Essential for safe interior mutability.
range_inclusive_new: Fully implemented. Successfully lowers the ..= syntax sugar to the RangeInclusive::new() method.

Stubs & Unsupported Items:

maybe_uninit, box_free, drop, drop_in_place: Registered as stubs to allow compilation to proceed. (The drop-related items fall under the broader, ongoing Drop implementation scope).
future_trait, ready, pending, poll, generator, generator_state: Registered as stubs because Async & Generators are not yet supported.

Resolved Intrinsics

min_align_of: Implemented (alignment calculation for statically sized types).
size_of_val / min_align_of_val: Fully supported for both sized and dynamically sized types (DSTs). If the incoming type is a DST, the compiler successfully extracts the required size and alignment information from the fat pointer’s metadata.
arith_offset: Implemented for safe pointer offset calculations without triggering undefined behavior.
write_bytes: Implemented (lowers to memset in the backend).
assert_zero_valid: Registered as a stub. It is meant to abort if the zero value is invalid for a given type, but currently acts as a no-op. See the corresponding PR for details.

Resolved Attributes

rustc_allocator / rustc_allocator_nounwind / rustc_std_internal_symbol: Fully implemented with proper symbol generation.
needs_allocator / rustc_conversion_suggestion: Registered as temporary stubs to unblock the standard library parsing.

Resolved Infrastructure

Dynamic Sized Types (DSTs): Support implemented and stabilized for slices and trait objects within the alloc context.
Fat Pointers & Vtables: The vtable generation and fat pointer layout mechanics were successfully refactored and implemented.
Unsized Coercions: Functional, allowing seamless conversions between thin and fat pointers.

Note

For any missing element (lang item, intrinsic, attribute, etc.), a full implementation is always the primary priority. Even if a full implementation is completely blocked by infrastructure limitations, deciding to register it as a stub requires careful thought and discussion. If something is registered as a stub, you can be certain it is a deliberate and well-considered decision.

Current State

We have successfully established the fundamental infrastructure required to support the alloc crate within gccrs.

Note

The features registered as temporary stubs in the previous section represent architectural boundaries. Rather than waiting for the entire compiler infrastructure to catch up, we utilized these stubs to unblock development and make independent progress. Once those upstream compiler components mature, substituting these stubs with full implementations will be straightforward.

The Test Suite Strategy

Currently, we have an automated test suite for the alloc crate. However, we cannot yet compile the crate end-to-end.

The upstream core test suite is currently capable of compiling up to the AST lowering phase. To keep our work strictly synchronized with the compiler’s current capabilities and avoid upstream panics, the alloc test suite is configured to successfully compile up to the name resolution phase.

The “Mock Core” Architecture

To satisfy alloc’s heavy dependency on core without being blocked by the compiler’s incomplete standard library support, we inject a custom mock core directly into the test suite. This mock core is defined as a submodule and provides just enough structure to pass the required compiler phases.

Here is a high-level representation of how the alloc test suite and the mock core are architected:

gcc/testsuite/rust/alloc <-- alloc testsuite
├── alloc
│   └── src
│       ├── alloc/               ┌───────────────────────────────────┐
│       ├── alloc.rs             │152│             .                 │
│       ├── borrow.rs            │153│             .                 │
│       ├── boxed.rs             │154│                               │
│       ├── collections/         │155│ #[path = "../../core.rs"]     │
│       ├── fmt.rs               │156│ pub mod core; <───────────────┼───┐
│       ├── lib.rs ──────────────┤   │            .                  │   │
│       ├── macros.rs            │157│ #[path = "../../prelude.rs"]  │   │
│       ├── prelude/             │158│ pub mod gccrs_core_prelude; <─┼───┼────┐
│       ├── raw_vec/             │159│                               │   │    │
│       ├── raw_vec.rs           │160│             .                 │   │    │
│       ├── rc/                  │161│             .                 │   │    │
│       ├── rc.rs                └───────────────────────────────────┘   │    │
│       ├── slice.rs                                                     │    │
│       ├── str.rs                                                       │    │
│       ├── string.rs                                                    │    │
│       ├── sync/                                                        │    │
│       ├── sync.rs                                                      │    │
│       ├── task.rs                                                      │    │
│       ├── tests.rs                                                     │    │
│       └── vec.rs                                                       │    │
├── alloc.exp                                                            │    │
├── core.rs  ────────────────────────────────────────────────────────────┘    │
└── prelude.rs  ──────────────────────────────────────────────────────────────┘

Roadmap & Next Steps

To be entirely candid, the direct, alloc-specific infrastructure is now largely in place. The immediate next steps within the alloc crate itself mostly involve routine maintenance: reviewing the recently merged patches, ironing out edge cases, and fixing any newly discovered bugs.

The true path forward for alloc does not involve writing more alloc-specific code; it requires advancing the upstream core support. Because alloc is fundamentally built on top of core, any structural limitations in core inherently bottleneck alloc.

Therefore, the most impactful contribution to alloc right now is helping the gccrs team complete the missing core infrastructure.

As the compiler’s support for core matures, the future roadmap for alloc will naturally unfold:

Phasing Out the Mock: The temporary mock core used in our test suite will be gradually removed.
End-to-End Testing: The alloc test suite will be updated to compile against the actual standard core crate, pushing past the name resolution phase.
Replacing Stubs: The temporary stubs and workarounds we registered to unblock development will be cleanly replaced with their complete backend implementations.

Overview

Note

All development during this GSoC project was directly submitted to the upstream Rust-GCC/gccrs repository on GitHub.

Below is the complete list of contributions.

gccrs#4556: Add allocator attributes [Attribute]
gccrs#4557: Add lang item exchange_malloc [Lang Item]
gccrs#4574: Implement owned_box and box expressions [Lang Item] [Important]
gccrs#4582: Add min_align_of intrinsic [Intrinsic]
gccrs#4587: Enforce intrinsic signatures during type checking [Typecheck]
gccrs#4599: Refactor dynamic object fat pointers and vtable generation [Infrastructure] [Important]
gccrs#4620: Add write_bytes and arith_offset intrinsics [Intrinsic]
gccrs#4660: Fix incorrect impl block selection [Bug Fix]
gccrs#4672: Add size_of_val and min_align_of_val intrinsics [Intrinsic]
gccrs#4695: Register rustc_conversion_suggestion [Attribute]
gccrs#4696: Register needs_allocator [Attribute]
gccrs#4697: Add assert_zero_valid intrinsic [Intrinsic]
gccrs#4704: Add range_inclusive_new [Lang Item]
gccrs#4719: Add unsafe_cell [Lang Item]
gccrs#4720: Add pin and unpin lang items [Lang Item]
gccrs#4721: Register lang items for alloc crate [Lang Item]
gccrs#4722: Support coercions and intrinsics for unsized ADTs [Infrastructure] [Lang Item] [Important] [Pending Review]
gccrs#4750: Fix ignored self in grouped glob imports [Bug Fix]
gccrs#4767: Improve box with DST and auto-deref support [Infrastructure] [Important] [Pending Review]
gccrs#4693: Add the alloc crate to the testsuite [Testsuite] [Important] [Pending Review]

If you prefer to skip the detailed PR breakdowns, you can jump directly to:

Reproducible Environment with Nix - Learn how to easily build and test these changes.
Acknowledgements - Concluding thoughts and thanks.

gccrs#4556: Add allocator attrs

Link: Rust-GCC/gccrs#4556

Objective

This PR introduces three new built-in compiler attributes (rustc_std_internal_symbol, rustc_allocator, and rustc_allocator_nounwind) required for alloc crate integration.

Keyboard shortcuts

GCC Rust - Compiling the 'alloc' Crate