diff --git a/common/BUILD b/common/BUILD
index 9cce4ab..00023ee 100644
--- a/common/BUILD
+++ b/common/BUILD
@@ -30,6 +30,7 @@
         "@crate_index//:anyhow",
         "@crate_index//:once_cell",
         "@crate_index//:proc-macro2",
+        "@crate_index//:quote",
     ],
 )
 
@@ -38,7 +39,7 @@
     crate = ":code_gen_utils",
     deps = [
         ":token_stream_matchers",
-        "@crate_index//:quote",
+        ":token_stream_printer",
     ],
 )
 
diff --git a/common/code_gen_utils.rs b/common/code_gen_utils.rs
index 59e7361..84f1e9c 100644
--- a/common/code_gen_utils.rs
+++ b/common/code_gen_utils.rs
@@ -5,7 +5,9 @@
 use anyhow::{anyhow, ensure, Result};
 use once_cell::sync::Lazy;
 use proc_macro2::TokenStream;
-use std::collections::HashSet;
+use quote::{quote, ToTokens};
+use std::collections::{BTreeSet, HashSet};
+use std::rc::Rc;
 
 // TODO(lukasza): Consider adding more items into `code_gen_utils` (this crate).
 // For example, the following items from `src_code_gen.rs` will be most likely
@@ -32,6 +34,66 @@
     )
 }
 
+/// `CcInclude` represents a single `#include ...` directive in C++.
+#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum CcInclude {
+    SystemHeader(&'static str),
+    UserHeader(Rc<str>),
+}
+
+impl CcInclude {
+    /// Creates a `CcInclude` that represents `#include <cstddef>` and provides
+    /// C++ types like `std::size_t` or `std::ptrdiff_t`.  See also
+    /// https://en.cppreference.com/w/cpp/header/cstddef
+    pub fn cstddef() -> Self {
+        Self::SystemHeader("cstddef")
+    }
+
+    /// Creates a `CcInclude` that represents `#include <memory>`.
+    /// See also https://en.cppreference.com/w/cpp/header/memory
+    pub fn memory() -> Self {
+        Self::SystemHeader("memory")
+    }
+
+    /// Creates a user include: `#include "some/path/to/header.h"`.
+    pub fn user_header(path: Rc<str>) -> Self {
+        Self::UserHeader(path)
+    }
+}
+
+impl ToTokens for CcInclude {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        match self {
+            Self::SystemHeader(path) => {
+                let path: TokenStream = path
+                    .parse()
+                    .expect("`pub` API of `CcInclude` guarantees validity of system includes");
+                quote! { __HASH_TOKEN__ include < #path > __NEWLINE__ }.to_tokens(tokens)
+            }
+            Self::UserHeader(path) => {
+                quote! { __HASH_TOKEN__ include #path __NEWLINE__ }.to_tokens(tokens)
+            }
+        }
+    }
+}
+
+/// Formats a set of `CcInclude`s, trying to follow the guidance from
+/// [the Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html#Names_and_Order_of_Includes).
+pub fn format_cc_includes(set_of_includes: &BTreeSet<CcInclude>) -> TokenStream {
+    let mut tokens = TokenStream::default();
+    let mut iter = set_of_includes.iter().peekable();
+    while let Some(include) = iter.next() {
+        include.to_tokens(&mut tokens);
+
+        // Add an empty line between system headers and user headers.
+        if let (CcInclude::SystemHeader(_), Some(CcInclude::UserHeader(_))) = (include, iter.peek())
+        {
+            quote! { __NEWLINE__ }.to_tokens(&mut tokens)
+        }
+    }
+    tokens
+}
+
 static RESERVED_CC_KEYWORDS: Lazy<HashSet<&'static str>> = Lazy::new(|| {
     // `RESERVED_CC_KEYWORDS` are based on https://en.cppreference.com/w/cpp/keyword
     [
@@ -142,6 +204,7 @@
     use super::*;
     use quote::quote;
     use token_stream_matchers::assert_cc_matches;
+    use token_stream_printer::cc_tokens_to_formatted_string;
 
     #[test]
     fn test_format_cc_ident_basic() {
@@ -218,4 +281,65 @@
             quote! { std::vector<int> }
         );
     }
+
+    #[test]
+    fn test_cc_include_to_tokens_for_system_header() {
+        let include = CcInclude::cstddef();
+        assert_cc_matches!(
+            quote! { #include },
+            quote! {
+                __HASH_TOKEN__ include <cstddef>
+            }
+        );
+    }
+
+    #[test]
+    fn test_cc_include_to_tokens_for_user_header() {
+        let include = CcInclude::user_header("some/path/to/header.h".into());
+        assert_cc_matches!(
+            quote! { #include },
+            quote! {
+                __HASH_TOKEN__ include "some/path/to/header.h"
+            }
+        );
+    }
+
+    #[test]
+    fn test_cc_include_ord() {
+        let cstddef = CcInclude::cstddef();
+        let memory = CcInclude::memory();
+        let a = CcInclude::user_header("a.h".into());
+        let b = CcInclude::user_header("b.h".into());
+        assert!(cstddef < memory);
+        assert!(cstddef < a);
+        assert!(cstddef < b);
+        assert!(memory < a);
+        assert!(memory < b);
+        assert!(a < b);
+    }
+
+    #[test]
+    fn test_format_cc_includes() {
+        let includes = [
+            CcInclude::cstddef(),
+            CcInclude::memory(),
+            CcInclude::user_header("a.h".into()),
+            CcInclude::user_header("b.h".into()),
+        ]
+        .into_iter()
+        .collect::<BTreeSet<_>>();
+
+        let tokens = format_cc_includes(&includes);
+        let actual = cc_tokens_to_formatted_string(quote! { __NEWLINE__ #tokens }).unwrap();
+        assert_eq!(
+            actual,
+            r#"
+#include <cstddef>
+#include <memory>
+
+#include "a.h"
+#include "b.h"
+"#
+        );
+    }
 }
diff --git a/rs_bindings_from_cc/ir.rs b/rs_bindings_from_cc/ir.rs
index 4e6d2ba..0e752c8 100644
--- a/rs_bindings_from_cc/ir.rs
+++ b/rs_bindings_from_cc/ir.rs
@@ -102,7 +102,7 @@
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Deserialize)]
 pub struct HeaderName {
-    pub name: String,
+    pub name: Rc<str>,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Deserialize)]
@@ -897,7 +897,7 @@
         "#;
         let ir = deserialize_ir(input.as_bytes()).unwrap();
         let expected = FlatIR {
-            used_headers: vec![HeaderName { name: "foo/bar.h".to_string() }],
+            used_headers: vec![HeaderName { name: "foo/bar.h".into() }],
             current_target: "//foo:bar".into(),
             top_level_item_ids: vec![],
             items: vec![],
diff --git a/rs_bindings_from_cc/src_code_gen.rs b/rs_bindings_from_cc/src_code_gen.rs
index df3fef7..7a5167f 100644
--- a/rs_bindings_from_cc/src_code_gen.rs
+++ b/rs_bindings_from_cc/src_code_gen.rs
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 use arc_anyhow::{Context, Result};
+use code_gen_utils::{format_cc_includes, CcInclude};
 use error_report::{anyhow, bail, ensure, ErrorReport, ErrorReporting, IgnoreErrors};
 use ffi_types::*;
 use ir::*;
@@ -3679,25 +3680,29 @@
         .map(|record| cc_struct_layout_assertion(record, &ir))
         .collect::<Result<Vec<_>>>()?;
 
-    let mut standard_headers = <BTreeSet<Ident>>::new();
-    standard_headers.insert(format_ident!("memory")); // ubiquitous.
+    let mut internal_includes = BTreeSet::new();
+    internal_includes.insert(CcInclude::memory()); // ubiquitous.
     if ir.records().next().is_some() {
-        standard_headers.insert(format_ident!("cstddef"));
+        internal_includes.insert(CcInclude::cstddef());
     };
-
-    let mut includes = vec!["cxx20_backports.h", "offsetof.h"]
-        .into_iter()
-        .map(|hdr| format!("{}/{}", crubit_support_path, hdr))
-        .collect_vec();
+    for crubit_header in ["cxx20_backports.h", "offsetof.h"] {
+        internal_includes.insert(CcInclude::user_header(
+            format!("{crubit_support_path}/{crubit_header}").into(),
+        ));
+    }
+    let internal_includes = format_cc_includes(&internal_includes);
 
     // In order to generate C++ thunk in all the cases Clang needs to be able to
-    // access declarations from public headers of the C++ library.
-    includes.extend(ir.used_headers().map(|hdr| hdr.name.clone()));
+    // access declarations from public headers of the C++ library.  We don't
+    // process these includes via `format_cc_includes` to preserve their
+    // original order (some libraries require certain headers to be included
+    // first - e.g. `config.h`).
+    let ir_includes =
+        ir.used_headers().map(|hdr| CcInclude::user_header(hdr.name.clone())).collect_vec();
 
     Ok(quote! {
-        #( __HASH_TOKEN__ include <#standard_headers> __NEWLINE__)*
-        __NEWLINE__
-        #( __HASH_TOKEN__ include #includes __NEWLINE__)* __NEWLINE__
+        #internal_includes
+        #( #ir_includes )* __NEWLINE__
         __HASH_TOKEN__ pragma clang diagnostic push __NEWLINE__
         // Disable Clang thread-safety-analysis warnings that would otherwise
         // complain about thunks that call mutex locking functions in an unpaired way.