Files
carbon-lang/toolchain/lowering/lowering_context.cpp
T
Richard SmithandChandler Carruth 1013d1773c Model function calls as initializing expressions (#3089)
Start treating function calls as initializing expressions instead of as
value expressions.

This required adding support for expression categories. Value bindings
and temporary materialization conversions are created where necessary to
transition between expression categories. For a function call with a
return slot, we speculatively create a materialized temporary before the
call and either commit to it or replace it with something else later,
once we see how the function call expression is actually used.

This change follows the direction suggested in #3133 for initializing
expressions: depending on the return type of a function, the return
value will either be initialized in-place or returned directly. This is
visible in the semantics IR, which is a little unfortunate but is
probably necessary as this is part of the semantics of the program.

---------

Co-authored-by: Chandler Carruth <chandlerc@gmail.com>
2023-08-24 19:35:07 +00:00

221 lines
8.5 KiB
C++

// 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_context.h"
#include "common/vlog.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h"
#include "toolchain/lowering/lowering_function_context.h"
#include "toolchain/semantics/semantics_ir.h"
#include "toolchain/semantics/semantics_node.h"
#include "toolchain/semantics/semantics_node_kind.h"
namespace Carbon {
LoweringContext::LoweringContext(llvm::LLVMContext& llvm_context,
llvm::StringRef module_name,
const SemIR::File& semantics_ir,
llvm::raw_ostream* vlog_stream)
: llvm_context_(&llvm_context),
llvm_module_(std::make_unique<llvm::Module>(module_name, llvm_context)),
semantics_ir_(&semantics_ir),
vlog_stream_(vlog_stream) {
CARBON_CHECK(!semantics_ir.has_errors())
<< "Generating LLVM IR from invalid SemIR::File is unsupported.";
}
// TODO: Move this to lower_to_llvm.cpp.
auto LoweringContext::Run() -> std::unique_ptr<llvm::Module> {
CARBON_CHECK(llvm_module_) << "Run can only be called once.";
// Lower types.
auto types = semantics_ir_->types();
types_.resize_for_overwrite(types.size());
for (auto [i, type] : llvm::enumerate(types)) {
types_[i] = BuildType(type);
}
// Lower function declarations.
functions_.resize_for_overwrite(semantics_ir_->functions_size());
for (auto i : llvm::seq(semantics_ir_->functions_size())) {
functions_[i] = BuildFunctionDeclaration(SemIR::FunctionId(i));
}
// TODO: Lower global variable declarations.
// Lower function definitions.
for (auto i : llvm::seq(semantics_ir_->functions_size())) {
BuildFunctionDefinition(SemIR::FunctionId(i));
}
// TODO: Lower global variable initializers.
return std::move(llvm_module_);
}
auto LoweringContext::BuildFunctionDeclaration(SemIR::FunctionId function_id)
-> llvm::Function* {
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(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[first_param + i] =
GetType(semantics_ir().GetNode(param_ref).type_id());
}
// 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(first_param + i)
->setName(semantics_ir().GetString(name_id));
}
return llvm_function;
}
auto LoweringContext::BuildFunctionDefinition(SemIR::FunctionId function_id)
-> void {
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.
return;
}
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(first_param + i));
}
// Lower all blocks.
for (auto block_id : body_block_ids) {
CARBON_VLOG() << "Lowering " << block_id << "\n";
auto* llvm_block = function_lowering.GetBlock(block_id);
// Keep the LLVM blocks in lexical order.
llvm_block->moveBefore(llvm_function->end());
function_lowering.builder().SetInsertPoint(llvm_block);
for (const auto& node_id : semantics_ir().GetNodeBlock(block_id)) {
auto node = semantics_ir().GetNode(node_id);
CARBON_VLOG() << "Lowering " << node_id << ": " << node << "\n";
switch (node.kind()) {
#define CARBON_SEMANTICS_NODE_KIND(Name) \
case SemIR::NodeKind::Name: \
LoweringHandle##Name(function_lowering, node_id, node); \
break;
#include "toolchain/semantics/semantics_node_kind.def"
}
}
}
}
auto LoweringContext::BuildType(SemIR::NodeId node_id) -> llvm::Type* {
switch (node_id.index) {
case SemIR::BuiltinKind::FloatingPointType.AsInt():
// TODO: Handle different sizes.
return llvm::Type::getDoubleTy(*llvm_context_);
case SemIR::BuiltinKind::IntegerType.AsInt():
// TODO: Handle different sizes.
return llvm::Type::getInt32Ty(*llvm_context_);
case SemIR::BuiltinKind::BoolType.AsInt():
// TODO: We may want to have different representations for `bool` storage
// (`i8`) versus for `bool` values (`i1`).
return llvm::Type::getInt1Ty(*llvm_context_);
}
auto node = semantics_ir_->GetNode(node_id);
switch (node.kind()) {
case SemIR::NodeKind::ArrayType: {
auto [bound_node_id, type_id] = node.GetAsArrayType();
return llvm::ArrayType::get(
GetType(type_id), semantics_ir_->GetArrayBoundValue(bound_node_id));
}
case SemIR::NodeKind::ConstType:
return GetType(node.GetAsConstType());
case SemIR::NodeKind::PointerType:
return llvm::PointerType::get(*llvm_context_, /*AddressSpace=*/0);
case SemIR::NodeKind::StructType: {
auto refs = semantics_ir_->GetNodeBlock(node.GetAsStructType());
llvm::SmallVector<llvm::Type*> subtypes;
subtypes.reserve(refs.size());
for (auto ref_id : refs) {
auto [field_name_id, field_type_id] =
semantics_ir_->GetNode(ref_id).GetAsStructTypeField();
// TODO: Handle recursive types. The restriction for builtins prevents
// recursion while still letting them cache.
CARBON_CHECK(field_type_id.index < SemIR::BuiltinKind::ValidCount)
<< field_type_id;
subtypes.push_back(GetType(field_type_id));
}
return llvm::StructType::get(*llvm_context_, subtypes);
}
case SemIR::NodeKind::TupleType: {
// TODO: Investigate special-casing handling of empty tuples so that they
// can be collectively replaced with LLVM's void, particularly around
// function returns. LLVM doesn't allow declaring variables with a void
// type, so that may require significant special casing.
auto refs = semantics_ir_->GetTypeBlock(node.GetAsTupleType());
llvm::SmallVector<llvm::Type*> subtypes;
subtypes.reserve(refs.size());
for (auto ref_id : refs) {
subtypes.push_back(GetType(ref_id));
}
return llvm::StructType::get(*llvm_context_, subtypes);
}
default: {
CARBON_FATAL() << "Cannot use node as type: " << node_id;
}
}
}
} // namespace Carbon