mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Richard Smith
c33fb9fc48
For now, hide `override fn`s from name lookup, so that the base class version is always used, as the derived-class version does not have its own vptr entry and so would not do the right thing if a further-derived class adds a new override. This is implemented via a new access kind of `Hidden`. When checking the overriding function, pass in the expected `Self` type and check the `self` parameter against that; the signature that we generate for the thunk in the derived class is the base class signature with the `self` parameter's type changed to the derived class. When we generate a thunk for a virtual function, the thunk is assigned a `virtual_index`, and the virtual function itself is not. When the thunk makes a direct call to the virtual function, recognize this situation by checking for a `virtual_index`, and perform a non-virtual call if there isn't one. Assisted-by: Gemini via Antigravity
737 lines
31 KiB
C++
737 lines
31 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 <algorithm>
|
|
#include <vector>
|
|
|
|
#include "common/raw_string_ostream.h"
|
|
#include "llvm/IR/Type.h"
|
|
#include "llvm/IR/Value.h"
|
|
#include "toolchain/lower/aggregate.h"
|
|
#include "toolchain/lower/function_context.h"
|
|
#include "toolchain/sem_ir/builtin_function_kind.h"
|
|
#include "toolchain/sem_ir/cpp_initializer_list.h"
|
|
#include "toolchain/sem_ir/function.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::Lower {
|
|
|
|
// Get the predicate to use for an `icmp` instruction generated for the
|
|
// specified builtin.
|
|
static auto GetBuiltinICmpPredicate(SemIR::BuiltinFunctionKind builtin_kind,
|
|
bool is_signed)
|
|
-> llvm::CmpInst::Predicate {
|
|
switch (builtin_kind) {
|
|
case SemIR::BuiltinFunctionKind::IntEq:
|
|
case SemIR::BuiltinFunctionKind::BoolEq:
|
|
return llvm::CmpInst::ICMP_EQ;
|
|
case SemIR::BuiltinFunctionKind::IntNeq:
|
|
case SemIR::BuiltinFunctionKind::BoolNeq:
|
|
return llvm::CmpInst::ICMP_NE;
|
|
case SemIR::BuiltinFunctionKind::IntLess:
|
|
return is_signed ? llvm::CmpInst::ICMP_SLT : llvm::CmpInst::ICMP_ULT;
|
|
case SemIR::BuiltinFunctionKind::IntLessEq:
|
|
return is_signed ? llvm::CmpInst::ICMP_SLE : llvm::CmpInst::ICMP_ULE;
|
|
case SemIR::BuiltinFunctionKind::IntGreater:
|
|
return is_signed ? llvm::CmpInst::ICMP_SGT : llvm::CmpInst::ICMP_UGT;
|
|
case SemIR::BuiltinFunctionKind::IntGreaterEq:
|
|
return is_signed ? llvm::CmpInst::ICMP_SGE : llvm::CmpInst::ICMP_UGE;
|
|
default:
|
|
CARBON_FATAL("Unexpected builtin kind {0}", builtin_kind);
|
|
}
|
|
}
|
|
|
|
// Get the predicate to use for an `fcmp` instruction generated for the
|
|
// specified builtin.
|
|
static auto GetBuiltinFCmpPredicate(SemIR::BuiltinFunctionKind builtin_kind)
|
|
-> llvm::CmpInst::Predicate {
|
|
switch (builtin_kind) {
|
|
case SemIR::BuiltinFunctionKind::FloatEq:
|
|
return llvm::CmpInst::FCMP_OEQ;
|
|
case SemIR::BuiltinFunctionKind::FloatNeq:
|
|
return llvm::CmpInst::FCMP_ONE;
|
|
case SemIR::BuiltinFunctionKind::FloatLess:
|
|
return llvm::CmpInst::FCMP_OLT;
|
|
case SemIR::BuiltinFunctionKind::FloatLessEq:
|
|
return llvm::CmpInst::FCMP_OLE;
|
|
case SemIR::BuiltinFunctionKind::FloatGreater:
|
|
return llvm::CmpInst::FCMP_OGT;
|
|
case SemIR::BuiltinFunctionKind::FloatGreaterEq:
|
|
return llvm::CmpInst::FCMP_OGE;
|
|
default:
|
|
CARBON_FATAL("Unexpected builtin kind {0}", builtin_kind);
|
|
}
|
|
}
|
|
|
|
// Returns whether the specified instruction has a signed integer type.
|
|
static auto IsSignedInt(FunctionContext& context, SemIR::InstId int_id)
|
|
-> bool {
|
|
auto [file, type_id] = context.GetTypeIdOfInst(int_id);
|
|
return file->types().IsSignedInt(type_id);
|
|
}
|
|
|
|
// Creates a zext or sext instruction depending on the signedness of the
|
|
// operand.
|
|
static auto CreateExt(FunctionContext& context, llvm::Value* value,
|
|
llvm::Type* type, bool is_signed,
|
|
const llvm::Twine& name = "") -> llvm::Value* {
|
|
return is_signed ? context.builder().CreateSExt(value, type, name)
|
|
: context.builder().CreateZExt(value, type, name);
|
|
}
|
|
|
|
// Creates a zext, sext, or trunc instruction depending on the signedness of the
|
|
// operand.
|
|
static auto CreateExtOrTrunc(FunctionContext& context, llvm::Value* value,
|
|
llvm::Type* type, bool is_signed,
|
|
const llvm::Twine& name = "") -> llvm::Value* {
|
|
return is_signed ? context.builder().CreateSExtOrTrunc(value, type, name)
|
|
: context.builder().CreateZExtOrTrunc(value, type, name);
|
|
}
|
|
|
|
// Create a integer bit shift for a call to a builtin bit shift function.
|
|
static auto CreateIntShift(FunctionContext& context,
|
|
llvm::Instruction::BinaryOps bin_op,
|
|
llvm::Value* lhs, llvm::Value* rhs) -> llvm::Value* {
|
|
// Weirdly, LLVM requires the operands of bit shift operators to be of the
|
|
// same type. We can always use the width of the LHS, because if the RHS
|
|
// doesn't fit in that then the cast is out of range anyway. Zero-extending is
|
|
// always fine because it's an error for the RHS to be negative.
|
|
//
|
|
// TODO: In a development build we should trap if the RHS is signed and
|
|
// negative or greater than or equal to the number of bits in the left-hand
|
|
// type.
|
|
rhs = context.builder().CreateZExtOrTrunc(rhs, lhs->getType(), "rhs");
|
|
return context.builder().CreateBinOp(bin_op, lhs, rhs);
|
|
}
|
|
|
|
// Handles a call to a builtin integer comparison operator.
|
|
static auto HandleIntComparison(FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BuiltinFunctionKind builtin_kind,
|
|
SemIR::InstId lhs_id, SemIR::InstId rhs_id)
|
|
-> void {
|
|
llvm::Value* lhs = context.GetValue(lhs_id);
|
|
llvm::Value* rhs = context.GetValue(rhs_id);
|
|
const auto* lhs_type = cast<llvm::IntegerType>(lhs->getType());
|
|
const auto* rhs_type = cast<llvm::IntegerType>(rhs->getType());
|
|
|
|
// We perform a signed comparison if either operand is signed.
|
|
bool lhs_signed = IsSignedInt(context, lhs_id);
|
|
bool rhs_signed = IsSignedInt(context, rhs_id);
|
|
bool cmp_signed = lhs_signed || rhs_signed;
|
|
|
|
// Compute the width for the comparison. This is the smallest width that
|
|
// fits both types, after widening them to include a sign bit if
|
|
// necessary.
|
|
auto width_for_cmp = [&](const llvm::IntegerType* type, bool is_signed) {
|
|
unsigned width = type->getBitWidth();
|
|
if (!is_signed && cmp_signed) {
|
|
// We're performing a signed comparison but this input is unsigned.
|
|
// Widen it by at least one bit to provide a sign bit.
|
|
++width;
|
|
}
|
|
return width;
|
|
};
|
|
// TODO: This might be an awkward size, such as 33 or 65 bits, for a
|
|
// signed/unsigned comparison. Would it be better to round this up to a
|
|
// "nicer" bit width?
|
|
unsigned cmp_width = std::max(width_for_cmp(lhs_type, lhs_signed),
|
|
width_for_cmp(rhs_type, rhs_signed));
|
|
auto* cmp_type = llvm::IntegerType::get(context.llvm_context(), cmp_width);
|
|
|
|
// Widen the operands as needed.
|
|
lhs = CreateExt(context, lhs, cmp_type, lhs_signed, "lhs");
|
|
rhs = CreateExt(context, rhs, cmp_type, rhs_signed, "rhs");
|
|
|
|
context.SetLocal(
|
|
inst_id,
|
|
context.builder().CreateICmp(
|
|
GetBuiltinICmpPredicate(builtin_kind, cmp_signed), lhs, rhs));
|
|
}
|
|
|
|
// Creates a binary operator for a call to a builtin for either that operation
|
|
// or the corresponding compound assignment.
|
|
static auto CreateBinaryOperatorForBuiltin(
|
|
FunctionContext& context, SemIR::InstId inst_id,
|
|
SemIR::BuiltinFunctionKind builtin_kind, llvm::Value* lhs, llvm::Value* rhs)
|
|
-> llvm::Value* {
|
|
// TODO: Consider setting this to true in the performance build mode if the
|
|
// result type is a signed integer type.
|
|
constexpr bool SignedOverflowIsUB = false;
|
|
|
|
switch (builtin_kind) {
|
|
case SemIR::BuiltinFunctionKind::IntSAdd:
|
|
case SemIR::BuiltinFunctionKind::IntSAddAssign: {
|
|
return context.builder().CreateAdd(lhs, rhs, "",
|
|
/*HasNUW=*/false,
|
|
/*HasNSW=*/SignedOverflowIsUB);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntSSub:
|
|
case SemIR::BuiltinFunctionKind::IntSSubAssign: {
|
|
return context.builder().CreateSub(lhs, rhs, "",
|
|
/*HasNUW=*/false,
|
|
/*HasNSW=*/SignedOverflowIsUB);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntSMul:
|
|
case SemIR::BuiltinFunctionKind::IntSMulAssign: {
|
|
return context.builder().CreateMul(lhs, rhs, "",
|
|
/*HasNUW=*/false,
|
|
/*HasNSW=*/SignedOverflowIsUB);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntSDiv:
|
|
case SemIR::BuiltinFunctionKind::IntSDivAssign: {
|
|
return context.builder().CreateSDiv(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntSMod:
|
|
case SemIR::BuiltinFunctionKind::IntSModAssign: {
|
|
return context.builder().CreateSRem(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntUAdd:
|
|
case SemIR::BuiltinFunctionKind::IntUAddAssign: {
|
|
return context.builder().CreateAdd(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntUSub:
|
|
case SemIR::BuiltinFunctionKind::IntUSubAssign: {
|
|
return context.builder().CreateSub(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntUMul:
|
|
case SemIR::BuiltinFunctionKind::IntUMulAssign: {
|
|
return context.builder().CreateMul(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntUDiv:
|
|
case SemIR::BuiltinFunctionKind::IntUDivAssign: {
|
|
return context.builder().CreateUDiv(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntUMod:
|
|
case SemIR::BuiltinFunctionKind::IntUModAssign: {
|
|
return context.builder().CreateURem(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntAnd:
|
|
case SemIR::BuiltinFunctionKind::IntAndAssign: {
|
|
return context.builder().CreateAnd(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntOr:
|
|
case SemIR::BuiltinFunctionKind::IntOrAssign: {
|
|
return context.builder().CreateOr(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntXor:
|
|
case SemIR::BuiltinFunctionKind::IntXorAssign: {
|
|
return context.builder().CreateXor(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntLeftShift:
|
|
case SemIR::BuiltinFunctionKind::IntLeftShiftAssign: {
|
|
return CreateIntShift(context, llvm::Instruction::Shl, lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntRightShift:
|
|
case SemIR::BuiltinFunctionKind::IntRightShiftAssign: {
|
|
// TODO: Split each of these builtins into separate signed and unsigned
|
|
// builtins rather than working out here whether we're performing an
|
|
// arithmetic or logical shift.
|
|
auto lhs_id = context.sem_ir().inst_blocks().Get(
|
|
context.sem_ir().insts().GetAs<SemIR::Call>(inst_id).args_id)[0];
|
|
auto [lhs_type_file, lhs_type_id] = context.GetTypeIdOfInst(lhs_id);
|
|
return CreateIntShift(context,
|
|
lhs_type_file->types().IsSignedInt(lhs_type_id)
|
|
? llvm::Instruction::AShr
|
|
: llvm::Instruction::LShr,
|
|
lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::FloatAdd:
|
|
case SemIR::BuiltinFunctionKind::FloatAddAssign: {
|
|
return context.builder().CreateFAdd(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::FloatSub:
|
|
case SemIR::BuiltinFunctionKind::FloatSubAssign: {
|
|
return context.builder().CreateFSub(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::FloatMul:
|
|
case SemIR::BuiltinFunctionKind::FloatMulAssign: {
|
|
return context.builder().CreateFMul(lhs, rhs);
|
|
}
|
|
case SemIR::BuiltinFunctionKind::FloatDiv:
|
|
case SemIR::BuiltinFunctionKind::FloatDivAssign: {
|
|
return context.builder().CreateFDiv(lhs, rhs);
|
|
}
|
|
default: {
|
|
CARBON_FATAL("Unexpected binary operator {0}", builtin_kind);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handles a call to `cpp.std.initializer_list.make`.
|
|
static auto StoreArrayAsStdInitializerList(FunctionContext& context,
|
|
SemIR::InstId init_list_id,
|
|
SemIR::InstId array_inst_id)
|
|
-> void {
|
|
// Extract the bound from the array type.
|
|
auto [array_type_file, array_type_id] =
|
|
context.GetTypeIdOfInst(array_inst_id);
|
|
auto array_type = array_type_file->types().GetAs<SemIR::ArrayType>(
|
|
array_type_file->types().GetObjectRepr(array_type_id));
|
|
auto array_bound = array_type_file->GetZExtIntValue(array_type.bound_id);
|
|
CARBON_CHECK(array_bound, "Array type with non-constant bound");
|
|
|
|
// Store the array pointer in the first element of the initializer list.
|
|
auto* array_ptr = context.GetValue(array_inst_id);
|
|
auto* begin_ptr =
|
|
GetAggregateElement(context, init_list_id, SemIR::ElementIndex(0),
|
|
SemIR::InstId::None, "init_list.begin");
|
|
context.builder().CreateStore(array_ptr, begin_ptr);
|
|
|
|
// Store the end or size to the second element, depending on the layout.
|
|
auto init_list_type = context.GetTypeIdOfInst(init_list_id);
|
|
switch (auto layout = SemIR::GetStdInitializerListLayout(
|
|
*init_list_type.file, init_list_type.type_id);
|
|
layout.kind) {
|
|
case SemIR::StdInitializerListLayout::None: {
|
|
CARBON_FATAL("Unrecognized initializer list");
|
|
break;
|
|
}
|
|
|
|
case SemIR::StdInitializerListLayout::PointerPointer: {
|
|
auto* end_ptr =
|
|
GetAggregateElement(context, init_list_id, SemIR::ElementIndex(1),
|
|
SemIR::InstId::None, "init_list.end");
|
|
auto* array_end_ptr = context.builder().CreateConstInBoundsGEP1_32(
|
|
context.GetTypeOfInst(array_inst_id), array_ptr, 1, "array.end");
|
|
context.builder().CreateStore(array_end_ptr, end_ptr);
|
|
break;
|
|
}
|
|
|
|
case SemIR::StdInitializerListLayout::PointerInt: {
|
|
auto* size_ptr =
|
|
GetAggregateElement(context, init_list_id, SemIR::ElementIndex(1),
|
|
SemIR::InstId::None, "init_list.size");
|
|
context.builder().CreateStore(
|
|
llvm::ConstantInt::get(
|
|
context.GetType(FunctionContext::TypeInFile{
|
|
.file = &context.sem_ir(), .type_id = layout.size_type_id}),
|
|
*array_bound),
|
|
size_ptr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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 {
|
|
// TODO: Consider setting this to true in the performance build mode if the
|
|
// result type is a signed integer type.
|
|
constexpr bool SignedOverflowIsUB = false;
|
|
|
|
// TODO: Move the instruction names here into InstNamer.
|
|
switch (builtin_kind) {
|
|
case SemIR::BuiltinFunctionKind::None:
|
|
CARBON_FATAL("No callee in function call.");
|
|
|
|
case SemIR::BuiltinFunctionKind::NoOp:
|
|
return;
|
|
|
|
case SemIR::BuiltinFunctionKind::MakeUninitialized: {
|
|
context.SetLocal(inst_id,
|
|
llvm::PoisonValue::get(context.GetTypeOfInst(inst_id)));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::PrimitiveCopy:
|
|
context.SetLocal(inst_id, context.GetValue(arg_ids[0]));
|
|
return;
|
|
|
|
case SemIR::BuiltinFunctionKind::PrintChar: {
|
|
auto* i32_type = llvm::IntegerType::getInt32Ty(context.llvm_context());
|
|
llvm::Value* arg_value = context.builder().CreateSExtOrTrunc(
|
|
context.GetValue(arg_ids[0]), i32_type);
|
|
auto putchar = context.llvm_module().getOrInsertFunction(
|
|
"putchar", i32_type, i32_type);
|
|
auto* result = context.builder().CreateCall(putchar, {arg_value});
|
|
context.SetLocal(inst_id, context.builder().CreateSExtOrTrunc(
|
|
result, context.GetTypeOfInst(inst_id)));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::PrintInt: {
|
|
auto* i32_type = llvm::IntegerType::getInt32Ty(context.llvm_context());
|
|
auto* ptr_type = llvm::PointerType::get(context.llvm_context(), 0);
|
|
auto* printf_type = llvm::FunctionType::get(i32_type, {ptr_type},
|
|
/*isVarArg=*/true);
|
|
llvm::FunctionCallee printf =
|
|
context.llvm_module().getOrInsertFunction("printf", printf_type);
|
|
|
|
llvm::Value* format_string = context.printf_int_format_string();
|
|
llvm::Value* arg_value = context.builder().CreateSExtOrTrunc(
|
|
context.GetValue(arg_ids[0]), i32_type);
|
|
context.SetLocal(inst_id, context.builder().CreateCall(
|
|
printf, {format_string, arg_value}));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::ReadChar: {
|
|
auto* i32_type = llvm::IntegerType::getInt32Ty(context.llvm_context());
|
|
auto getchar =
|
|
context.llvm_module().getOrInsertFunction("getchar", i32_type);
|
|
auto* result = context.builder().CreateCall(getchar, {});
|
|
context.SetLocal(inst_id, context.builder().CreateSExtOrTrunc(
|
|
result, context.GetTypeOfInst(inst_id)));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::StringAt: {
|
|
auto string_inst_id = arg_ids[0];
|
|
auto* string_arg = context.GetValue(string_inst_id);
|
|
|
|
auto string_type_id = context.GetTypeIdOfInst(string_inst_id);
|
|
auto* string_type = context.GetType(string_type_id);
|
|
auto* string_value =
|
|
context.builder().CreateLoad(string_type, string_arg, "string.load");
|
|
|
|
auto* string_ptr_field =
|
|
context.builder().CreateExtractValue(string_value, {0}, "string.ptr");
|
|
|
|
auto* index_value = context.GetValue(arg_ids[1]);
|
|
|
|
auto* char_ptr = context.builder().CreateInBoundsGEP(
|
|
llvm::Type::getInt8Ty(context.llvm_context()), string_ptr_field,
|
|
index_value, "string.char_ptr");
|
|
|
|
auto* char_i8 = context.builder().CreateLoad(
|
|
llvm::Type::getInt8Ty(context.llvm_context()), char_ptr,
|
|
"string.char");
|
|
|
|
context.SetLocal(inst_id, context.builder().CreateZExt(
|
|
char_i8, context.GetTypeOfInst(inst_id),
|
|
"string.char.zext"));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::TypeAnd: {
|
|
context.SetLocal(inst_id, context.GetTypeAsValue());
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::BoolMakeType:
|
|
case SemIR::BuiltinFunctionKind::CharLiteralMakeType:
|
|
case SemIR::BuiltinFunctionKind::FloatLiteralMakeType:
|
|
case SemIR::BuiltinFunctionKind::FloatMakeType:
|
|
case SemIR::BuiltinFunctionKind::FormMakeType:
|
|
case SemIR::BuiltinFunctionKind::IntLiteralMakeType:
|
|
case SemIR::BuiltinFunctionKind::IntMakeTypeSigned:
|
|
case SemIR::BuiltinFunctionKind::IntMakeTypeUnsigned:
|
|
case SemIR::BuiltinFunctionKind::MaybeUnformedMakeType:
|
|
context.SetLocal(inst_id, context.GetTypeAsValue());
|
|
return;
|
|
|
|
case SemIR::BuiltinFunctionKind::IntConvertChar:
|
|
case SemIR::BuiltinFunctionKind::IntConvert: {
|
|
context.SetLocal(inst_id,
|
|
CreateExtOrTrunc(context, context.GetValue(arg_ids[0]),
|
|
context.GetTypeOfInst(inst_id),
|
|
IsSignedInt(context, arg_ids[0])));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::IntSNegate: {
|
|
// Lower `-x` as `0 - x`.
|
|
auto* operand = context.GetValue(arg_ids[0]);
|
|
context.SetLocal(
|
|
inst_id,
|
|
context.builder().CreateSub(
|
|
llvm::ConstantInt::getNullValue(operand->getType()), operand, "",
|
|
/*HasNUW=*/false,
|
|
/*HasNSW=*/SignedOverflowIsUB));
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntUNegate: {
|
|
// Lower `-x` as `0 - x`.
|
|
auto* operand = context.GetValue(arg_ids[0]);
|
|
context.SetLocal(
|
|
inst_id,
|
|
context.builder().CreateSub(
|
|
llvm::ConstantInt::getNullValue(operand->getType()), operand));
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntComplement: {
|
|
// Lower `^x` as `-1 ^ x`.
|
|
auto* operand = context.GetValue(arg_ids[0]);
|
|
context.SetLocal(
|
|
inst_id,
|
|
context.builder().CreateXor(
|
|
llvm::ConstantInt::getSigned(operand->getType(), -1), operand));
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntSAdd:
|
|
case SemIR::BuiltinFunctionKind::IntSSub:
|
|
case SemIR::BuiltinFunctionKind::IntSMul:
|
|
case SemIR::BuiltinFunctionKind::IntSDiv:
|
|
case SemIR::BuiltinFunctionKind::IntSMod:
|
|
case SemIR::BuiltinFunctionKind::IntUAdd:
|
|
case SemIR::BuiltinFunctionKind::IntUSub:
|
|
case SemIR::BuiltinFunctionKind::IntUMul:
|
|
case SemIR::BuiltinFunctionKind::IntUDiv:
|
|
case SemIR::BuiltinFunctionKind::IntUMod:
|
|
case SemIR::BuiltinFunctionKind::IntAnd:
|
|
case SemIR::BuiltinFunctionKind::IntOr:
|
|
case SemIR::BuiltinFunctionKind::IntXor:
|
|
case SemIR::BuiltinFunctionKind::IntLeftShift:
|
|
case SemIR::BuiltinFunctionKind::IntRightShift:
|
|
case SemIR::BuiltinFunctionKind::FloatAdd:
|
|
case SemIR::BuiltinFunctionKind::FloatSub:
|
|
case SemIR::BuiltinFunctionKind::FloatMul:
|
|
case SemIR::BuiltinFunctionKind::FloatDiv: {
|
|
context.SetLocal(inst_id, CreateBinaryOperatorForBuiltin(
|
|
context, inst_id, builtin_kind,
|
|
context.GetValue(arg_ids[0]),
|
|
context.GetValue(arg_ids[1])));
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntSAddAssign:
|
|
case SemIR::BuiltinFunctionKind::IntSSubAssign:
|
|
case SemIR::BuiltinFunctionKind::IntSMulAssign:
|
|
case SemIR::BuiltinFunctionKind::IntSDivAssign:
|
|
case SemIR::BuiltinFunctionKind::IntSModAssign:
|
|
case SemIR::BuiltinFunctionKind::IntUAddAssign:
|
|
case SemIR::BuiltinFunctionKind::IntUSubAssign:
|
|
case SemIR::BuiltinFunctionKind::IntUMulAssign:
|
|
case SemIR::BuiltinFunctionKind::IntUDivAssign:
|
|
case SemIR::BuiltinFunctionKind::IntUModAssign:
|
|
case SemIR::BuiltinFunctionKind::IntAndAssign:
|
|
case SemIR::BuiltinFunctionKind::IntOrAssign:
|
|
case SemIR::BuiltinFunctionKind::IntXorAssign:
|
|
case SemIR::BuiltinFunctionKind::IntLeftShiftAssign:
|
|
case SemIR::BuiltinFunctionKind::IntRightShiftAssign:
|
|
case SemIR::BuiltinFunctionKind::FloatAddAssign:
|
|
case SemIR::BuiltinFunctionKind::FloatSubAssign:
|
|
case SemIR::BuiltinFunctionKind::FloatMulAssign:
|
|
case SemIR::BuiltinFunctionKind::FloatDivAssign: {
|
|
auto* lhs_ptr = context.GetValue(arg_ids[0]);
|
|
auto lhs_type = context.GetTypeIdOfInst(arg_ids[0]);
|
|
auto* lhs_value = context.LoadObject(lhs_type, lhs_ptr);
|
|
auto* result = CreateBinaryOperatorForBuiltin(
|
|
context, inst_id, builtin_kind, lhs_value,
|
|
context.GetValue(arg_ids[1]));
|
|
context.StoreObject(lhs_type, result, lhs_ptr);
|
|
// TODO: Add a helper to get a "no value representation" value.
|
|
context.SetLocal(inst_id,
|
|
llvm::PoisonValue::get(context.GetTypeOfInst(inst_id)));
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::IntEq:
|
|
case SemIR::BuiltinFunctionKind::IntNeq:
|
|
case SemIR::BuiltinFunctionKind::IntLess:
|
|
case SemIR::BuiltinFunctionKind::IntLessEq:
|
|
case SemIR::BuiltinFunctionKind::IntGreater:
|
|
case SemIR::BuiltinFunctionKind::IntGreaterEq:
|
|
case SemIR::BuiltinFunctionKind::BoolEq:
|
|
case SemIR::BuiltinFunctionKind::BoolNeq: {
|
|
HandleIntComparison(context, inst_id, builtin_kind, arg_ids[0],
|
|
arg_ids[1]);
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::FloatNegate: {
|
|
context.SetLocal(
|
|
inst_id, context.builder().CreateFNeg(context.GetValue(arg_ids[0])));
|
|
return;
|
|
}
|
|
case SemIR::BuiltinFunctionKind::FloatEq:
|
|
case SemIR::BuiltinFunctionKind::FloatNeq:
|
|
case SemIR::BuiltinFunctionKind::FloatLess:
|
|
case SemIR::BuiltinFunctionKind::FloatLessEq:
|
|
case SemIR::BuiltinFunctionKind::FloatGreater:
|
|
case SemIR::BuiltinFunctionKind::FloatGreaterEq: {
|
|
context.SetLocal(inst_id, context.builder().CreateFCmp(
|
|
GetBuiltinFCmpPredicate(builtin_kind),
|
|
context.GetValue(arg_ids[0]),
|
|
context.GetValue(arg_ids[1])));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::CharConvertChecked:
|
|
case SemIR::BuiltinFunctionKind::FloatConvertChecked:
|
|
case SemIR::BuiltinFunctionKind::IntConvertChecked: {
|
|
// TODO: Check this statically.
|
|
CARBON_CHECK(builtin_kind.IsCompTimeOnly(
|
|
context.sem_ir(), arg_ids,
|
|
context.sem_ir().insts().Get(inst_id).type_id()));
|
|
CARBON_FATAL("Missing constant value for call to comptime-only function");
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::PointerMakeNull: {
|
|
context.SetLocal(inst_id,
|
|
llvm::ConstantPointerNull::get(
|
|
llvm::PointerType::get(context.llvm_context(),
|
|
/*AddressSpace=*/0)));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::PointerIsNull: {
|
|
context.SetLocal(inst_id, context.builder().CreateIsNull(
|
|
context.GetValue(arg_ids[0])));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::PointerUnsafeConvert: {
|
|
context.SetLocal(inst_id, context.GetValue(arg_ids[0]));
|
|
return;
|
|
}
|
|
|
|
case SemIR::BuiltinFunctionKind::CppStdInitializerListMake: {
|
|
// TODO: We assume that the initializer list uses an in-place initializing
|
|
// representation, but we don't enforce that when type-checking the
|
|
// builtin.
|
|
StoreArrayAsStdInitializerList(context, arg_ids[1], arg_ids[0]);
|
|
context.SetLocal(inst_id, context.GetValue(arg_ids[1]));
|
|
return;
|
|
}
|
|
}
|
|
|
|
CARBON_FATAL("Unsupported builtin call.");
|
|
}
|
|
|
|
static auto HandleVirtualCall(FunctionContext& context,
|
|
llvm::ArrayRef<llvm::Value*> args,
|
|
const SemIR::Function& function,
|
|
const FunctionInfo& function_info)
|
|
-> llvm::CallInst* {
|
|
CARBON_CHECK(!args.empty(),
|
|
"Virtual functions must have at least one parameter");
|
|
auto* ptr_type =
|
|
llvm::PointerType::get(context.llvm_context(), /*AddressSpace=*/0);
|
|
// The vtable pointer is always at the start of the object in the Carbon
|
|
// ABI, so a pointer to the object is a pointer to the vtable pointer - load
|
|
// that to get a pointer to the vtable.
|
|
// TODO: Handle the case in C++ interop where the vtable pointer isn't at
|
|
// the start of the object.
|
|
// TODO: Use `context.LoadObject`.
|
|
auto* vtable = context.builder().CreateLoad(ptr_type, args.front(), "vtable");
|
|
auto* i32_type = llvm::IntegerType::getInt32Ty(context.llvm_context());
|
|
auto* pointer_type =
|
|
llvm::PointerType::get(context.llvm_context(), /* address space */ 0);
|
|
llvm::Value* virtual_fn;
|
|
if (function.clang_decl_id.has_value()) {
|
|
// Use absolute vtables for clang interop - the itanium vtable contains
|
|
// function pointers.
|
|
auto* virtual_function_pointer_address = context.builder().CreateGEP(
|
|
pointer_type, vtable,
|
|
{llvm::ConstantInt::get(
|
|
i32_type, static_cast<uint64_t>(function.virtual_index))});
|
|
virtual_fn = context.builder().CreateLoad(
|
|
pointer_type, virtual_function_pointer_address, "memptr.virtualfn");
|
|
} else {
|
|
// For Carbon, use Relative VTables as pioneered by Fuchsia:
|
|
// https://llvm.org/devmtg/2021-11/slides/2021-RelativeVTablesinC.pdf
|
|
// In this case, the vtable contains an offset from the vtable itself to the
|
|
// function in question. This avoids the use of link-time relocations in the
|
|
// vtable (making object files smaller, improving link time) - at the cost
|
|
// of extra instructions to resolve the offset at the call-site.
|
|
// This uses the `llvm.load.relative` intrinsic (
|
|
// https://llvm.org/docs/LangRef.html#llvm-load-relative-intrinsic ) that
|
|
// essentially does the arithmetic in one-shot: ptr + *(ptr + offset)
|
|
virtual_fn = context.builder().CreateCall(
|
|
llvm::Intrinsic::getOrInsertDeclaration(
|
|
&context.llvm_module(), llvm::Intrinsic::load_relative, {i32_type}),
|
|
{vtable,
|
|
llvm::ConstantInt::get(
|
|
i32_type, static_cast<uint64_t>(function.virtual_index) * 4)});
|
|
}
|
|
return context.builder().CreateCall(function_info.type, virtual_fn, args);
|
|
}
|
|
|
|
auto HandleInst(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);
|
|
|
|
// TODO: This duplicates the SpecificId handling in `GetCallee`.
|
|
|
|
// TODO: Should the `bound_method` be removed when forming the `call`
|
|
// instruction? The `self` parameter is transferred into the call argument
|
|
// list.
|
|
FunctionContext::InstInFile callee = {.file = &context.sem_ir(),
|
|
.inst_id = inst.callee_id};
|
|
if (auto bound_method = context.sem_ir().insts().TryGetAs<SemIR::BoundMethod>(
|
|
callee.inst_id)) {
|
|
callee.inst_id = bound_method->function_decl_id;
|
|
}
|
|
|
|
// Find the callee that the call instruction was type-checked against. This
|
|
// determines the meaning of the `arg_ids`.
|
|
auto inst_callee_function =
|
|
SemIR::GetCalleeAsFunction(*callee.file, callee.inst_id);
|
|
|
|
// Map to the callee in the specific. This might be in a different file than
|
|
// the one we're currently lowering.
|
|
if (context.specific_id().has_value()) {
|
|
auto [const_file, const_id] = GetConstantValueInSpecific(
|
|
context.specific_sem_ir(), context.specific_id(), context.sem_ir(),
|
|
callee.inst_id);
|
|
callee.file = const_file;
|
|
callee.inst_id = const_file->constant_values().GetInstIdIfValid(const_id);
|
|
CARBON_CHECK(callee.inst_id.has_value());
|
|
}
|
|
|
|
auto callee_function =
|
|
SemIR::GetCalleeAsFunction(*callee.file, callee.inst_id);
|
|
|
|
const SemIR::Function& function =
|
|
callee.file->functions().Get(callee_function.function_id);
|
|
context.AddCallToCurrentFingerprint(callee.file->check_ir_id(),
|
|
callee_function.function_id,
|
|
callee_function.resolved_specific_id);
|
|
|
|
if (auto builtin_kind = function.builtin_function_kind();
|
|
builtin_kind != SemIR::BuiltinFunctionKind::None) {
|
|
HandleBuiltinCall(context, inst_id, builtin_kind, arg_ids);
|
|
return;
|
|
}
|
|
|
|
// Get the function info for the callee. If the callee has incomplete types,
|
|
// fall back to using the information from the call instruction.
|
|
const auto& function_info =
|
|
context.GetFileContext(callee.file)
|
|
.GetOrCreateFunctionInfo(callee_function.function_id,
|
|
callee_function.resolved_specific_id,
|
|
&context.GetFileContext(&context.sem_ir()),
|
|
inst_callee_function.function_id,
|
|
inst_callee_function.resolved_specific_id);
|
|
CARBON_CHECK(!function_info->inexact,
|
|
"Attempting to emit call to inexact function: {0}",
|
|
*function_info->llvm_function);
|
|
|
|
// Lower args in the LLVM parameter order, rather than the SemIR parameter
|
|
// order.
|
|
std::vector<llvm::Value*> args;
|
|
for (auto index : function_info->lowered_param_indices) {
|
|
args.push_back(context.GetValue(arg_ids[index.index]));
|
|
}
|
|
|
|
llvm::CallInst* call;
|
|
if (function.virtual_index == -1) {
|
|
auto* llvm_callee = function_info->llvm_function;
|
|
auto describe_call = [&] {
|
|
RawStringOstream out;
|
|
out << "call ";
|
|
llvm_callee->printAsOperand(out);
|
|
out << "(";
|
|
llvm::ListSeparator sep;
|
|
for (auto* arg : args) {
|
|
out << sep;
|
|
arg->printAsOperand(out);
|
|
}
|
|
out << ")\n";
|
|
llvm_callee->print(out);
|
|
return out.TakeStr();
|
|
};
|
|
CARBON_CHECK(llvm_callee->arg_size() == args.size(),
|
|
"Argument count mismatch: {0}", describe_call());
|
|
call = context.builder().CreateCall(llvm_callee, args);
|
|
} else {
|
|
call = HandleVirtualCall(context, args, function, *function_info);
|
|
}
|
|
|
|
context.SetLocal(inst_id, call);
|
|
}
|
|
|
|
} // namespace Carbon::Lower
|