Files
carbon-lang/toolchain/lowering/lowering_handle.cpp
T
Richard SmithandJon Ross-Perkins e41a165359 Retain information about how an initializing expression is used in semantics IR (#3173)
Switch from a fully lowering-oriented approach to initializing
expressions in semantics IR to an approach that retains more information
about the high-level semantics of the program. Specifically:

- Always form an `Assign` node for a variable initialization or
assignment, even for empty types and when the actual initialization is
performed in-place by evaluating the right-hand side.
- Always form a `ReturnExpression` node for a return statement with an
expression, even when the actual initialization is performed in-place
into the return slot and the function doesn't return a value.

This is intended to permit us to more easily write semantic checks over
the IR, and to preserve a use edge from the use of an initializing
expression and its initializer in all cases.

To better support this, `MaterializeTemporary` is also split into two
nodes:

- A `TemporaryStorage` node allocates and provides the storage for a
temporary, and is emitted prior to emitting the initialization of the
temporary.
- A `Temporary` node connects the temporary storage to the initializer,
and is emitted after emitting the initialization.

Example testcase:

```carbon
fn F() -> (i32, i32);

fn G() -> (i32, i32) {
  var v: (i32, i32) = F();
  v = F();
  return F();
}

fn H() -> i32 {
  return G()[0];
}
```

Before:

```carbon-semir
fn @G() -> %return: (i32, i32) {
  // ...
  %v: (i32, i32) = var "v"
  %.loc4_24: (i32, i32) = call @F() to %v
  %.loc5: (i32, i32) = call @F() to %v
  %.loc6: (i32, i32) = call @F() to %return
  return
}

fn @H() -> i32 {
!entry:
  %.loc10_11.1: (i32, i32) = materialize_temporary
  %.loc10_11.2: (i32, i32) = call @G() to %.loc10_11.1
  %.loc10_14: i32 = int_literal 0
  %.loc10_15.1: i32 = tuple_index %.loc10_11.1, %.loc10_14
  %.loc10_15.2: i32 = bind_value %.loc10_15.1
  return %.loc10_15.2
}
```

After:

```carbon-semir
fn @G() -> %return: (i32, i32) {
  // ...
  %v: (i32, i32) = var "v"
  %.loc4_24: (i32, i32) = call @F() to %v
  assign %v, %.loc4_24
  %.loc5: (i32, i32) = call @F() to %v
  assign %v, %.loc5
  %.loc6: (i32, i32) = call @F() to %return
  return %.loc6
}

fn @H() -> i32 {
!entry:
  %.loc10_11.1: (i32, i32) = temporary_storage
  %.loc10_11.2: (i32, i32) = call @G() to %.loc10_11.1
  %.loc10_14: i32 = int_literal 0
  %.loc10_11.3: (i32, i32) = temporary %.loc10_11.1, %.loc10_11.2
  %.loc10_15.1: i32 = tuple_index %.loc10_11.3, %.loc10_14
  %.loc10_15.2: i32 = bind_value %.loc10_15.1
  return %.loc10_15.2
}
```

Note that in the "Before" code, there is no indication in `G()` that we
assigned to `v`, and no path through "use" edges from the tuple indexing
in `H()` to the call to `G()`.

This change results in our not performing `memcpy`s into the destination
for tuple and struct initializers. This is a consequence of those
initializers not yet performing in-place initialization, and will be
fixed in a subsequent change.

---------

Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
2023-08-30 23:29:23 +00:00

391 lines
16 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 "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h"
#include "toolchain/lowering/lowering_function_context.h"
#include "toolchain/semantics/semantics_node_kind.h"
namespace Carbon::Lower {
auto HandleInvalid(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/,
SemIR::Node /*node*/) -> void {
llvm_unreachable("never in actual IR");
}
auto HandleCrossReference(FunctionContext& /*context*/,
SemIR::NodeId /*node_id*/, SemIR::Node node) -> void {
CARBON_FATAL() << "TODO: Add support: " << node;
}
auto HandleAddressOf(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
context.SetLocal(node_id, context.GetLocal(node.GetAsAddressOf()));
}
auto HandleArrayIndex(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto [array_node_id, index_node_id] = node.GetAsArrayIndex();
auto* array_value = context.GetLocal(array_node_id);
auto* llvm_type =
context.GetType(context.semantics_ir().GetNode(array_node_id).type_id());
auto index_node = context.semantics_ir().GetNode(index_node_id);
llvm::Value* array_element_value;
if (index_node.kind() == SemIR::NodeKind::IntegerLiteral) {
const auto index = context.semantics_ir()
.GetIntegerLiteral(index_node.GetAsIntegerLiteral())
.getZExtValue();
array_element_value = context.GetIndexFromStructOrArray(
llvm_type, array_value, index, "array.index");
} else {
auto* index = context.builder().CreateLoad(llvm_type->getArrayElementType(),
context.GetLocal(index_node_id));
// TODO: Handle return value or call such as `F()[a]`.
array_element_value = context.builder().CreateInBoundsGEP(
llvm_type, array_value, index, "array.index");
}
context.SetLocal(node_id, array_element_value);
}
auto HandleArrayValue(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto* llvm_type = context.GetType(node.type_id());
auto* alloca =
context.builder().CreateAlloca(llvm_type, /*ArraySize=*/nullptr, "array");
context.SetLocal(node_id, alloca);
auto tuple_node_id = node.GetAsArrayValue();
auto* tuple_value = context.GetLocal(tuple_node_id);
auto* tuple_type =
context.GetType(context.semantics_ir().GetNode(tuple_node_id).type_id());
for (auto i : llvm::seq(llvm_type->getArrayNumElements())) {
llvm::Value* array_element_value = context.GetIndexFromStructOrArray(
tuple_type, tuple_value, i, "array.element");
if (tuple_value->getType()->isPointerTy()) {
array_element_value = context.builder().CreateLoad(
llvm_type->getArrayElementType(), array_element_value);
}
// Initializing the array with values.
context.builder().CreateStore(
array_element_value,
context.builder().CreateStructGEP(llvm_type, alloca, i));
}
}
auto HandleAssign(FunctionContext& context, SemIR::NodeId /*node_id*/,
SemIR::Node node) -> void {
auto [storage_id, value_id] = node.GetAsAssign();
auto storage_type_id = context.semantics_ir().GetNode(storage_id).type_id();
context.FinishInitialization(storage_type_id, storage_id, value_id);
}
auto HandleBinaryOperatorAdd(FunctionContext& /*context*/,
SemIR::NodeId /*node_id*/, SemIR::Node node)
-> void {
CARBON_FATAL() << "TODO: Add support: " << node;
}
auto HandleBindName(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/,
SemIR::Node /*node*/) -> void {
// Probably need to do something here, but not necessary for now.
}
auto HandleBlockArg(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
SemIR::NodeBlockId block_id = node.GetAsBlockArg();
context.SetLocal(node_id, context.GetBlockArg(block_id, node.type_id()));
}
auto HandleBoolLiteral(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
llvm::Value* v = llvm::ConstantInt::get(context.builder().getInt1Ty(),
node.GetAsBoolLiteral().index);
context.SetLocal(node_id, v);
}
auto HandleBranch(FunctionContext& context, SemIR::NodeId /*node_id*/,
SemIR::Node node) -> void {
SemIR::NodeBlockId target_block_id = node.GetAsBranch();
// Opportunistically avoid creating a BasicBlock that contains just a branch.
llvm::BasicBlock* block = context.builder().GetInsertBlock();
if (block->empty() && context.TryToReuseBlock(target_block_id, block)) {
// Reuse this block as the branch target.
} else {
context.builder().CreateBr(context.GetBlock(target_block_id));
}
context.builder().ClearInsertionPoint();
}
auto HandleBranchIf(FunctionContext& context, SemIR::NodeId /*node_id*/,
SemIR::Node node) -> void {
auto [target_block_id, cond_id] = node.GetAsBranchIf();
llvm::Value* cond = context.GetLocalLoaded(cond_id);
llvm::BasicBlock* then_block = context.GetBlock(target_block_id);
llvm::BasicBlock* else_block = context.CreateSyntheticBlock();
context.builder().CreateCondBr(cond, then_block, else_block);
context.builder().SetInsertPoint(else_block);
}
auto HandleBranchWithArg(FunctionContext& context, SemIR::NodeId /*node_id*/,
SemIR::Node node) -> void {
auto [target_block_id, arg_id] = node.GetAsBranchWithArg();
llvm::Value* arg = context.GetLocalLoaded(arg_id);
SemIR::TypeId arg_type_id = context.semantics_ir().GetNode(arg_id).type_id();
// Opportunistically avoid creating a BasicBlock that contains just a branch.
// We only do this for a block that we know will only have a single
// predecessor, so that we can correctly populate the predecessors of the
// PHINode.
llvm::BasicBlock* block = context.builder().GetInsertBlock();
llvm::BasicBlock* phi_predecessor = block;
if (block->empty() && context.IsCurrentSyntheticBlock(block) &&
context.TryToReuseBlock(target_block_id, block)) {
// Reuse this block as the branch target.
phi_predecessor = block->getSinglePredecessor();
CARBON_CHECK(phi_predecessor)
<< "Synthetic block did not have a single predecessor";
} else {
context.builder().CreateBr(context.GetBlock(target_block_id));
}
context.GetBlockArg(target_block_id, arg_type_id)
->addIncoming(arg, phi_predecessor);
context.builder().ClearInsertionPoint();
}
auto HandleBuiltin(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/,
SemIR::Node node) -> void {
CARBON_FATAL() << "TODO: Add support: " << node;
}
auto HandleCall(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto [refs_id, function_id] = node.GetAsCall();
auto* llvm_function = context.GetFunction(function_id);
const auto& function = context.semantics_ir().GetFunction(function_id);
std::vector<llvm::Value*> args;
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) {
auto arg_type_id = context.semantics_ir().GetNode(ref_id).type_id();
switch (SemIR::GetValueRepresentation(context.semantics_ir(), arg_type_id)
.kind) {
case SemIR::ValueRepresentation::None:
break;
case SemIR::ValueRepresentation::Copy:
case SemIR::ValueRepresentation::Custom:
args.push_back(context.GetLocalLoaded(ref_id));
break;
case SemIR::ValueRepresentation::Pointer:
args.push_back(context.GetLocal(ref_id));
break;
}
}
if (llvm_function->getReturnType()->isVoidTy()) {
context.builder().CreateCall(llvm_function, args);
// The value of a function call with a void return type shouldn't used, but
// StubReference needs a value to propagate.
context.SetLocal(node_id,
llvm::PoisonValue::get(context.GetType(node.type_id())));
} else {
context.SetLocal(node_id,
context.builder().CreateCall(llvm_function, args,
llvm_function->getName()));
}
}
auto HandleDereference(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
context.SetLocal(node_id, context.GetLocal(node.GetAsDereference()));
}
auto HandleFunctionDeclaration(FunctionContext& /*context*/,
SemIR::NodeId /*node_id*/, SemIR::Node node)
-> void {
CARBON_FATAL()
<< "Should not be encountered. If that changes, we may want to change "
"higher-level logic to skip them rather than calling this. "
<< node;
}
auto HandleIntegerLiteral(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
llvm::APInt i =
context.semantics_ir().GetIntegerLiteral(node.GetAsIntegerLiteral());
// TODO: This won't offer correct semantics, but seems close enough for now.
llvm::Value* v =
llvm::ConstantInt::get(context.builder().getInt32Ty(), i.getSExtValue());
context.SetLocal(node_id, v);
}
auto HandleNamespace(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/,
SemIR::Node /*node*/) -> void {
// No action to take.
}
auto HandleNoOp(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/,
SemIR::Node /*node*/) -> void {
// No action to take.
}
auto HandleParameter(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/,
SemIR::Node /*node*/) -> void {
CARBON_FATAL() << "Parameters should be lowered by `BuildFunctionDefinition`";
}
auto HandleRealLiteral(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
SemIR::RealLiteral real =
context.semantics_ir().GetRealLiteral(node.GetAsRealLiteral());
// TODO: This will probably have overflow issues, and should be fixed.
double val =
real.mantissa.getSExtValue() *
std::pow((real.is_decimal ? 10 : 2), real.exponent.getSExtValue());
llvm::APFloat llvm_val(val);
context.SetLocal(node_id, llvm::ConstantFP::get(
context.builder().getDoubleTy(), llvm_val));
}
auto HandleReturn(FunctionContext& context, SemIR::NodeId /*node_id*/,
SemIR::Node /*node*/) -> void {
context.builder().CreateRetVoid();
}
auto HandleReturnExpression(FunctionContext& context, SemIR::NodeId /*node_id*/,
SemIR::Node node) -> void {
SemIR::NodeId expr_id = node.GetAsReturnExpression();
switch (SemIR::GetInitializingRepresentation(
context.semantics_ir(),
context.semantics_ir().GetNode(expr_id).type_id())
.kind) {
case SemIR::InitializingRepresentation::None:
case SemIR::InitializingRepresentation::InPlace:
// Nothing to return.
context.builder().CreateRetVoid();
return;
case SemIR::InitializingRepresentation::ByCopy:
// The expression produces the value representation for the type.
context.builder().CreateRet(context.GetLocalLoaded(expr_id));
return;
}
}
auto HandleStringLiteral(FunctionContext& /*context*/,
SemIR::NodeId /*node_id*/, SemIR::Node node) -> void {
CARBON_FATAL() << "TODO: Add support: " << node;
}
auto HandleStructAccess(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto [struct_id, member_index] = node.GetAsStructAccess();
auto struct_type_id = context.semantics_ir().GetNode(struct_id).type_id();
auto* llvm_type = context.GetType(struct_type_id);
// Get type information for member names.
auto type_refs = context.semantics_ir().GetNodeBlock(
context.semantics_ir()
.GetNode(context.semantics_ir().GetType(struct_type_id))
.GetAsStructType());
auto [field_name_id, field_type_id] =
context.semantics_ir()
.GetNode(type_refs[member_index.index])
.GetAsStructTypeField();
auto member_name = context.semantics_ir().GetString(field_name_id);
auto* gep = context.builder().CreateStructGEP(
llvm_type, context.GetLocal(struct_id), member_index.index, member_name);
context.SetLocal(node_id, gep);
}
auto HandleTupleIndex(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto [tuple_node_id, index_node_id] = node.GetAsTupleIndex();
auto* tuple_value = context.GetLocal(tuple_node_id);
auto index_node = context.semantics_ir().GetNode(index_node_id);
const auto index = context.semantics_ir()
.GetIntegerLiteral(index_node.GetAsIntegerLiteral())
.getZExtValue();
auto* llvm_type =
context.GetType(context.semantics_ir().GetNode(tuple_node_id).type_id());
context.SetLocal(node_id, context.GetIndexFromStructOrArray(
llvm_type, tuple_value, index, "tuple.index"));
}
auto HandleTupleValue(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto* llvm_type = context.GetType(node.type_id());
auto* alloca =
context.builder().CreateAlloca(llvm_type, /*ArraySize=*/nullptr, "tuple");
context.SetLocal(node_id, alloca);
auto refs = context.semantics_ir().GetNodeBlock(node.GetAsTupleValue());
for (auto [i, ref] : llvm::enumerate(refs)) {
auto* gep = context.builder().CreateStructGEP(llvm_type, alloca, i);
context.builder().CreateStore(context.GetLocal(ref), gep);
}
}
auto HandleStructTypeField(FunctionContext& /*context*/,
SemIR::NodeId /*node_id*/, SemIR::Node /*node*/)
-> void {
// No action to take.
}
auto HandleStructValue(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
auto* llvm_type = context.GetType(node.type_id());
auto* alloca = context.builder().CreateAlloca(
llvm_type, /*ArraySize=*/nullptr, "struct");
context.SetLocal(node_id, alloca);
auto refs = context.semantics_ir().GetNodeBlock(node.GetAsStructValue());
// Get type information for member names.
auto type_refs = context.semantics_ir().GetNodeBlock(
context.semantics_ir()
.GetNode(context.semantics_ir().GetType(node.type_id()))
.GetAsStructType());
for (auto [i, ref, type_ref] : llvm::enumerate(refs, type_refs)) {
auto [field_name_id, field_type_id] =
context.semantics_ir().GetNode(type_ref).GetAsStructTypeField();
auto member_name = context.semantics_ir().GetString(field_name_id);
auto* gep =
context.builder().CreateStructGEP(llvm_type, alloca, i, member_name);
context.builder().CreateStore(context.GetLocal(ref), gep);
}
}
auto HandleStubReference(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
context.SetLocal(node_id, context.GetLocal(node.GetAsStubReference()));
}
auto HandleUnaryOperatorNot(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
context.SetLocal(node_id, context.builder().CreateNot(context.GetLocal(
node.GetAsUnaryOperatorNot())));
}
auto HandleVarStorage(FunctionContext& context, SemIR::NodeId node_id,
SemIR::Node node) -> void {
// TODO: Eventually this name will be optional, and we'll want to provide
// something like `var` as a default. However, that's not possible right now
// so cannot be tested.
auto name = context.semantics_ir().GetString(node.GetAsVarStorage());
auto* alloca = context.builder().CreateAlloca(context.GetType(node.type_id()),
/*ArraySize=*/nullptr, name);
context.SetLocal(node_id, alloca);
}
} // namespace Carbon::Lower