mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-19 20:56:41 +00:00
For now, a builtin function is defined by specifying a string literal initializer in a function declaration: ```carbon fn MyBuiltin(a: i32) -> i32 = "builtin.name"; ``` End-to-end support is included for a sample `"int.add"` builtin performing integer addition, covering constant evaluation and code generation. The implementation here needs substantial refactoring before we'll be ready to start adding more builtins. That refactoring work will be coming next. This change is aiming to checkpoint some incremental progress.
420 lines
16 KiB
C++
420 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/APFloat.h"
|
|
#include "llvm/ADT/APInt.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/IR/BasicBlock.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/Type.h"
|
|
#include "llvm/IR/Value.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "toolchain/lower/function_context.h"
|
|
#include "toolchain/sem_ir/function.h"
|
|
#include "toolchain/sem_ir/inst.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::Lower {
|
|
|
|
template <typename InstT>
|
|
static auto FatalErrorIfEncountered(InstT inst) -> void {
|
|
CARBON_FATAL()
|
|
<< "Encountered an instruction that isn't expected to lower. It's "
|
|
"possible that logic needs to be changed in order to stop "
|
|
"showing this instruction in lowered contexts. Instruction: "
|
|
<< inst;
|
|
}
|
|
|
|
auto HandleAddrOf(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::AddrOf inst) -> void {
|
|
context.SetLocal(inst_id, context.GetValue(inst.lvalue_id));
|
|
}
|
|
|
|
auto HandleAddrPattern(FunctionContext& /*context*/, SemIR::InstId /*inst_id*/,
|
|
SemIR::AddrPattern /*inst*/) -> void {
|
|
CARBON_FATAL() << "`addr` should be lowered by `BuildFunctionDefinition`";
|
|
}
|
|
|
|
auto HandleArrayIndex(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::ArrayIndex inst) -> void {
|
|
auto* array_value = context.GetValue(inst.array_id);
|
|
auto* llvm_type =
|
|
context.GetType(context.sem_ir().insts().Get(inst.array_id).type_id());
|
|
llvm::Value* indexes[2] = {
|
|
llvm::ConstantInt::get(llvm::Type::getInt32Ty(context.llvm_context()), 0),
|
|
context.GetValue(inst.index_id)};
|
|
context.SetLocal(inst_id,
|
|
context.builder().CreateInBoundsGEP(llvm_type, array_value,
|
|
indexes, "array.index"));
|
|
}
|
|
|
|
auto HandleArrayInit(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::ArrayInit inst) -> void {
|
|
// The result of initialization is the return slot of the initializer.
|
|
context.SetLocal(inst_id, context.GetValue(inst.dest_id));
|
|
}
|
|
|
|
auto HandleAssign(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::Assign inst) -> void {
|
|
auto storage_type_id = context.sem_ir().insts().Get(inst.lhs_id).type_id();
|
|
context.FinishInit(storage_type_id, inst.lhs_id, inst.rhs_id);
|
|
}
|
|
|
|
auto HandleAssociatedConstantDecl(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/,
|
|
SemIR::AssociatedConstantDecl inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleAssociatedEntity(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/,
|
|
SemIR::AssociatedEntity inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleBindAlias(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BindAlias inst) -> void {
|
|
auto type_inst_id = context.sem_ir().types().GetInstId(inst.type_id);
|
|
if (type_inst_id == SemIR::InstId::BuiltinNamespaceType) {
|
|
return;
|
|
}
|
|
|
|
context.SetLocal(inst_id, context.GetValue(inst.value_id));
|
|
}
|
|
|
|
auto HandleBindName(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BindName inst) -> void {
|
|
context.SetLocal(inst_id, context.GetValue(inst.value_id));
|
|
}
|
|
|
|
auto HandleBindSymbolicName(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BindSymbolicName inst) -> void {
|
|
context.SetLocal(inst_id, context.GetValue(inst.value_id));
|
|
}
|
|
|
|
auto HandleBlockArg(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BlockArg inst) -> void {
|
|
context.SetLocal(inst_id, context.GetBlockArg(inst.block_id, inst.type_id));
|
|
}
|
|
|
|
auto HandleBoolLiteral(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BoolLiteral inst) -> void {
|
|
llvm::Value* v =
|
|
llvm::ConstantInt::get(context.builder().getInt1Ty(), inst.value.index);
|
|
context.SetLocal(inst_id, v);
|
|
}
|
|
|
|
auto HandleBoundMethod(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BoundMethod inst) -> void {
|
|
// Propagate just the function; the object is separately provided to the
|
|
// enclosing call as an implicit argument.
|
|
context.SetLocal(inst_id, context.GetValue(inst.function_id));
|
|
}
|
|
|
|
auto HandleBranch(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::Branch inst) -> void {
|
|
// Opportunistically avoid creating a BasicBlock that contains just a branch.
|
|
// TODO: Don't do this if it would remove a loop preheader block.
|
|
llvm::BasicBlock* block = context.builder().GetInsertBlock();
|
|
if (block->empty() && context.TryToReuseBlock(inst.target_id, block)) {
|
|
// Reuse this block as the branch target.
|
|
} else {
|
|
context.builder().CreateBr(context.GetBlock(inst.target_id));
|
|
}
|
|
|
|
context.builder().ClearInsertionPoint();
|
|
}
|
|
|
|
auto HandleBranchIf(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::BranchIf inst) -> void {
|
|
llvm::Value* cond = context.GetValue(inst.cond_id);
|
|
llvm::BasicBlock* then_block = context.GetBlock(inst.target_id);
|
|
llvm::BasicBlock* else_block = context.MakeSyntheticBlock();
|
|
context.builder().CreateCondBr(cond, then_block, else_block);
|
|
context.builder().SetInsertPoint(else_block);
|
|
}
|
|
|
|
auto HandleBranchWithArg(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::BranchWithArg inst) -> void {
|
|
llvm::Value* arg = context.GetValue(inst.arg_id);
|
|
SemIR::TypeId arg_type_id =
|
|
context.sem_ir().insts().Get(inst.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(inst.target_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(inst.target_id));
|
|
}
|
|
|
|
context.GetBlockArg(inst.target_id, arg_type_id)
|
|
->addIncoming(arg, phi_predecessor);
|
|
context.builder().ClearInsertionPoint();
|
|
}
|
|
|
|
auto HandleBuiltin(FunctionContext& /*context*/, SemIR::InstId /*inst_id*/,
|
|
SemIR::Builtin inst) -> void {
|
|
CARBON_FATAL() << "TODO: Add support: " << inst;
|
|
}
|
|
|
|
// Returns the builtin function kind of the callee in a function call, or None
|
|
// if the call is not to a builtin.
|
|
static auto GetCalleeBuiltinFunctionKind(const SemIR::File& sem_ir,
|
|
SemIR::InstId callee_id)
|
|
-> SemIR::BuiltinFunctionKind {
|
|
if (auto bound_method =
|
|
sem_ir.insts().TryGetAs<SemIR::BoundMethod>(callee_id)) {
|
|
callee_id = bound_method->function_id;
|
|
}
|
|
callee_id = sem_ir.constant_values().Get(callee_id).inst_id();
|
|
if (!callee_id.is_valid()) {
|
|
return SemIR::BuiltinFunctionKind::None;
|
|
}
|
|
if (auto callee = sem_ir.insts().TryGetAs<SemIR::FunctionDecl>(callee_id)) {
|
|
const auto& function = sem_ir.functions().Get(callee->function_id);
|
|
return function.builtin_kind;
|
|
}
|
|
return SemIR::BuiltinFunctionKind::None;
|
|
}
|
|
|
|
// Handles a call to a builtin function.
|
|
static auto HandleBuiltinCall(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BuiltinFunctionKind builtin_kind,
|
|
llvm::ArrayRef<SemIR::InstId> arg_ids) -> void {
|
|
switch (builtin_kind) {
|
|
case SemIR::BuiltinFunctionKind::None:
|
|
CARBON_FATAL() << "No callee in function call.";
|
|
|
|
case SemIR::BuiltinFunctionKind::IntAdd: {
|
|
// TODO: Move type checking to the point where we make the call.
|
|
if (arg_ids.size() != 2) {
|
|
break;
|
|
}
|
|
auto lhs_type = context.sem_ir().insts().Get(arg_ids[0]).type_id();
|
|
auto rhs_type = context.sem_ir().insts().Get(arg_ids[1]).type_id();
|
|
auto result_type = context.sem_ir().insts().Get(inst_id).type_id();
|
|
if (lhs_type != rhs_type || lhs_type != result_type ||
|
|
context.sem_ir().types().GetInstId(lhs_type) !=
|
|
SemIR::InstId::BuiltinIntType) {
|
|
break;
|
|
}
|
|
constexpr bool SignedOverflowIsUB = false;
|
|
context.SetLocal(inst_id, context.builder().CreateAdd(
|
|
context.GetValue(arg_ids[0]),
|
|
context.GetValue(arg_ids[1]), "add",
|
|
/*HasNUW=*/false,
|
|
/*HasNSW=*/SignedOverflowIsUB));
|
|
return;
|
|
}
|
|
}
|
|
|
|
CARBON_FATAL() << "Unsupported builtin call.";
|
|
}
|
|
|
|
auto HandleCall(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::Call inst) -> void {
|
|
llvm::ArrayRef<SemIR::InstId> arg_ids =
|
|
context.sem_ir().inst_blocks().Get(inst.args_id);
|
|
|
|
auto* callee_value = context.GetValue(inst.callee_id);
|
|
|
|
// A null callee pointer value indicates this isn't a real function.
|
|
if (!callee_value) {
|
|
auto builtin_kind =
|
|
GetCalleeBuiltinFunctionKind(context.sem_ir(), inst.callee_id);
|
|
HandleBuiltinCall(context, inst_id, builtin_kind, arg_ids);
|
|
return;
|
|
}
|
|
|
|
auto* callee = llvm::cast<llvm::Function>(callee_value);
|
|
|
|
std::vector<llvm::Value*> args;
|
|
|
|
if (SemIR::GetInitRepr(context.sem_ir(), inst.type_id).has_return_slot()) {
|
|
args.push_back(context.GetValue(arg_ids.back()));
|
|
arg_ids = arg_ids.drop_back();
|
|
}
|
|
|
|
for (auto arg_id : arg_ids) {
|
|
auto arg_type_id = context.sem_ir().insts().Get(arg_id).type_id();
|
|
if (SemIR::GetValueRepr(context.sem_ir(), arg_type_id).kind !=
|
|
SemIR::ValueRepr::None) {
|
|
args.push_back(context.GetValue(arg_id));
|
|
}
|
|
}
|
|
|
|
auto* call = context.builder().CreateCall(callee, args);
|
|
context.SetLocal(inst_id, call);
|
|
|
|
// Name the call's result the same as the callee.
|
|
// TODO: Is this a helpful name?
|
|
if (!call->getType()->isVoidTy()) {
|
|
call->setName(callee->getName());
|
|
}
|
|
}
|
|
|
|
auto HandleConverted(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::Converted inst) -> void {
|
|
context.SetLocal(inst_id, context.GetValue(inst.result_id));
|
|
}
|
|
|
|
auto HandleDeref(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::Deref inst) -> void {
|
|
context.SetLocal(inst_id, context.GetValue(inst.pointer_id));
|
|
}
|
|
|
|
auto HandleFunctionDecl(FunctionContext& /*context*/, SemIR::InstId /*inst_id*/,
|
|
SemIR::FunctionDecl inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleImplDecl(FunctionContext& /*context*/, SemIR::InstId /*inst_id*/,
|
|
SemIR::ImplDecl inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleImportRefUnused(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/,
|
|
SemIR::ImportRefUnused inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleImportRefUsed(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/, SemIR::ImportRefUsed inst)
|
|
-> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleInitializeFrom(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::InitializeFrom inst) -> void {
|
|
auto storage_type_id = context.sem_ir().insts().Get(inst.dest_id).type_id();
|
|
context.FinishInit(storage_type_id, inst.dest_id, inst.src_id);
|
|
}
|
|
|
|
auto HandleInterfaceDecl(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/, SemIR::InterfaceDecl inst)
|
|
-> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleInterfaceWitness(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/,
|
|
SemIR::InterfaceWitness inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleInterfaceWitnessAccess(FunctionContext& context,
|
|
SemIR::InstId inst_id,
|
|
SemIR::InterfaceWitnessAccess inst) -> void {
|
|
// TODO: Add general constant lowering.
|
|
auto const_id = context.sem_ir().constant_values().Get(inst_id);
|
|
CARBON_CHECK(const_id.is_constant())
|
|
<< "Lowering non-constant witness access " << inst;
|
|
context.SetLocal(inst_id, context.GetValue(const_id.inst_id()));
|
|
}
|
|
|
|
auto HandleIntLiteral(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::IntLiteral inst) -> void {
|
|
const llvm::APInt& i = context.sem_ir().ints().Get(inst.int_id);
|
|
// TODO: This won't offer correct semantics, but seems close enough for now.
|
|
llvm::Value* v =
|
|
llvm::ConstantInt::get(context.builder().getInt32Ty(), i.getZExtValue());
|
|
context.SetLocal(inst_id, v);
|
|
}
|
|
|
|
auto HandleNameRef(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::NameRef inst) -> void {
|
|
auto type_inst_id = context.sem_ir().types().GetInstId(inst.type_id);
|
|
if (type_inst_id == SemIR::InstId::BuiltinNamespaceType) {
|
|
return;
|
|
}
|
|
|
|
context.SetLocal(inst_id, context.GetValue(inst.value_id));
|
|
}
|
|
|
|
auto HandleNamespace(FunctionContext& /*context*/, SemIR::InstId /*inst_id*/,
|
|
SemIR::Namespace inst) -> void {
|
|
FatalErrorIfEncountered(inst);
|
|
}
|
|
|
|
auto HandleParam(FunctionContext& /*context*/, SemIR::InstId /*inst_id*/,
|
|
SemIR::Param /*inst*/) -> void {
|
|
CARBON_FATAL() << "Parameters should be lowered by `BuildFunctionDefinition`";
|
|
}
|
|
|
|
auto HandleRealLiteral(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::RealLiteral inst) -> void {
|
|
const Real& real = context.sem_ir().reals().Get(inst.real_id);
|
|
// TODO: This will probably have overflow issues, and should be fixed.
|
|
double val =
|
|
real.mantissa.getZExtValue() *
|
|
std::pow((real.is_decimal ? 10 : 2), real.exponent.getSExtValue());
|
|
llvm::APFloat llvm_val(val);
|
|
context.SetLocal(inst_id, llvm::ConstantFP::get(
|
|
context.builder().getDoubleTy(), llvm_val));
|
|
}
|
|
|
|
auto HandleReturn(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::Return /*inst*/) -> void {
|
|
context.builder().CreateRetVoid();
|
|
}
|
|
|
|
auto HandleReturnExpr(FunctionContext& context, SemIR::InstId /*inst_id*/,
|
|
SemIR::ReturnExpr inst) -> void {
|
|
switch (
|
|
SemIR::GetInitRepr(context.sem_ir(),
|
|
context.sem_ir().insts().Get(inst.expr_id).type_id())
|
|
.kind) {
|
|
case SemIR::InitRepr::None:
|
|
case SemIR::InitRepr::InPlace:
|
|
// Nothing to return.
|
|
context.builder().CreateRetVoid();
|
|
return;
|
|
case SemIR::InitRepr::ByCopy:
|
|
// The expression produces the value representation for the type.
|
|
context.builder().CreateRet(context.GetValue(inst.expr_id));
|
|
return;
|
|
}
|
|
}
|
|
|
|
auto HandleSpliceBlock(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::SpliceBlock inst) -> void {
|
|
context.LowerBlock(inst.block_id);
|
|
context.SetLocal(inst_id, context.GetValue(inst.result_id));
|
|
}
|
|
|
|
auto HandleStringLiteral(FunctionContext& /*context*/,
|
|
SemIR::InstId /*inst_id*/, SemIR::StringLiteral inst)
|
|
-> void {
|
|
CARBON_FATAL() << "TODO: Add support: " << inst;
|
|
}
|
|
|
|
auto HandleUnaryOperatorNot(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::UnaryOperatorNot inst) -> void {
|
|
context.SetLocal(
|
|
inst_id, context.builder().CreateNot(context.GetValue(inst.operand_id)));
|
|
}
|
|
|
|
auto HandleVarStorage(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::VarStorage inst) -> 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.sem_ir().names().GetIRBaseName(inst.name_id);
|
|
auto* alloca = context.builder().CreateAlloca(context.GetType(inst.type_id),
|
|
/*ArraySize=*/nullptr, name);
|
|
context.SetLocal(inst_id, alloca);
|
|
}
|
|
|
|
} // namespace Carbon::Lower
|