diff --git a/src/doc/rustc/src/instrument-coverage.md b/src/doc/rustc/src/instrument-coverage.md
index 41da47e9206..57679f82f48 100644
--- a/src/doc/rustc/src/instrument-coverage.md
+++ b/src/doc/rustc/src/instrument-coverage.md
@@ -27,7 +27,7 @@ Rust's source-based code coverage requires the Rust "profiler runtime". Without
 
 The Rust `nightly` distribution channel includes the profiler runtime, by default.
 
-> **Important**: If you are building the Rust compiler from the source distribution, the profiler runtime is _not_ enabled in the default `config.example.toml`. Edit your `config.toml` file and ensure the `profiler` feature is set it to `true` (either under the `[build]` section, or under the settings for an individual `[target.<triple>]`):
+> **Important**: If you are building the Rust compiler from the source distribution, the profiler runtime is _not_ enabled in the default `bootstrap.example.toml`. Edit your `bootstrap.toml` file and ensure the `profiler` feature is set it to `true` (either under the `[build]` section, or under the settings for an individual `[target.<triple>]`):
 >
 > ```toml
 > # Build the profiler runtime (required when compiling with options that depend
diff --git a/src/doc/rustc/src/platform-support/TEMPLATE.md b/src/doc/rustc/src/platform-support/TEMPLATE.md
index 87dde722558..96c79973a16 100644
--- a/src/doc/rustc/src/platform-support/TEMPLATE.md
+++ b/src/doc/rustc/src/platform-support/TEMPLATE.md
@@ -28,7 +28,7 @@ What format do binaries use by default? ELF, PE, something else?
 ## Building the target
 
 If Rust doesn't build the target by default, how can users build it? Can users
-just add it to the `target` list in `config.toml`?
+just add it to the `target` list in `bootstrap.toml`?
 
 ## Building Rust programs
 
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-teeos.md b/src/doc/rustc/src/platform-support/aarch64-unknown-teeos.md
index 7a6609b2d76..e2f2379ec44 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-teeos.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-teeos.md
@@ -54,7 +54,7 @@ exec /path/to/ohos-sdk/linux/native/llvm/bin/clang++ \
 
 ## Building the target
 
-To build a rust toolchain, create a `config.toml` with the following contents:
+To build a rust toolchain, create a `bootstrap.toml` with the following contents:
 
 ```toml
 profile = "compiler"
diff --git a/src/doc/rustc/src/platform-support/apple-ios.md b/src/doc/rustc/src/platform-support/apple-ios.md
index 5045f810400..cfb458fdb73 100644
--- a/src/doc/rustc/src/platform-support/apple-ios.md
+++ b/src/doc/rustc/src/platform-support/apple-ios.md
@@ -47,7 +47,7 @@ $ rustup target add x86_64-apple-ios
 ```
 
 The tier 3 targets can be built by enabling them for a `rustc` build in
-`config.toml`, by adding, for example:
+`bootstrap.toml`, by adding, for example:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/apple-tvos.md b/src/doc/rustc/src/platform-support/apple-tvos.md
index 7a3b601579a..166bb1b6db2 100644
--- a/src/doc/rustc/src/platform-support/apple-tvos.md
+++ b/src/doc/rustc/src/platform-support/apple-tvos.md
@@ -52,7 +52,7 @@ The following APIs are currently known to have missing or incomplete support:
 ## Building the target
 
 The targets can be built by enabling them for a `rustc` build in
-`config.toml`, by adding, for example:
+`bootstrap.toml`, by adding, for example:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/apple-visionos.md b/src/doc/rustc/src/platform-support/apple-visionos.md
index 56224d7e20d..a7bbae168a4 100644
--- a/src/doc/rustc/src/platform-support/apple-visionos.md
+++ b/src/doc/rustc/src/platform-support/apple-visionos.md
@@ -31,7 +31,7 @@ case `XROS_DEPLOYMENT_TARGET`.
 ## Building the target
 
 The targets can be built by enabling them for a `rustc` build in
-`config.toml`, by adding, for example:
+`bootstrap.toml`, by adding, for example:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/apple-watchos.md b/src/doc/rustc/src/platform-support/apple-watchos.md
index 8ba35f70b85..0bf8cdf3614 100644
--- a/src/doc/rustc/src/platform-support/apple-watchos.md
+++ b/src/doc/rustc/src/platform-support/apple-watchos.md
@@ -37,7 +37,7 @@ case `WATCHOS_DEPLOYMENT_TARGET`.
 ## Building the target
 
 The targets can be built by enabling them for a `rustc` build in
-`config.toml`, by adding, for example:
+`bootstrap.toml`, by adding, for example:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/arm64e-apple-darwin.md b/src/doc/rustc/src/platform-support/arm64e-apple-darwin.md
index 322a07c5739..3200b7ae1b6 100644
--- a/src/doc/rustc/src/platform-support/arm64e-apple-darwin.md
+++ b/src/doc/rustc/src/platform-support/arm64e-apple-darwin.md
@@ -16,7 +16,7 @@ See the docs on [`*-apple-darwin`](apple-darwin.md) for general macOS requiremen
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`:
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/arm64e-apple-ios.md b/src/doc/rustc/src/platform-support/arm64e-apple-ios.md
index 3d8ba5c282a..aa99276a68f 100644
--- a/src/doc/rustc/src/platform-support/arm64e-apple-ios.md
+++ b/src/doc/rustc/src/platform-support/arm64e-apple-ios.md
@@ -14,7 +14,7 @@ See the docs on [`*-apple-ios`](apple-ios.md) for general iOS requirements.
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`:
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/arm64e-apple-tvos.md b/src/doc/rustc/src/platform-support/arm64e-apple-tvos.md
index ec8a996549e..332ea750f20 100644
--- a/src/doc/rustc/src/platform-support/arm64e-apple-tvos.md
+++ b/src/doc/rustc/src/platform-support/arm64e-apple-tvos.md
@@ -15,7 +15,7 @@ To build this target Xcode 12 or higher on macOS is required.
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`:
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/arm64ec-pc-windows-msvc.md b/src/doc/rustc/src/platform-support/arm64ec-pc-windows-msvc.md
index 15bf55d35a2..67903ae6401 100644
--- a/src/doc/rustc/src/platform-support/arm64ec-pc-windows-msvc.md
+++ b/src/doc/rustc/src/platform-support/arm64ec-pc-windows-msvc.md
@@ -56,7 +56,7 @@ To put this in practice:
 ## Building the target
 
 You can build Rust with support for the targets by adding it to the `target`
-list in `config.toml`:
+list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md b/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
index 3c3e35a51b8..3a5b5a38017 100644
--- a/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
+++ b/src/doc/rustc/src/platform-support/armeb-unknown-linux-gnueabi.md
@@ -21,7 +21,7 @@ The target definition can be seen [here](https://github.com/rust-lang/rust/blob/
 ## Building the target
 Because it is Tier 3, rust does not yet ship pre-compiled artifacts for this target.
 
-Therefore, you can build Rust with support for the target by adding it to the target list in config.toml, a sample configuration is shown below. It is expected that the user already have a working GNU compiler toolchain and update the paths accordingly.
+Therefore, you can build Rust with support for the target by adding it to the target list in bootstrap.toml, a sample configuration is shown below. It is expected that the user already have a working GNU compiler toolchain and update the paths accordingly.
 
 ```toml
 [llvm]
diff --git a/src/doc/rustc/src/platform-support/armv6k-nintendo-3ds.md b/src/doc/rustc/src/platform-support/armv6k-nintendo-3ds.md
index 160986aeae9..a085aef2d04 100644
--- a/src/doc/rustc/src/platform-support/armv6k-nintendo-3ds.md
+++ b/src/doc/rustc/src/platform-support/armv6k-nintendo-3ds.md
@@ -50,7 +50,7 @@ This target generates binaries in the ELF format.
 ## Building the target
 
 You can build Rust with support for the target by adding it to the `target`
-list in `config.toml` and providing paths to the devkitARM toolchain.
+list in `bootstrap.toml` and providing paths to the devkitARM toolchain.
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md b/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md
index 1c8acc09c77..f687f6f0695 100644
--- a/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md
+++ b/src/doc/rustc/src/platform-support/armv7-unknown-linux-uclibceabihf.md
@@ -22,7 +22,7 @@ If you don't already have a suitable toolchain, download one [here](https://tool
 
 ### Configure rust
 
-The target can be built by enabling it for a `rustc` build, by placing the following in `config.toml`:
+The target can be built by enabling it for a `rustc` build, by placing the following in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/csky-unknown-linux-gnuabiv2.md b/src/doc/rustc/src/platform-support/csky-unknown-linux-gnuabiv2.md
index 32e4f855313..f749b37aa7a 100644
--- a/src/doc/rustc/src/platform-support/csky-unknown-linux-gnuabiv2.md
+++ b/src/doc/rustc/src/platform-support/csky-unknown-linux-gnuabiv2.md
@@ -36,7 +36,7 @@ If you don't already have a suitable toolchain, you can download from [here](htt
 
 ### Configure rust
 
-The target can be built by enabling it for a `rustc` build, by placing the following in `config.toml`:
+The target can be built by enabling it for a `rustc` build, by placing the following in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/fuchsia.md b/src/doc/rustc/src/platform-support/fuchsia.md
index 489f46e1cb9..bed5b81adc5 100644
--- a/src/doc/rustc/src/platform-support/fuchsia.md
+++ b/src/doc/rustc/src/platform-support/fuchsia.md
@@ -180,7 +180,7 @@ Fuchsia as well. A recent version (14+) of clang should be sufficient to compile
 Rust for Fuchsia.
 
 x86-64 and AArch64 Fuchsia targets can be enabled using the following
-configuration in `config.toml`:
+configuration in `bootstrap.toml`:
 
 ```toml
 [build]
@@ -212,7 +212,7 @@ cxx = "clang++"
 
 By default, the Rust compiler installs itself to `/usr/local` on most UNIX
 systems. You may want to install it to another location (e.g. a local `install`
-directory) by setting a custom prefix in `config.toml`:
+directory) by setting a custom prefix in `bootstrap.toml`:
 
 ```toml
 [install]
@@ -695,7 +695,7 @@ We can then use the script to start our test environment with:
 )
 ```
 
-Where `${RUST_SRC_PATH}/build` is the `build-dir` set in `config.toml`.
+Where `${RUST_SRC_PATH}/build` is the `build-dir` set in `bootstrap.toml`.
 
 Once our environment is started, we can run our tests using `x.py` as usual. The
 test runner script will run the compiled tests on an emulated Fuchsia device. To
@@ -705,7 +705,7 @@ run the full `tests/ui` test suite:
 ( \
     source config-env.sh &&                                                   \
     ./x.py                                                                    \
-    --config config.toml                                                      \
+    --config bootstrap.toml                                                      \
     --stage=2                                                                 \
     test tests/ui                                                             \
     --target x86_64-unknown-fuchsia                                           \
@@ -893,7 +893,7 @@ through our `x.py` invocation. The full invocation is:
 ( \
     source config-env.sh &&                                                   \
     ./x.py                                                                    \
-    --config config.toml                                                      \
+    --config bootstrap.toml                                                      \
     --stage=2                                                                 \
     test tests/${TEST}                                                        \
     --target x86_64-unknown-fuchsia                                           \
diff --git a/src/doc/rustc/src/platform-support/hermit.md b/src/doc/rustc/src/platform-support/hermit.md
index 5aa787e53e1..df7bc495fce 100644
--- a/src/doc/rustc/src/platform-support/hermit.md
+++ b/src/doc/rustc/src/platform-support/hermit.md
@@ -31,7 +31,7 @@ Hermit binaries have the ELF format.
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`.
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`.
 To run the Hermit build scripts, you also have to enable your host target.
 The build scripts rely on `llvm-tools` and binaries are linked using `rust-lld`, so those have to be enabled as well.
 
diff --git a/src/doc/rustc/src/platform-support/hexagon-unknown-linux-musl.md b/src/doc/rustc/src/platform-support/hexagon-unknown-linux-musl.md
index d858337a949..cfd2b2bac9c 100644
--- a/src/doc/rustc/src/platform-support/hexagon-unknown-linux-musl.md
+++ b/src/doc/rustc/src/platform-support/hexagon-unknown-linux-musl.md
@@ -44,7 +44,7 @@ Because it is Tier 3, rust does not yet ship pre-compiled artifacts for this
 target.
 
 Therefore, you can build Rust with support for the target by adding it to the
-target list in `config.toml`, a sample configuration is shown below.
+target list in `bootstrap.toml`, a sample configuration is shown below.
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/hexagon-unknown-none-elf.md b/src/doc/rustc/src/platform-support/hexagon-unknown-none-elf.md
index a0e26b798ac..c7726eacaf4 100644
--- a/src/doc/rustc/src/platform-support/hexagon-unknown-none-elf.md
+++ b/src/doc/rustc/src/platform-support/hexagon-unknown-none-elf.md
@@ -28,7 +28,7 @@ This target generates PIC ELF binaries.
 ## Building the target
 
 You can build Rust with support for the target by adding it to the `target`
-list in `config.toml`:
+list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/i686-apple-darwin.md b/src/doc/rustc/src/platform-support/i686-apple-darwin.md
index d69fa97ce63..abb64dcc986 100644
--- a/src/doc/rustc/src/platform-support/i686-apple-darwin.md
+++ b/src/doc/rustc/src/platform-support/i686-apple-darwin.md
@@ -17,7 +17,7 @@ You'll need the macOS 10.13 SDK shipped with Xcode 9. The location of the SDK
 can be passed to `rustc` using the common `SDKROOT` environment variable.
 
 Once you have that, you can build Rust with support for the target by adding
-it to the `target` list in `config.toml`:
+it to the `target` list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/kmc-solid.md b/src/doc/rustc/src/platform-support/kmc-solid.md
index bbcd0f711c6..44f47927286 100644
--- a/src/doc/rustc/src/platform-support/kmc-solid.md
+++ b/src/doc/rustc/src/platform-support/kmc-solid.md
@@ -32,7 +32,7 @@ The target can be built by enabling it for a `rustc` build.
 target = ["aarch64-kmc-solid_asp3"]
 ```
 
-Make sure `aarch64-kmc-elf-gcc` is included in `$PATH`. Alternatively, you can use GNU Arm Embedded Toolchain by adding the following to `config.toml`:
+Make sure `aarch64-kmc-elf-gcc` is included in `$PATH`. Alternatively, you can use GNU Arm Embedded Toolchain by adding the following to `bootstrap.toml`:
 
 ```toml
 [target.aarch64-kmc-solid_asp3]
diff --git a/src/doc/rustc/src/platform-support/loongarch-linux.md b/src/doc/rustc/src/platform-support/loongarch-linux.md
index 45eb0a81216..2c9f712ce82 100644
--- a/src/doc/rustc/src/platform-support/loongarch-linux.md
+++ b/src/doc/rustc/src/platform-support/loongarch-linux.md
@@ -65,7 +65,7 @@ These targets are distributed through `rustup`, and otherwise require no
 special configuration.
 
 If you need to build your own Rust for some reason though, the targets can be
-simply enabled in `config.toml`. For example:
+simply enabled in `bootstrap.toml`. For example:
 
 ```toml
 [build]
@@ -73,7 +73,7 @@ target = ["loongarch64-unknown-linux-gnu"]
 ```
 
 Make sure the LoongArch toolchain binaries are reachable from `$PATH`.
-Alternatively, you can explicitly configure the paths in `config.toml`:
+Alternatively, you can explicitly configure the paths in `bootstrap.toml`:
 
 ```toml
 [target.loongarch64-unknown-linux-gnu]
diff --git a/src/doc/rustc/src/platform-support/loongarch-none.md b/src/doc/rustc/src/platform-support/loongarch-none.md
index bafa85c26e2..6c5d8669830 100644
--- a/src/doc/rustc/src/platform-support/loongarch-none.md
+++ b/src/doc/rustc/src/platform-support/loongarch-none.md
@@ -46,7 +46,7 @@ scripts.
 ## Building the target
 
 You can build Rust with support for the targets by adding them to the `target`
-list in `config.toml`:
+list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/mips-release-6.md b/src/doc/rustc/src/platform-support/mips-release-6.md
index 9203a31e9f4..b779477996d 100644
--- a/src/doc/rustc/src/platform-support/mips-release-6.md
+++ b/src/doc/rustc/src/platform-support/mips-release-6.md
@@ -67,7 +67,7 @@ The following procedure outlines the build process for the MIPS64 R6 target with
 
 ### Prerequisite: Disable debuginfo
 
-An LLVM bug makes rustc crash if debug or debug info generation is enabled. You need to edit `config.toml` to disable this:
+An LLVM bug makes rustc crash if debug or debug info generation is enabled. You need to edit `bootstrap.toml` to disable this:
 
 ```toml
 [rust]
@@ -83,7 +83,7 @@ The crate `rustix` may try to link itself against MIPS R2 assembly, resulting in
 export RUSTFLAGS="--cfg rustix_use_libc"
 ```
 
-This will trigger warnings during build, as `-D warnings` is enabled by default. Disable `-D warnings` by editing `config.toml` to append the following:
+This will trigger warnings during build, as `-D warnings` is enabled by default. Disable `-D warnings` by editing `bootstrap.toml` to append the following:
 
 ```toml
 [rust]
@@ -116,7 +116,7 @@ target = ["mipsisa64r6el-unknown-linux-gnuabi64"]
 
 Make sure that `mipsisa64r6el-unknown-linux-gnuabi64-gcc` is available from your executable search path (`$PATH`).
 
-Alternatively, you can specify the directories to all necessary toolchain executables in `config.toml`:
+Alternatively, you can specify the directories to all necessary toolchain executables in `bootstrap.toml`:
 
 ```toml
 [target.mipsisa64r6el-unknown-linux-gnuabi64]
diff --git a/src/doc/rustc/src/platform-support/nto-qnx.md b/src/doc/rustc/src/platform-support/nto-qnx.md
index 77e8caaee4c..e097d32277d 100644
--- a/src/doc/rustc/src/platform-support/nto-qnx.md
+++ b/src/doc/rustc/src/platform-support/nto-qnx.md
@@ -124,7 +124,7 @@ For conditional compilation, following QNX specific attributes are defined:
 
 ## Building the target
 
-1. Create a `config.toml`
+1. Create a `bootstrap.toml`
 
     Example content:
 
diff --git a/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md b/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
index 1af1410d4bb..ab8641ff69a 100644
--- a/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
+++ b/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
@@ -32,7 +32,7 @@ What format do binaries use by default? ELF, PE, something else?
 ## Building the target
 
 If Rust doesn't build the target by default, how can users build it? Can users
-just add it to the `target` list in `config.toml`?
+just add it to the `target` list in `bootstrap.toml`?
 
 ## Building Rust programs
 
diff --git a/src/doc/rustc/src/platform-support/openharmony.md b/src/doc/rustc/src/platform-support/openharmony.md
index e772a3d09f3..ab50cbcdf97 100644
--- a/src/doc/rustc/src/platform-support/openharmony.md
+++ b/src/doc/rustc/src/platform-support/openharmony.md
@@ -145,7 +145,7 @@ linker = "/path/to/x86_64-unknown-linux-ohos-clang.sh"
 ## Building the target from source
 
 Instead of using `rustup`, you can instead build a rust toolchain from source.
-Create a `config.toml` with the following contents:
+Create a `bootstrap.toml` with the following contents:
 
 ```toml
 profile = "compiler"
diff --git a/src/doc/rustc/src/platform-support/pc-windows-gnullvm.md b/src/doc/rustc/src/platform-support/pc-windows-gnullvm.md
index 89c4cdb2afc..f14fe7df422 100644
--- a/src/doc/rustc/src/platform-support/pc-windows-gnullvm.md
+++ b/src/doc/rustc/src/platform-support/pc-windows-gnullvm.md
@@ -29,7 +29,7 @@ Like with any other Windows target, created binaries are in PE format.
 
 These targets can be easily cross-compiled
 using [llvm-mingw](https://github.com/mstorsjo/llvm-mingw) toolchain or [MSYS2 CLANG*](https://www.msys2.org/docs/environments/) environments.
-Just fill `[target.*]` sections for both build and resulting compiler and set installation prefix in `config.toml`.
+Just fill `[target.*]` sections for both build and resulting compiler and set installation prefix in `bootstrap.toml`.
 Then run `./x.py install`.
 In my case I had ran `./x.py install --host x86_64-pc-windows-gnullvm --target x86_64-pc-windows-gnullvm` inside MSYS2 MINGW64 shell
 so `x86_64-pc-windows-gnu` was my build toolchain.
diff --git a/src/doc/rustc/src/platform-support/powerpc64le-unknown-linux-musl.md b/src/doc/rustc/src/platform-support/powerpc64le-unknown-linux-musl.md
index 3bd3f5d8b7f..e1e3d6d31c0 100644
--- a/src/doc/rustc/src/platform-support/powerpc64le-unknown-linux-musl.md
+++ b/src/doc/rustc/src/platform-support/powerpc64le-unknown-linux-musl.md
@@ -23,7 +23,7 @@ The target can be built by enabling it for a `rustc` build.
 target = ["powerpc64le-unknown-linux-musl"]
 ```
 
-Make sure your C compiler is included in `$PATH`, then add it to the `config.toml`:
+Make sure your C compiler is included in `$PATH`, then add it to the `bootstrap.toml`:
 
 ```toml
 [target.powerpc64le-unknown-linux-musl]
diff --git a/src/doc/rustc/src/platform-support/redox.md b/src/doc/rustc/src/platform-support/redox.md
index 2bba92d504c..c1a96f1cfc4 100644
--- a/src/doc/rustc/src/platform-support/redox.md
+++ b/src/doc/rustc/src/platform-support/redox.md
@@ -27,7 +27,7 @@ Redox OS binaries use ELF as file format.
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`. In addition a copy of [relibc] needs to be present in the linker search path.
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`. In addition a copy of [relibc] needs to be present in the linker search path.
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/riscv32im-risc0-zkvm-elf.md b/src/doc/rustc/src/platform-support/riscv32im-risc0-zkvm-elf.md
index 1fdd594012c..79455b0fbc4 100644
--- a/src/doc/rustc/src/platform-support/riscv32im-risc0-zkvm-elf.md
+++ b/src/doc/rustc/src/platform-support/riscv32im-risc0-zkvm-elf.md
@@ -43,7 +43,7 @@ Calling `extern "C"` on the target uses the C calling convention outlined in the
 ## Building for the zkVM
 
 Programs for the zkVM could be built by adding it to the `target` list in
-`config.toml`. However, we recommend building programs in our starter template
+`bootstrap.toml`. However, we recommend building programs in our starter template
 generated by the [cargo-risczero] utility and the [risc0-build] crate. This
 crate calls `rustc` with `-C "link-arg=-Ttext=` so that it maps the text in the
 appropriate location as well as generating variables that represent the ELF and
diff --git a/src/doc/rustc/src/platform-support/riscv32imac-unknown-xous-elf.md b/src/doc/rustc/src/platform-support/riscv32imac-unknown-xous-elf.md
index f024cd25bf7..12928edfcac 100644
--- a/src/doc/rustc/src/platform-support/riscv32imac-unknown-xous-elf.md
+++ b/src/doc/rustc/src/platform-support/riscv32imac-unknown-xous-elf.md
@@ -24,7 +24,7 @@ The target can be built by enabling it for a `rustc` build.
 target = ["riscv32imac-unknown-xous-elf"]
 ```
 
-Make sure your C compiler is included in `$PATH`, then add it to the `config.toml`:
+Make sure your C compiler is included in `$PATH`, then add it to the `bootstrap.toml`:
 
 ```toml
 [target.riscv32imac-unknown-xous-elf]
diff --git a/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-gnu.md b/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-gnu.md
index dda2a50c33d..1ab867fe71e 100644
--- a/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-gnu.md
+++ b/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-gnu.md
@@ -26,7 +26,7 @@ These targets are distributed through `rustup`, and otherwise require no
 special configuration.
 
 If you need to build your own Rust for some reason though, the targets can be
-enabled in `config.toml`. For example:
+enabled in `bootstrap.toml`. For example:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-musl.md b/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-musl.md
index 5b3dc683038..5e6275d6979 100644
--- a/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-musl.md
+++ b/src/doc/rustc/src/platform-support/riscv64gc-unknown-linux-musl.md
@@ -22,7 +22,7 @@ The target can be built by enabling it for a `rustc` build.
 target = ["riscv64gc-unknown-linux-musl"]
 ```
 
-Make sure your C compiler is included in `$PATH`, then add it to the `config.toml`:
+Make sure your C compiler is included in `$PATH`, then add it to the `bootstrap.toml`:
 
 ```toml
 [target.riscv64gc-unknown-linux-musl]
diff --git a/src/doc/rustc/src/platform-support/s390x-unknown-linux-gnu.md b/src/doc/rustc/src/platform-support/s390x-unknown-linux-gnu.md
index 6f09ce42dbb..1aa2704cf95 100644
--- a/src/doc/rustc/src/platform-support/s390x-unknown-linux-gnu.md
+++ b/src/doc/rustc/src/platform-support/s390x-unknown-linux-gnu.md
@@ -34,7 +34,7 @@ This target is distributed through `rustup`, and otherwise requires no
 special configuration.
 
 If you need to build your own Rust for some reason though, the target can be
-enabled in `config.toml`. For example:
+enabled in `bootstrap.toml`. For example:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md b/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md
index e00f8db7f8e..3c334620cfc 100644
--- a/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md
+++ b/src/doc/rustc/src/platform-support/s390x-unknown-linux-musl.md
@@ -33,7 +33,7 @@ Because it is Tier 3, Rust does not yet ship pre-compiled artifacts for this
 target.
 
 Therefore, you can build Rust with support for the target by adding it to the
-target list in `config.toml`, a sample configuration is shown below.
+target list in `bootstrap.toml`, a sample configuration is shown below.
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md b/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md
index f579b1fb8d4..c19b7d7681a 100644
--- a/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md
+++ b/src/doc/rustc/src/platform-support/sparc-unknown-none-elf.md
@@ -34,7 +34,7 @@ considerations for binary layout will require linker options or linker scripts.
 ## Building the target
 
 You can build Rust with support for the target by adding it to the `target`
-list in `config.toml`:
+list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/unikraft-linux-musl.md b/src/doc/rustc/src/platform-support/unikraft-linux-musl.md
index c589208c099..b40e99825e5 100644
--- a/src/doc/rustc/src/platform-support/unikraft-linux-musl.md
+++ b/src/doc/rustc/src/platform-support/unikraft-linux-musl.md
@@ -34,7 +34,7 @@ Instead, the Unikraft build system will produce the final Unikernel image for th
 
 ## Building the targets
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`:
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md
index e6917502182..e9979cc912c 100644
--- a/src/doc/rustc/src/platform-support/unknown-uefi.md
+++ b/src/doc/rustc/src/platform-support/unknown-uefi.md
@@ -252,7 +252,7 @@ This section contains information on how to use std on UEFI.
 
 ### Build std
 The building std part is pretty much the same as the official [docs](https://rustc-dev-guide.rust-lang.org/getting-started.html).
-The linker that should be used is `rust-lld`. Here is a sample `config.toml`:
+The linker that should be used is `rust-lld`. Here is a sample `bootstrap.toml`:
 ```toml
 [rust]
 lld = true
diff --git a/src/doc/rustc/src/platform-support/vxworks.md b/src/doc/rustc/src/platform-support/vxworks.md
index 6aa3d8b7361..a2b91f3769d 100644
--- a/src/doc/rustc/src/platform-support/vxworks.md
+++ b/src/doc/rustc/src/platform-support/vxworks.md
@@ -33,7 +33,7 @@ Rust for each target can be cross-compiled with its specific target vsb configur
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the `target` list in `config.toml`. In addition the workbench and wr-cc have to configured and activated.
+You can build Rust with support for the targets by adding it to the `target` list in `bootstrap.toml`. In addition the workbench and wr-cc have to configured and activated.
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-emscripten.md b/src/doc/rustc/src/platform-support/wasm32-unknown-emscripten.md
index d364852b1c1..6949c657db8 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-emscripten.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-emscripten.md
@@ -61,7 +61,7 @@ Building this target can be done by:
 * Configure the `wasm32-unknown-emscripten` target to get built.
 * Ensure the `WebAssembly` target backend is not disabled in LLVM.
 
-These are all controlled through `config.toml` options. It should be possible
+These are all controlled through `bootstrap.toml` options. It should be possible
 to build this target on any platform. A minimal example configuration would be:
 
 ```toml
diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index ba95ab7af6d..150f69e03c6 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -65,7 +65,7 @@ Building this target can be done by:
 * Configure LLD to be built.
 * Ensure the `WebAssembly` target backend is not disabled in LLVM.
 
-These are all controlled through `config.toml` options. It should be possible
+These are all controlled through `bootstrap.toml` options. It should be possible
 to build this target on any platform.
 
 ## Building Rust programs
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md b/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
index 1b0a312ca9c..af20b62b9f6 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
@@ -107,7 +107,7 @@ flag, for example:
 
 Users need to install or built wasi-sdk since release 20.0
 https://github.com/WebAssembly/wasi-sdk/releases/tag/wasi-sdk-20
-and specify path to *wasi-root* `config.toml`
+and specify path to *wasi-root* `bootstrap.toml`
 
 ```toml
 [target.wasm32-wasip1-threads]
@@ -115,7 +115,7 @@ wasi-root = ".../wasi-libc/sysroot"
 ```
 
 After that users can build this by adding it to the `target` list in
-`config.toml`, or with `-Zbuild-std`.
+`bootstrap.toml`, or with `-Zbuild-std`.
 
 ## Building Rust programs
 
diff --git a/src/doc/rustc/src/platform-support/wasm64-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm64-unknown-unknown.md
index a717f5dad79..157fff419d3 100644
--- a/src/doc/rustc/src/platform-support/wasm64-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm64-unknown-unknown.md
@@ -64,7 +64,7 @@ This target does not support `panic=unwind` at this time.
 ## Building the target
 
 You can build Rust with support for the target by adding it to the `target`
-list in `config.toml`, and the target also requires `lld` to be built to work.
+list in `bootstrap.toml`, and the target also requires `lld` to be built to work.
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/win7-windows-gnu.md b/src/doc/rustc/src/platform-support/win7-windows-gnu.md
index 180a1dc6d26..3a819b0a4e2 100644
--- a/src/doc/rustc/src/platform-support/win7-windows-gnu.md
+++ b/src/doc/rustc/src/platform-support/win7-windows-gnu.md
@@ -23,7 +23,7 @@ Like any other Windows target, the created binaries are in PE format.
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the target list in config.toml:
+You can build Rust with support for the targets by adding it to the target list in bootstrap.toml:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/win7-windows-msvc.md b/src/doc/rustc/src/platform-support/win7-windows-msvc.md
index 77b7d68212b..cbbb44b47aa 100644
--- a/src/doc/rustc/src/platform-support/win7-windows-msvc.md
+++ b/src/doc/rustc/src/platform-support/win7-windows-msvc.md
@@ -24,7 +24,7 @@ Like any other Windows target, the created binaries are in PE format.
 
 ## Building the target
 
-You can build Rust with support for the targets by adding it to the target list in config.toml:
+You can build Rust with support for the targets by adding it to the target list in bootstrap.toml:
 
 ```toml
 [build]
@@ -73,7 +73,7 @@ Windows SDK, which can be acquired using [`xwin`](https://github.com/Jake-Shadle
   clang-cl /imsvc "$XWIN/crt/include" /imsvc "$XWIN/sdk/include/ucrt" /imsvc "$XWIN/sdk/include/um" /imsvc "$XWIN/sdk/include/shared" --target="x86_64-pc-windows-msvc" "$@"
   ```
 
-- In your config.toml, add the following lines:
+- In your bootstrap.toml, add the following lines:
 
   ```toml
   [target.x86_64-win7-windows-msvc]
diff --git a/src/doc/rustc/src/platform-support/x86_64-unknown-none.md b/src/doc/rustc/src/platform-support/x86_64-unknown-none.md
index bd5fd1d0502..3b8aae3a389 100644
--- a/src/doc/rustc/src/platform-support/x86_64-unknown-none.md
+++ b/src/doc/rustc/src/platform-support/x86_64-unknown-none.md
@@ -39,7 +39,7 @@ scripts.
 ## Building the target
 
 You can build Rust with support for the target by adding it to the `target`
-list in `config.toml`:
+list in `bootstrap.toml`:
 
 ```toml
 [build]
diff --git a/src/doc/rustc/src/platform-support/x86_64h-apple-darwin.md b/src/doc/rustc/src/platform-support/x86_64h-apple-darwin.md
index 6c2a6a41101..545fffb84f9 100644
--- a/src/doc/rustc/src/platform-support/x86_64h-apple-darwin.md
+++ b/src/doc/rustc/src/platform-support/x86_64h-apple-darwin.md
@@ -29,7 +29,7 @@ respects.
 ## Building the target
 
 Users on Apple targets can build this by adding it to the `target` list in
-`config.toml`, or with `-Zbuild-std`.
+`bootstrap.toml`, or with `-Zbuild-std`.
 
 ## Building Rust programs