Model function calls as initializing expressions

toolchain/lowering/lowering_context.cpp

@@ -57,39 +57,63 @@ auto LoweringContext::Run() -> std::unique_ptr<llvm::Module> {
 
 auto LoweringContext::BuildFunctionDeclaration(SemIR::FunctionId function_id)
     -> llvm::Function* {
-  auto function = semantics_ir().GetFunction(function_id);
+  const auto& function = semantics_ir().GetFunction(function_id);
+  const bool has_return_slot = function.return_slot_id.is_valid();
+  const int first_param = has_return_slot ? 1 : 0;
+
+  SemIR::InitializingRepresentation return_rep =
+      function.return_type_id.is_valid()
+          ? SemIR::GetInitializingRepresentation(semantics_ir(),
+                                                 function.return_type_id)
+          : SemIR::InitializingRepresentation{
+                .kind = SemIR::InitializingRepresentation::None};
+  CARBON_CHECK(return_rep.has_return_slot() == has_return_slot);
 
   // TODO: Lower type information for the arguments prior to building args.
   auto param_refs = semantics_ir().GetNodeBlock(function.param_refs_id);
   llvm::SmallVector<llvm::Type*> args;
-  args.resize_for_overwrite(param_refs.size());
+  args.resize_for_overwrite(first_param + param_refs.size());
+  if (has_return_slot) {
+    args[0] = GetType(function.return_type_id)->getPointerTo();
+  }
   for (auto [i, param_ref] : llvm::enumerate(param_refs)) {
-    args[i] = GetType(semantics_ir().GetNode(param_ref).type_id());
+    args[first_param + i] =
+        GetType(semantics_ir().GetNode(param_ref).type_id());
   }
 
-  // If return type is not valid, the function does not have a return type.
-  // Hence, set return type to void.
-  llvm::Type* return_type = function.return_type_id.is_valid()
-                                ? GetType(function.return_type_id)
-                                : llvm::Type::getVoidTy(llvm_context());
+  // If the initializing representation doesn't produce a value, set the return
+  // type to void.
+  llvm::Type* return_type =
+      return_rep.kind == SemIR::InitializingRepresentation::ByCopy
+          ? GetType(function.return_type_id)
+          : llvm::Type::getVoidTy(llvm_context());
+
   llvm::FunctionType* function_type =
       llvm::FunctionType::get(return_type, args, /*isVarArg=*/false);
   auto* llvm_function = llvm::Function::Create(
       function_type, llvm::Function::ExternalLinkage,
       semantics_ir().GetString(function.name_id), llvm_module());
 
+  if (has_return_slot) {
+    auto* return_slot = llvm_function->getArg(0);
+    return_slot->addAttr(llvm::Attribute::getWithStructRetType(
+        llvm_context(), GetType(function.return_type_id)));
+    return_slot->setName("return");
+  }
+
   // Set parameter names.
   for (auto [i, param_ref] : llvm::enumerate(param_refs)) {
     auto name_id = semantics_ir().GetNode(param_ref).GetAsParameter();
-    llvm_function->getArg(i)->setName(semantics_ir().GetString(name_id));
+    llvm_function->getArg(first_param + i)
+        ->setName(semantics_ir().GetString(name_id));
   }
 
   return llvm_function;
 }
 
 auto LoweringContext::BuildFunctionDefinition(SemIR::FunctionId function_id)
     -> void {
-  auto function = semantics_ir().GetFunction(function_id);
+  const auto& function = semantics_ir().GetFunction(function_id);
   const auto& body_block_ids = function.body_block_ids;
   if (body_block_ids.empty()) {
     // Function is probably defined in another file; not an error.
@@ -99,14 +123,21 @@ auto LoweringContext::BuildFunctionDefinition(SemIR::FunctionId function_id)
   llvm::Function* llvm_function = GetFunction(function_id);
   LoweringFunctionContext function_lowering(*this, llvm_function);
 
+  const bool has_return_slot = function.return_slot_id.is_valid();
+  const int first_param = has_return_slot ? 1 : 0;
+
   // Add parameters to locals.
   auto param_refs = semantics_ir().GetNodeBlock(function.param_refs_id);
+  if (has_return_slot) {
+    function_lowering.SetLocal(function.return_slot_id,
+                               llvm_function->getArg(0));
+  }
   for (auto [i, param_ref] : llvm::enumerate(param_refs)) {
-    function_lowering.SetLocal(param_ref, llvm_function->getArg(i));
+    function_lowering.SetLocal(param_ref,
+                               llvm_function->getArg(first_param + i));
   }
 
   // Lower all blocks.
-  // TODO: Determine the set of reachable blocks, and only lower those ones.
   for (auto block_id : body_block_ids) {
     CARBON_VLOG() << "Lowering " << block_id << "\n";
     auto* llvm_block = function_lowering.GetBlock(block_id);

toolchain/lowering/lowering_handle.cpp

@@ -172,21 +172,32 @@ auto LoweringHandleBuiltin(LoweringFunctionContext& /*context*/,
 auto LoweringHandleCall(LoweringFunctionContext& context, SemIR::NodeId node_id,
                         SemIR::Node node) -> void {
   auto [refs_id, function_id] = node.GetAsCall();
-  auto* function = context.GetFunction(function_id);
+  auto* llvm_function = context.GetFunction(function_id);
+  const auto& function = context.semantics_ir().GetFunction(function_id);
+
   std::vector<llvm::Value*> args;
-  for (auto ref_id : context.semantics_ir().GetNodeBlock(refs_id)) {
+  llvm::ArrayRef<SemIR::NodeId> arg_ids =
+      context.semantics_ir().GetNodeBlock(refs_id);
+
+  if (function.return_slot_id.is_valid()) {
+    args.push_back(context.GetLocal(arg_ids.back()));
+    arg_ids = arg_ids.drop_back();
+  }
+
+  for (auto ref_id : arg_ids) {
     args.push_back(context.GetLocalLoaded(ref_id));
   }
-  if (function->getReturnType()->isVoidTy()) {
-    context.builder().CreateCall(function, args);
-    // TODO: use empty tuple type.
-    // TODO: don't create the empty tuple if the call does not get assigned.
-    context.SetLocal(node_id, context.builder().CreateAlloca(
-                                  llvm::StructType::get(context.llvm_context()),
-                                  /*ArraySize=*/nullptr, "call.result"));
+
+  if (llvm_function->getReturnType()->isVoidTy()) {
+    context.builder().CreateCall(llvm_function, args);
+    // TODO: A function with a void return type shouldn't be referred to by
+    // other nodes.
+    context.SetLocal(node_id,
+                     llvm::UndefValue::get(context.GetType(node.type_id())));
   } else {
-    context.SetLocal(node_id, context.builder().CreateCall(
-                                  function, args, function->getName()));
+    context.SetLocal(node_id,
+                     context.builder().CreateCall(llvm_function, args,
+                                                  llvm_function->getName()));
   }
 }
 
@@ -222,6 +233,12 @@ auto LoweringHandleNamespace(LoweringFunctionContext& /*context*/,
   // No action to take.
 }
 
+auto LoweringHandleNoOp(LoweringFunctionContext& /*context*/,
+                        SemIR::NodeId /*node_id*/, SemIR::Node /*node*/)
+    -> void {
+  // No action to take.
+}
+
 auto LoweringHandleParameter(LoweringFunctionContext& /*context*/,
                              SemIR::NodeId /*node_id*/, SemIR::Node /*node*/)
     -> void {

toolchain/lowering/lowering_handle_expression_category.cpp

@@ -0,0 +1,22 @@
+// 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/lowering/lowering_function_context.h"
+
+namespace Carbon {
+
+auto LoweringHandleBindValue(LoweringFunctionContext& context,
+                             SemIR::NodeId node_id, SemIR::Node node) -> void {
+  context.SetLocal(node_id, context.GetLocalLoaded(node.GetAsBindValue()));
+}
+
+auto LoweringHandleMaterializeTemporary(LoweringFunctionContext& context,
+                                        SemIR::NodeId node_id, SemIR::Node node)
+    -> void {
+  context.SetLocal(
+      node_id, context.builder().CreateAlloca(context.GetType(node.type_id()),
+                                              nullptr, "temp"));
+}
+
+}  // namespace Carbon

toolchain/lowering/testdata/array/assign_return_value.carbon

@@ -13,27 +13,30 @@ fn Run() {
 // CHECK:STDOUT: ; ModuleID = 'assign_return_value.carbon'
 // CHECK:STDOUT: source_filename = "assign_return_value.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: define { i32, i32 } @F() {
+// CHECK:STDOUT: define void @F(ptr sret({ i32, i32 }) %return) {
 // CHECK:STDOUT:   %tuple = alloca { i32, i32 }, align 8
 // CHECK:STDOUT:   %1 = getelementptr inbounds { i32, i32 }, ptr %tuple, i32 0, i32 0
 // CHECK:STDOUT:   store i32 12, ptr %1, align 4
 // CHECK:STDOUT:   %2 = getelementptr inbounds { i32, i32 }, ptr %tuple, i32 0, i32 1
 // CHECK:STDOUT:   store i32 24, ptr %2, align 4
 // CHECK:STDOUT:   %3 = load { i32, i32 }, ptr %tuple, align 4
-// CHECK:STDOUT:   ret { i32, i32 } %3
+// CHECK:STDOUT:   store { i32, i32 } %3, ptr %return, align 4
+// CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Run() {
 // CHECK:STDOUT:   %t = alloca [2 x i32], align 4
-// CHECK:STDOUT:   %F = call { i32, i32 } @F()
+// CHECK:STDOUT:   %temp = alloca { i32, i32 }, align 8
+// CHECK:STDOUT:   call void @F(ptr %temp)
+// CHECK:STDOUT:   %1 = load { i32, i32 }, ptr %temp, align 4
 // CHECK:STDOUT:   %array = alloca [2 x i32], align 4
-// CHECK:STDOUT:   %array.element = extractvalue { i32, i32 } %F, 0
-// CHECK:STDOUT:   %1 = getelementptr inbounds [2 x i32], ptr %array, i32 0, i32 0
-// CHECK:STDOUT:   store i32 %array.element, ptr %1, align 4
-// CHECK:STDOUT:   %array.element1 = extractvalue { i32, i32 } %F, 1
-// CHECK:STDOUT:   %2 = getelementptr inbounds [2 x i32], ptr %array, i32 0, i32 1
-// CHECK:STDOUT:   store i32 %array.element1, ptr %2, align 4
-// CHECK:STDOUT:   %3 = load [2 x i32], ptr %array, align 4
-// CHECK:STDOUT:   store [2 x i32] %3, ptr %t, align 4
+// CHECK:STDOUT:   %array.element = extractvalue { i32, i32 } %1, 0
+// CHECK:STDOUT:   %2 = getelementptr inbounds [2 x i32], ptr %array, i32 0, i32 0
+// CHECK:STDOUT:   store i32 %array.element, ptr %2, align 4
+// CHECK:STDOUT:   %array.element1 = extractvalue { i32, i32 } %1, 1
+// CHECK:STDOUT:   %3 = getelementptr inbounds [2 x i32], ptr %array, i32 0, i32 1
+// CHECK:STDOUT:   store i32 %array.element1, ptr %3, align 4
+// CHECK:STDOUT:   %4 = load [2 x i32], ptr %array, align 4
+// CHECK:STDOUT:   store [2 x i32] %4, ptr %t, align 4
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/array/base.carbon

@@ -105,20 +105,18 @@ fn Run() {
 // CHECK:STDOUT:   %34 = load { i32, i32, i32 }, ptr %tuple19, align 4
 // CHECK:STDOUT:   store { i32, i32, i32 } %34, ptr %d, align 4
 // CHECK:STDOUT:   %e = alloca [3 x i32], align 4
+// CHECK:STDOUT:   %35 = load { i32, i32, i32 }, ptr %d, align 4
 // CHECK:STDOUT:   %array20 = alloca [3 x i32], align 4
-// CHECK:STDOUT:   %array.element21 = getelementptr inbounds { i32, i32, i32 }, ptr %d, i32 0, i32 0
-// CHECK:STDOUT:   %35 = load i32, ptr %array.element21, align 4
+// CHECK:STDOUT:   %array.element21 = extractvalue { i32, i32, i32 } %35, 0
 // CHECK:STDOUT:   %36 = getelementptr inbounds [3 x i32], ptr %array20, i32 0, i32 0
-// CHECK:STDOUT:   store i32 %35, ptr %36, align 4
-// CHECK:STDOUT:   %array.element22 = getelementptr inbounds { i32, i32, i32 }, ptr %d, i32 0, i32 1
-// CHECK:STDOUT:   %37 = load i32, ptr %array.element22, align 4
-// CHECK:STDOUT:   %38 = getelementptr inbounds [3 x i32], ptr %array20, i32 0, i32 1
-// CHECK:STDOUT:   store i32 %37, ptr %38, align 4
-// CHECK:STDOUT:   %array.element23 = getelementptr inbounds { i32, i32, i32 }, ptr %d, i32 0, i32 2
-// CHECK:STDOUT:   %39 = load i32, ptr %array.element23, align 4
-// CHECK:STDOUT:   %40 = getelementptr inbounds [3 x i32], ptr %array20, i32 0, i32 2
-// CHECK:STDOUT:   store i32 %39, ptr %40, align 4
-// CHECK:STDOUT:   %41 = load [3 x i32], ptr %array20, align 4
-// CHECK:STDOUT:   store [3 x i32] %41, ptr %e, align 4
+// CHECK:STDOUT:   store i32 %array.element21, ptr %36, align 4
+// CHECK:STDOUT:   %array.element22 = extractvalue { i32, i32, i32 } %35, 1
+// CHECK:STDOUT:   %37 = getelementptr inbounds [3 x i32], ptr %array20, i32 0, i32 1
+// CHECK:STDOUT:   store i32 %array.element22, ptr %37, align 4
+// CHECK:STDOUT:   %array.element23 = extractvalue { i32, i32, i32 } %35, 2
+// CHECK:STDOUT:   %38 = getelementptr inbounds [3 x i32], ptr %array20, i32 0, i32 2
+// CHECK:STDOUT:   store i32 %array.element23, ptr %38, align 4
+// CHECK:STDOUT:   %39 = load [3 x i32], ptr %array20, align 4
+// CHECK:STDOUT:   store [3 x i32] %39, ptr %e, align 4
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/basics/type_values.carbon

@@ -15,12 +15,10 @@ fn F64() -> type {
 // CHECK:STDOUT: ; ModuleID = 'type_values.carbon'
 // CHECK:STDOUT: source_filename = "type_values.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: %type = type {}
-// CHECK:STDOUT:
-// CHECK:STDOUT: define %type @I32() {
-// CHECK:STDOUT:   ret %type zeroinitializer
+// CHECK:STDOUT: define void @I32() {
+// CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: define %type @F64() {
-// CHECK:STDOUT:   ret %type zeroinitializer
+// CHECK:STDOUT: define void @F64() {
+// CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/empty_struct.carbon

@@ -15,18 +15,16 @@ fn Main() {
 // CHECK:STDOUT: ; ModuleID = 'empty_struct.carbon'
 // CHECK:STDOUT: source_filename = "empty_struct.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: define {} @Echo({} %a) {
+// CHECK:STDOUT: define void @Echo({} %a) {
 // CHECK:STDOUT:   %struct = alloca {}, align 8
-// CHECK:STDOUT:   %1 = load {}, ptr %struct, align 1
-// CHECK:STDOUT:   ret {} %1
+// CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   %struct = alloca {}, align 8
 // CHECK:STDOUT:   %b = alloca {}, align 8
 // CHECK:STDOUT:   %struct1 = alloca {}, align 8
 // CHECK:STDOUT:   %1 = load {}, ptr %struct1, align 1
-// CHECK:STDOUT:   %Echo = call {} @Echo({} %1)
-// CHECK:STDOUT:   store {} %Echo, ptr %b, align 1
+// CHECK:STDOUT:   call void @Echo({} %1)
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/empty_tuple.carbon

@@ -15,16 +15,15 @@ fn Main() {
 // CHECK:STDOUT: ; ModuleID = 'empty_tuple.carbon'
 // CHECK:STDOUT: source_filename = "empty_tuple.carbon"
 // CHECK:STDOUT:
-// CHECK:STDOUT: define {} @Echo({} %a) {
-// CHECK:STDOUT:   ret {} %a
+// CHECK:STDOUT: define void @Echo({} %a) {
+// CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   %tuple = alloca {}, align 8
 // CHECK:STDOUT:   %b = alloca {}, align 8
 // CHECK:STDOUT:   %tuple1 = alloca {}, align 8
 // CHECK:STDOUT:   %1 = load {}, ptr %tuple1, align 1
-// CHECK:STDOUT:   %Echo = call {} @Echo({} %1)
-// CHECK:STDOUT:   store {} %Echo, ptr %b, align 1
+// CHECK:STDOUT:   call void @Echo({} %1)
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/implicit_empty_tuple_as_arg.carbon

@@ -20,17 +20,16 @@ fn Main() {
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: define {} @Bar({} %a) {
-// CHECK:STDOUT:   ret {} %a
+// CHECK:STDOUT: define void @Bar({} %a) {
+// CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   %tuple = alloca {}, align 8
 // CHECK:STDOUT:   %x = alloca {}, align 8
 // CHECK:STDOUT:   call void @Foo()
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
-// CHECK:STDOUT:   %1 = load {}, ptr %call.result, align 1
-// CHECK:STDOUT:   %Bar = call {} @Bar({} %1)
-// CHECK:STDOUT:   store {} %Bar, ptr %x, align 1
+// CHECK:STDOUT:   %temp = alloca {}, align 8
+// CHECK:STDOUT:   %1 = load {}, ptr %temp, align 1
+// CHECK:STDOUT:   call void @Bar({} %1)
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/params_one.carbon

@@ -19,6 +19,5 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   call void @Foo(i32 1)
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/params_one_comma.carbon

@@ -20,8 +20,6 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   call void @Foo(i32 1)
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   call void @Foo(i32 1)
-// CHECK:STDOUT:   %call.result1 = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/params_two.carbon

@@ -19,6 +19,5 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   call void @Foo(i32 1, i32 2)
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/params_two_comma.carbon

@@ -20,8 +20,6 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   call void @Foo(i32 1, i32 2)
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   call void @Foo(i32 1, i32 2)
-// CHECK:STDOUT:   %call.result1 = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/params_zero.carbon

@@ -19,6 +19,5 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @Main() {
 // CHECK:STDOUT:   call void @Foo()
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/return_implicit.carbon

@@ -23,8 +23,5 @@ fn Main() {
 // CHECK:STDOUT:   %tuple = alloca {}, align 8
 // CHECK:STDOUT:   %b = alloca {}, align 8
 // CHECK:STDOUT:   call void @MakeImplicitEmptyTuple()
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
-// CHECK:STDOUT:   %1 = load {}, ptr %call.result, align 1
-// CHECK:STDOUT:   store {} %1, ptr %b, align 1
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/call/var_param.carbon

@@ -23,6 +23,5 @@ fn Main() {
 // CHECK:STDOUT:   store i32 0, ptr %a, align 4
 // CHECK:STDOUT:   %1 = load i32, ptr %a, align 4
 // CHECK:STDOUT:   call void @DoNothing(i32 %1)
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }

toolchain/lowering/testdata/function/declaration/simple.carbon

@@ -15,6 +15,5 @@ fn G(n: i32) { F(n); }
 // CHECK:STDOUT:
 // CHECK:STDOUT: define void @G(i32 %n) {
 // CHECK:STDOUT:   call void @F(i32 %n)
-// CHECK:STDOUT:   %call.result = alloca {}, align 8
 // CHECK:STDOUT:   ret void
 // CHECK:STDOUT: }