Rudimentary name mangling support

toolchain/codegen/testdata/assembly/basic.carbon

@@ -5,6 +5,6 @@
 // ARGS: compile --no-prelude-import --target=x86_64-unknown-linux-gnu --output=- %s
 // NOAUTOUPDATE
 // SET-CHECK-SUBSET
-// CHECK:STDOUT: Main:
+// CHECK:STDOUT: _CMain.Main:
 
 fn Main() {}

toolchain/lower/BUILD

@@ -32,6 +32,8 @@ cc_library(
         "constant.h",
         "file_context.cpp",
         "function_context.cpp",
+        "mangler.cpp",
+        "mangler.h",
     ] +
     # Glob handler files to avoid missing any.
     glob([

toolchain/lower/file_context.cpp

@@ -11,6 +11,7 @@
 #include "toolchain/base/kind_switch.h"
 #include "toolchain/lower/constant.h"
 #include "toolchain/lower/function_context.h"
+#include "toolchain/lower/mangler.h"
 #include "toolchain/sem_ir/entry_point.h"
 #include "toolchain/sem_ir/file.h"
 #include "toolchain/sem_ir/function.h"
@@ -233,22 +234,15 @@ auto FileContext::BuildFunctionDecl(SemIR::FunctionId function_id)
 
   // Compute the return type to use for the LLVM function. If the initializing
   // representation doesn't produce a value, set the return type to void.
+  // TODO: For the `Run` entry point, remap return type to i32 if it doesn't
+  // return a value.
   llvm::Type* function_return_type =
       return_info.init_repr.kind == SemIR::InitRepr::ByCopy
           ? return_type
           : llvm::Type::getVoidTy(llvm_context());
 
-  std::string mangled_name;
-  if (SemIR::IsEntryPoint(sem_ir(), function_id)) {
-    // TODO: Add an implicit `return 0` if `Run` doesn't return `i32`.
-    mangled_name = "main";
-  } else {
-    // TODO: Decide on a name mangling scheme.
-    auto name = sem_ir().names().GetAsStringIfIdentifier(function.name_id);
-    CARBON_CHECK(name) << "Unexpected special name for function: "
-                       << function.name_id;
-    mangled_name = *name;
-  }
+  Mangler m(*this);
+  std::string mangled_name = m.Mangle(function_id);
 
   llvm::FunctionType* function_type = llvm::FunctionType::get(
       function_return_type, param_types, /*isVarArg=*/false);

toolchain/lower/mangler.cpp

@@ -0,0 +1,116 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "toolchain/lower/mangler.h"
+
+#include "toolchain/base/kind_switch.h"
+#include "toolchain/sem_ir/entry_point.h"
+
+namespace Carbon::Lower {
+
+auto Mangler::MangleInverseQualifiedNameScope(llvm::raw_ostream& os,
+                                              SemIR::NameScopeId name_scope_id)
+    -> void {
+  // Maintain a stack of names for delayed rendering of interface impls.
+  struct NameEntry {
+    SemIR::NameScopeId name_scope_id;
+
+    // The prefix emitted before this name component. If '\0', no prefix will be
+    // emitted.
+    // - Namespace components are separated by '.'.
+    // - The two components of an interface are separated by ':'.
+    char prefix;
+  };
+  llvm::SmallVector<NameEntry> names_to_render;
+  names_to_render.push_back({.name_scope_id = name_scope_id, .prefix = '.'});
+  while (!names_to_render.empty()) {
+    auto [name_scope_id, prefix] = names_to_render.pop_back_val();
+    if (prefix) {
+      os << prefix;
+    }
+    if (name_scope_id == SemIR::NameScopeId::Package) {
+      if (auto package_id = sem_ir().package_id(); package_id.is_valid()) {
+        os << sem_ir().identifiers().Get(package_id);
+      } else {
+        os << "Main";
+      }
+      continue;
+    }
+    const auto& name_scope = sem_ir().name_scopes().Get(name_scope_id);
+    CARBON_KIND_SWITCH(sem_ir().insts().Get(name_scope.inst_id)) {
+      case CARBON_KIND(SemIR::ImplDecl impl_decl): {
+
+        const auto& impl = sem_ir().impls().Get(impl_decl.impl_id);
+
+        auto interface_type =
+            types().GetAs<SemIR::InterfaceType>(impl.constraint_id);
+        const auto& interface =
+            sem_ir().interfaces().Get(interface_type.interface_id);
+        names_to_render.push_back(
+            {.name_scope_id = interface.scope_id, .prefix = ':'});
+
+        CARBON_KIND_SWITCH(types().GetAsInst(impl.self_id)) {
+          case CARBON_KIND(SemIR::ClassType class_type): {
+            auto next_name_scope_id =
+                sem_ir().classes().Get(class_type.class_id).scope_id;
+            names_to_render.push_back(
+                {.name_scope_id = next_name_scope_id, .prefix = '\0'});
+            break;
+          }
+          case CARBON_KIND(SemIR::BuiltinInst builtin_inst): {
+            os << builtin_inst.builtin_inst_kind.label();
+            break;
+          }
+          default:
+            CARBON_FATAL() << "Attempting to mangle unsupported SemIR.";
+            break;
+        }
+        // Skip the tail of the loop that adds the parent name scope to the
+        // stack - the scope in which the impl was defined is not part of the
+        // mangling, the constraint and interface alone uniquelify identify an
+        // impl.
+        continue;
+      }
+      case CARBON_KIND(SemIR::ClassDecl class_decl): {
+        os << names().GetAsStringIfIdentifier(
+            sem_ir().classes().Get(class_decl.class_id).name_id);
+        break;
+      }
+      case CARBON_KIND(SemIR::InterfaceDecl interface_decl): {
+        os << names().GetAsStringIfIdentifier(
+            sem_ir().interfaces().Get(interface_decl.interface_id).name_id);
+        break;
+      }
+      case SemIR::Namespace::Kind: {
+        os << names().GetAsStringIfIdentifier(name_scope.name_id);
+        break;
+      }
+      default:
+        CARBON_FATAL() << "Attempting to mangle unsupported SemIR.";
+        break;
+    }
+    names_to_render.push_back(
+        {.name_scope_id = name_scope.parent_scope_id, .prefix = '.'});
+  }
+}
+
+auto Mangler::Mangle(SemIR::FunctionId function_id) -> std::string {
+  // FIXME: Add support for generic entities.
+
+  const auto& function = sem_ir().functions().Get(function_id);
+  if (SemIR::IsEntryPoint(sem_ir(), function_id)) {
+    return "main";
+  }
+  std::string result;
+  llvm::raw_string_ostream os(result);
+  os << "_C";
+
+  os << names().GetAsStringIfIdentifier(function.name_id);
+
+  MangleInverseQualifiedNameScope(os, function.parent_scope_id);
+
+  return os.str();
+}
+
+}  // namespace Carbon::Lower

toolchain/lower/mangler.h

@@ -0,0 +1,48 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef CARBON_TOOLCHAIN_LOWER_MANGLER_H_
+#define CARBON_TOOLCHAIN_LOWER_MANGLER_H_
+
+#include <string>
+
+#include "toolchain/lower/file_context.h"
+#include "toolchain/sem_ir/ids.h"
+
+namespace Carbon::Lower {
+
+// A class for producing mangled (deterministically unique, at least partially
+// human readable) names for externally referenceable entities such as
+// functions.
+class Mangler {
+ public:
+  // Initialize a new Mangler instance for mangling entities within the
+  // specified `FileContext`.
+  explicit Mangler(FileContext& file_context) : file_context_(file_context) {}
+
+  // Produce a deterministically unique mangled name for the function specified
+  // by `function_id`.
+  auto Mangle(SemIR::FunctionId function_id) -> std::string;
+
+ private:
+  // Mangle this qualified name with inner scope first, working outwards. This
+  // may reduce the incidence of common prefixes in the name mangling. (i.e.:
+  // every standard library name won't have a common prefix that has to be
+  // skipped and compared before getting to the interesting part)
+  auto MangleInverseQualifiedNameScope(llvm::raw_ostream& os,
+                                       SemIR::NameScopeId name_scope_id)
+      -> void;
+
+  auto sem_ir() const -> const SemIR::File& { return file_context_.sem_ir(); }
+
+  auto names() const -> SemIR::NameStoreWrapper { return sem_ir().names(); }
+
+  auto types() const -> SemIR::TypeStore { return sem_ir().types(); }
+
+  FileContext& file_context_;
+};
+
+}  // namespace Carbon::Lower
+
+#endif  // CARBON_TOOLCHAIN_LOWER_MANGLER_H_

toolchain/lower/testdata/alias/local.carbon

@@ -17,7 +17,7 @@ fn F() -> i32 {
 // CHECK:STDOUT: ; ModuleID = 'local.carbon'
 // CHECK:STDOUT: source_filename = "local.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: define i32 @F() !dbg !4 {
+// CHECK:STDOUT: define i32 @_CF.Main() !dbg !4 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %a.var = alloca i32, align 4, !dbg !7
 // CHECK:STDOUT:   store i32 0, ptr %a.var, align 4, !dbg !8
@@ -32,7 +32,7 @@ fn F() -> i32 {
 // CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3}
 // CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 // CHECK:STDOUT: !3 = !DIFile(filename: "local.carbon", directory: "")
-// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "F", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "_CF.Main", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !5 = !DISubroutineType(types: !6)
 // CHECK:STDOUT: !6 = !{}
 // CHECK:STDOUT: !7 = !DILocation(line: 12, column: 7, scope: !4)

toolchain/lower/testdata/array/array_in_place.carbon

@@ -17,15 +17,15 @@ fn G() {
 // CHECK:STDOUT: ; ModuleID = 'array_in_place.carbon'
 // CHECK:STDOUT: source_filename = "array_in_place.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: declare void @F(ptr sret({ i32, i32, i32 }))
+// CHECK:STDOUT: declare void @_CF.Main(ptr sret({ i32, i32, i32 }))
 // CHECK:STDOUT:
-// CHECK:STDOUT: define void @G() !dbg !4 {
+// CHECK:STDOUT: define void @_CG.Main() !dbg !4 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %v.var = alloca [2 x { i32, i32, i32 }], align 8, !dbg !7
 // CHECK:STDOUT:   %.loc14_42.2.array.index = getelementptr inbounds [2 x { i32, i32, i32 }], ptr %v.var, i32 0, i32 0, !dbg !8
-// CHECK:STDOUT:   call void @F(ptr %.loc14_42.2.array.index), !dbg !9
+// CHECK:STDOUT:   call void @_CF.Main(ptr %.loc14_42.2.array.index), !dbg !9
 // CHECK:STDOUT:   %.loc14_42.5.array.index = getelementptr inbounds [2 x { i32, i32, i32 }], ptr %v.var, i32 0, i32 1, !dbg !8
-// CHECK:STDOUT:   call void @F(ptr %.loc14_42.5.array.index), !dbg !10
+// CHECK:STDOUT:   call void @_CF.Main(ptr %.loc14_42.5.array.index), !dbg !10
 // CHECK:STDOUT:   ret void, !dbg !11
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -36,7 +36,7 @@ fn G() {
 // CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3}
 // CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 // CHECK:STDOUT: !3 = !DIFile(filename: "array_in_place.carbon", directory: "")
-// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "G", linkageName: "G", scope: null, file: !3, line: 13, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "G", linkageName: "_CG.Main", scope: null, file: !3, line: 13, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !5 = !DISubroutineType(types: !6)
 // CHECK:STDOUT: !6 = !{}
 // CHECK:STDOUT: !7 = !DILocation(line: 14, column: 7, scope: !4)

toolchain/lower/testdata/array/assign_return_value.carbon

@@ -19,7 +19,7 @@ fn Run() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: @tuple.loc11_39 = internal constant { i32, i32 } { i32 12, i32 24 }
 // CHECK:STDOUT:
-// CHECK:STDOUT: define void @F(ptr sret({ i32, i32 }) %return) !dbg !4 {
+// CHECK:STDOUT: define void @_CF.Main(ptr sret({ i32, i32 }) %return) !dbg !4 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %.loc11_38.2.tuple.elem = getelementptr inbounds nuw { i32, i32 }, ptr %return, i32 0, i32 0, !dbg !7
 // CHECK:STDOUT:   %.loc11_38.4.tuple.elem = getelementptr inbounds nuw { i32, i32 }, ptr %return, i32 0, i32 1, !dbg !7
@@ -31,7 +31,7 @@ fn Run() {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %t.var = alloca [2 x i32], align 4, !dbg !10
 // CHECK:STDOUT:   %.loc14_22.1.temp = alloca { i32, i32 }, align 8, !dbg !11
-// CHECK:STDOUT:   call void @F(ptr %.loc14_22.1.temp), !dbg !11
+// CHECK:STDOUT:   call void @_CF.Main(ptr %.loc14_22.1.temp), !dbg !11
 // CHECK:STDOUT:   %.loc14_22.3.tuple.elem = getelementptr inbounds nuw { i32, i32 }, ptr %.loc14_22.1.temp, i32 0, i32 0, !dbg !11
 // CHECK:STDOUT:   %.loc14_22.4 = load i32, ptr %.loc14_22.3.tuple.elem, align 4, !dbg !11
 // CHECK:STDOUT:   %.loc14_22.6.array.index = getelementptr inbounds [2 x i32], ptr %t.var, i32 0, i32 0, !dbg !11
@@ -55,7 +55,7 @@ fn Run() {
 // CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3}
 // CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 // CHECK:STDOUT: !3 = !DIFile(filename: "assign_return_value.carbon", directory: "")
-// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "F", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "_CF.Main", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !5 = !DISubroutineType(types: !6)
 // CHECK:STDOUT: !6 = !{}
 // CHECK:STDOUT: !7 = !DILocation(line: 11, column: 31, scope: !4)

toolchain/lower/testdata/array/function_param.carbon

@@ -21,21 +21,21 @@ fn G() -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: @array.loc16_11.1 = internal constant [3 x i32] [i32 1, i32 2, i32 3]
 // CHECK:STDOUT:
-// CHECK:STDOUT: define i32 @F(ptr %arr, i32 %i) !dbg !4 {
+// CHECK:STDOUT: define i32 @_CF.Main(ptr %arr, i32 %i) !dbg !4 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %.loc12_15.2.array.index = getelementptr inbounds [3 x i32], ptr %arr, i32 0, i32 %i, !dbg !7
 // CHECK:STDOUT:   %.loc12_15.3 = load i32, ptr %.loc12_15.2.array.index, align 4, !dbg !7
 // CHECK:STDOUT:   ret i32 %.loc12_15.3, !dbg !8
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: define i32 @G() !dbg !9 {
+// CHECK:STDOUT: define i32 @_CG.Main() !dbg !9 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   %.loc16_20.2.temp = alloca [3 x i32], align 4, !dbg !10
 // CHECK:STDOUT:   %.loc16_20.4.array.index = getelementptr inbounds [3 x i32], ptr %.loc16_20.2.temp, i32 0, i32 0, !dbg !10
 // CHECK:STDOUT:   %.loc16_20.7.array.index = getelementptr inbounds [3 x i32], ptr %.loc16_20.2.temp, i32 0, i32 1, !dbg !10
 // CHECK:STDOUT:   %.loc16_20.10.array.index = getelementptr inbounds [3 x i32], ptr %.loc16_20.2.temp, i32 0, i32 2, !dbg !10
 // CHECK:STDOUT:   call void @llvm.memcpy.p0.p0.i64(ptr align 4 %.loc16_20.2.temp, ptr align 4 @array.loc16_11.1, i64 12, i1 false), !dbg !11
-// CHECK:STDOUT:   %F.call = call i32 @F(ptr %.loc16_20.2.temp, i32 1), !dbg !11
+// CHECK:STDOUT:   %F.call = call i32 @_CF.Main(ptr %.loc16_20.2.temp, i32 1), !dbg !11
 // CHECK:STDOUT:   ret i32 %F.call, !dbg !12
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -51,12 +51,12 @@ fn G() -> i32 {
 // CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3}
 // CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 // CHECK:STDOUT: !3 = !DIFile(filename: "function_param.carbon", directory: "")
-// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "F", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "_CF.Main", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !5 = !DISubroutineType(types: !6)
 // CHECK:STDOUT: !6 = !{}
 // CHECK:STDOUT: !7 = !DILocation(line: 12, column: 10, scope: !4)
 // CHECK:STDOUT: !8 = !DILocation(line: 12, column: 3, scope: !4)
-// CHECK:STDOUT: !9 = distinct !DISubprogram(name: "G", linkageName: "G", scope: null, file: !3, line: 15, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !9 = distinct !DISubprogram(name: "G", linkageName: "_CG.Main", scope: null, file: !3, line: 15, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !10 = !DILocation(line: 16, column: 12, scope: !9)
 // CHECK:STDOUT: !11 = !DILocation(line: 16, column: 10, scope: !9)
 // CHECK:STDOUT: !12 = !DILocation(line: 16, column: 3, scope: !9)

toolchain/lower/testdata/basics/false_true.carbon

@@ -19,12 +19,12 @@ fn T() -> bool {
 // CHECK:STDOUT: ; ModuleID = 'false_true.carbon'
 // CHECK:STDOUT: source_filename = "false_true.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: define i1 @F() !dbg !4 {
+// CHECK:STDOUT: define i1 @_CF.Main() !dbg !4 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   ret i1 false, !dbg !7
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: define i1 @T() !dbg !8 {
+// CHECK:STDOUT: define i1 @_CT.Main() !dbg !8 {
 // CHECK:STDOUT: entry:
 // CHECK:STDOUT:   ret i1 true, !dbg !9
 // CHECK:STDOUT: }
@@ -36,9 +36,9 @@ fn T() -> bool {
 // CHECK:STDOUT: !1 = !{i32 2, !"Debug Info Version", i32 3}
 // CHECK:STDOUT: !2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "carbon", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 // CHECK:STDOUT: !3 = !DIFile(filename: "false_true.carbon", directory: "")
-// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "F", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !4 = distinct !DISubprogram(name: "F", linkageName: "_CF.Main", scope: null, file: !3, line: 11, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !5 = !DISubroutineType(types: !6)
 // CHECK:STDOUT: !6 = !{}
 // CHECK:STDOUT: !7 = !DILocation(line: 12, column: 3, scope: !4)
-// CHECK:STDOUT: !8 = distinct !DISubprogram(name: "T", linkageName: "T", scope: null, file: !3, line: 15, type: !5, spFlags: DISPFlagDefinition, unit: !2)
+// CHECK:STDOUT: !8 = distinct !DISubprogram(name: "T", linkageName: "_CT.Main", scope: null, file: !3, line: 15, type: !5, spFlags: DISPFlagDefinition, unit: !2)
 // CHECK:STDOUT: !9 = !DILocation(line: 16, column: 3, scope: !8)