mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-18 03:10:29 +00:00
I'm trying to increase the distinction between BuiltinKind and
BuiltinFunctionKind. BuiltinKind is for instructions,
BuiltinFunctionKind is for function definitions. To get to this point,
I'm doing a few changes:
- BuiltinKind -> BuiltinInstKind
- builtin_kind.* -> builtin_inst_kind.*: filename consistency
- Builtin -> BuiltinInst: mainly for consistency with the above
- Builtin::builtin_kind -> BuiltinInst::builtin_inst_kind: somewhat
repetitive but seems like a consistent edit
- Function::builtin_kind -> Function::builtin_function_kind: seems a
useful distinction
I'm leaving alone things like (and mentioning in case there's a desire
for more renames):
- InstId::BuiltinError, InstId::ForBuiltin: these I think are more
apparent because they're directly associated with Inst.
- GetBuiltinICmpPredicate in lowering: maybe builtin function handling
should be in its own file, but these local names don't feel problematic
to me.
- GetBuiltinType, BuildBuiltinValueRepr, PerformBuiltinIntComparison:
similar to the above, names don't feel too problematic
204 lines
8.2 KiB
C++
204 lines
8.2 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/check/call.h"
|
|
#include "toolchain/check/context.h"
|
|
#include "toolchain/check/handle.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
auto HandleBoolLiteralFalse(Context& context, Parse::BoolLiteralFalseId node_id)
|
|
-> bool {
|
|
context.AddInstAndPush<SemIR::BoolLiteral>(
|
|
node_id,
|
|
{.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::BoolType),
|
|
.value = SemIR::BoolValue::False});
|
|
return true;
|
|
}
|
|
|
|
auto HandleBoolLiteralTrue(Context& context, Parse::BoolLiteralTrueId node_id)
|
|
-> bool {
|
|
context.AddInstAndPush<SemIR::BoolLiteral>(
|
|
node_id,
|
|
{.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::BoolType),
|
|
.value = SemIR::BoolValue::True});
|
|
return true;
|
|
}
|
|
|
|
// Forms an IntLiteral instruction with type `i32` for a given literal integer
|
|
// value, which is assumed to be unsigned.
|
|
static auto MakeI32Literal(Context& context, Parse::NodeId node_id,
|
|
IntId int_id) -> SemIR::InstId {
|
|
auto val = context.ints().Get(int_id);
|
|
if (val.getActiveBits() > 31) {
|
|
CARBON_DIAGNOSTIC(IntLiteralTooLargeForI32, Error,
|
|
"Integer literal with value {0} does not fit in i32.",
|
|
llvm::APSInt);
|
|
context.emitter().Emit(node_id, IntLiteralTooLargeForI32,
|
|
llvm::APSInt(val, /*isUnsigned=*/true));
|
|
return SemIR::InstId::BuiltinError;
|
|
}
|
|
// Literals are always represented as unsigned, so zero-extend if needed.
|
|
auto i32_val = val.zextOrTrunc(32);
|
|
return context.AddInst<SemIR::IntLiteral>(
|
|
node_id,
|
|
{.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::IntType),
|
|
.int_id = context.ints().Add(i32_val)});
|
|
}
|
|
|
|
auto HandleIntLiteral(Context& context, Parse::IntLiteralId node_id) -> bool {
|
|
// Convert the literal to i32.
|
|
// TODO: Form an integer literal value and a corresponding type here instead.
|
|
auto int_literal_id = MakeI32Literal(
|
|
context, node_id,
|
|
context.tokens().GetIntLiteral(context.parse_tree().node_token(node_id)));
|
|
context.node_stack().Push(node_id, int_literal_id);
|
|
return true;
|
|
}
|
|
|
|
auto HandleRealLiteral(Context& context, Parse::RealLiteralId node_id) -> bool {
|
|
// Convert the real literal to an llvm::APFloat and add it to the floats
|
|
// ValueStore. In the future this would use an arbitrary precision Rational
|
|
// type.
|
|
//
|
|
// TODO: Implement Carbon's actual implicit conversion rules for
|
|
// floating-point constants, as per the design
|
|
// docs/design/expressions/implicit_conversions.md
|
|
auto real_id =
|
|
context.tokens().GetRealLiteral(context.parse_tree().node_token(node_id));
|
|
auto real_value = context.sem_ir().reals().Get(real_id);
|
|
|
|
if (real_value.mantissa.getActiveBits() > 64) {
|
|
CARBON_DIAGNOSTIC(RealMantissaTooLargeForI64, Error,
|
|
"Real mantissa with value {0} does not fit in i64.",
|
|
llvm::APSInt);
|
|
context.emitter().Emit(node_id, RealMantissaTooLargeForI64,
|
|
llvm::APSInt(real_value.mantissa, true));
|
|
context.node_stack().Push(node_id, SemIR::InstId::BuiltinError);
|
|
return true;
|
|
}
|
|
|
|
if (real_value.exponent.getSignificantBits() > 64) {
|
|
CARBON_DIAGNOSTIC(RealExponentTooLargeForI64, Error,
|
|
"Real exponent with value {0} does not fit in i64.",
|
|
llvm::APSInt);
|
|
context.emitter().Emit(node_id, RealExponentTooLargeForI64,
|
|
llvm::APSInt(real_value.exponent, false));
|
|
context.node_stack().Push(node_id, SemIR::InstId::BuiltinError);
|
|
return true;
|
|
}
|
|
|
|
double double_val = real_value.mantissa.getZExtValue() *
|
|
std::pow((real_value.is_decimal ? 10 : 2),
|
|
real_value.exponent.getSExtValue());
|
|
|
|
auto float_id = context.sem_ir().floats().Add(llvm::APFloat(double_val));
|
|
context.AddInstAndPush<SemIR::FloatLiteral>(
|
|
node_id,
|
|
{.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::FloatType),
|
|
.float_id = float_id});
|
|
return true;
|
|
}
|
|
|
|
auto HandleStringLiteral(Context& context, Parse::StringLiteralId node_id)
|
|
-> bool {
|
|
context.AddInstAndPush<SemIR::StringLiteral>(
|
|
node_id,
|
|
{.type_id = context.GetBuiltinType(SemIR::BuiltinInstKind::StringType),
|
|
.string_literal_id = context.tokens().GetStringLiteralValue(
|
|
context.parse_tree().node_token(node_id))});
|
|
return true;
|
|
}
|
|
|
|
auto HandleBoolTypeLiteral(Context& context, Parse::BoolTypeLiteralId node_id)
|
|
-> bool {
|
|
auto fn_inst_id = context.LookupNameInCore(node_id, "Bool");
|
|
auto type_inst_id = PerformCall(context, node_id, fn_inst_id, {});
|
|
context.node_stack().Push(node_id, type_inst_id);
|
|
return true;
|
|
}
|
|
|
|
// Shared implementation for handling `iN` and `uN` literals.
|
|
static auto HandleIntOrUnsignedIntTypeLiteral(Context& context,
|
|
Parse::NodeId node_id,
|
|
SemIR::IntKind int_kind,
|
|
IntId size_id) -> bool {
|
|
if (!(context.ints().Get(size_id) & 3).isZero()) {
|
|
CARBON_DIAGNOSTIC(IntWidthNotMultipleOf8, Error,
|
|
"Bit width of integer type literal must be a multiple of "
|
|
"8. Use `Core.{0}({1})` instead.",
|
|
std::string, llvm::APSInt);
|
|
context.emitter().Emit(
|
|
node_id, IntWidthNotMultipleOf8, int_kind.is_signed() ? "Int" : "UInt",
|
|
llvm::APSInt(context.ints().Get(size_id), /*isUnsigned=*/true));
|
|
}
|
|
auto width_id = MakeI32Literal(context, node_id, size_id);
|
|
auto fn_inst_id = context.LookupNameInCore(
|
|
node_id, int_kind == SemIR::IntKind::Signed ? "Int" : "UInt");
|
|
auto type_inst_id = PerformCall(context, node_id, fn_inst_id, {width_id});
|
|
context.node_stack().Push(node_id, type_inst_id);
|
|
return true;
|
|
}
|
|
|
|
auto HandleIntTypeLiteral(Context& context, Parse::IntTypeLiteralId node_id)
|
|
-> bool {
|
|
auto tok_id = context.parse_tree().node_token(node_id);
|
|
auto size_id = context.tokens().GetTypeLiteralSize(tok_id);
|
|
// Special case: `i32` has a custom builtin for now.
|
|
// TODO: Remove this special case.
|
|
if (context.ints().Get(size_id) == 32) {
|
|
auto fn_inst_id = context.LookupNameInCore(node_id, "Int32");
|
|
auto type_inst_id = PerformCall(context, node_id, fn_inst_id, {});
|
|
context.node_stack().Push(node_id, type_inst_id);
|
|
return true;
|
|
}
|
|
return HandleIntOrUnsignedIntTypeLiteral(context, node_id,
|
|
SemIR::IntKind::Signed, size_id);
|
|
}
|
|
|
|
auto HandleUnsignedIntTypeLiteral(Context& context,
|
|
Parse::UnsignedIntTypeLiteralId node_id)
|
|
-> bool {
|
|
auto tok_id = context.parse_tree().node_token(node_id);
|
|
auto size_id = context.tokens().GetTypeLiteralSize(tok_id);
|
|
return HandleIntOrUnsignedIntTypeLiteral(context, node_id,
|
|
SemIR::IntKind::Unsigned, size_id);
|
|
}
|
|
|
|
auto HandleFloatTypeLiteral(Context& context, Parse::FloatTypeLiteralId node_id)
|
|
-> bool {
|
|
auto text =
|
|
context.tokens().GetTokenText(context.parse_tree().node_token(node_id));
|
|
if (text != "f64") {
|
|
return context.TODO(node_id, "Currently only f64 is allowed");
|
|
}
|
|
auto tok_id = context.parse_tree().node_token(node_id);
|
|
auto size_id = context.tokens().GetTypeLiteralSize(tok_id);
|
|
auto width_id = MakeI32Literal(context, node_id, size_id);
|
|
auto fn_inst_id = context.LookupNameInCore(node_id, "Float");
|
|
auto type_inst_id = PerformCall(context, node_id, fn_inst_id, {width_id});
|
|
context.node_stack().Push(node_id, type_inst_id);
|
|
return true;
|
|
}
|
|
|
|
auto HandleStringTypeLiteral(Context& context,
|
|
Parse::StringTypeLiteralId node_id) -> bool {
|
|
context.node_stack().Push(node_id, SemIR::InstId::BuiltinStringType);
|
|
return true;
|
|
}
|
|
|
|
auto HandleTypeTypeLiteral(Context& context, Parse::TypeTypeLiteralId node_id)
|
|
-> bool {
|
|
context.node_stack().Push(node_id, SemIR::InstId::BuiltinTypeType);
|
|
return true;
|
|
}
|
|
|
|
auto HandleAutoTypeLiteral(Context& context, Parse::AutoTypeLiteralId node_id)
|
|
-> bool {
|
|
return context.TODO(node_id, "HandleAutoTypeLiteral");
|
|
}
|
|
|
|
} // namespace Carbon::Check
|