diff --git a/lib/std/zig/target.zig b/lib/std/zig/target.zig
index b9116f557f..1785eb94e6 100644
--- a/lib/std/zig/target.zig
+++ b/lib/std/zig/target.zig
@@ -263,7 +263,8 @@ pub fn isLibCxxLibName(target: std.Target, name: []const u8) bool {
 
     return eqlIgnoreCase(ignore_case, name, "c++") or
         eqlIgnoreCase(ignore_case, name, "stdc++") or
-        eqlIgnoreCase(ignore_case, name, "c++abi");
+        eqlIgnoreCase(ignore_case, name, "c++abi") or
+        eqlIgnoreCase(ignore_case, name, "supc++");
 }
 
 fn eqlIgnoreCase(ignore_case: bool, a: []const u8, b: []const u8) bool {
diff --git a/src/main.zig b/src/main.zig
index 0d239f1f99..cf2d37d086 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -3832,16 +3832,13 @@ fn createModule(
                     create_module.opts.link_libcpp = true;
                     continue;
                 }
-                switch (target_util.classifyCompilerRtLibName(target, lib_name)) {
+                switch (target_util.classifyCompilerRtLibName(lib_name)) {
                     .none => {},
                     .only_libunwind, .both => {
                         create_module.opts.link_libunwind = true;
                         continue;
                     },
-                    .only_compiler_rt => {
-                        warn("ignoring superfluous library '{s}': this dependency is fulfilled instead by compiler-rt which zig unconditionally provides", .{lib_name});
-                        continue;
-                    },
+                    .only_compiler_rt => continue,
                 }
 
                 if (target.isMinGW()) {
diff --git a/src/target.zig b/src/target.zig
index 6297d21bfc..e796b8e271 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -260,17 +260,23 @@ pub fn supportsReturnAddress(target: std.Target) bool {
 
 pub const CompilerRtClassification = enum { none, only_compiler_rt, only_libunwind, both };
 
-pub fn classifyCompilerRtLibName(target: std.Target, name: []const u8) CompilerRtClassification {
-    if (target.abi.isGnu() and std.mem.eql(u8, name, "gcc_s")) {
+pub fn classifyCompilerRtLibName(name: []const u8) CompilerRtClassification {
+    if (std.mem.eql(u8, name, "gcc_s")) {
         // libgcc_s includes exception handling functions, so if linking this library
         // is requested, zig needs to instead link libunwind. Otherwise we end up with
         // the linker unable to find `_Unwind_RaiseException` and other related symbols.
         return .both;
     }
-    if (std.mem.eql(u8, name, "compiler_rt")) {
+    if (std.mem.eql(u8, name, "compiler_rt") or
+        std.mem.eql(u8, name, "gcc") or
+        std.mem.eql(u8, name, "atomic") or
+        std.mem.eql(u8, name, "ssp"))
+    {
         return .only_compiler_rt;
     }
-    if (std.mem.eql(u8, name, "unwind")) {
+    if (std.mem.eql(u8, name, "unwind") or
+        std.mem.eql(u8, name, "gcc_eh"))
+    {
         return .only_libunwind;
     }
     return .none;