mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-25 11:40:10 +01:00
Richard Smith
29c294880d
Rather than producing multiple constants with the same value, fold all instances of a given constant to the same constant instruction. A future PR will use this to replace the current type canonicalization system.
119 lines
4.5 KiB
C++
119 lines
4.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/sem_ir/inst_profile.h"
|
|
|
|
#include "toolchain/sem_ir/file.h"
|
|
#include "toolchain/sem_ir/inst.h"
|
|
#include "toolchain/sem_ir/typed_insts.h"
|
|
|
|
namespace Carbon::SemIR {
|
|
|
|
// A function to profile an argument of an instruction.
|
|
using ProfileArgFunction = auto(llvm::FoldingSetNodeID&, const File& sem_ir,
|
|
int32_t arg) -> void;
|
|
|
|
// Profiling for unused arguments.
|
|
static auto NullProfileArgFunction(llvm::FoldingSetNodeID& /*id*/,
|
|
const File& /*sem_ir*/, int32_t arg)
|
|
-> void {
|
|
CARBON_CHECK(arg == IdBase::InvalidIndex)
|
|
<< "Unexpected value for unused argument.";
|
|
}
|
|
|
|
// Profiling for ID arguments that should participate in the instruction's
|
|
// value.
|
|
static auto DefaultProfileArgFunction(llvm::FoldingSetNodeID& id,
|
|
const File& /*sem_ir*/, int32_t arg)
|
|
-> void {
|
|
id.AddInteger(arg);
|
|
}
|
|
|
|
// Profiling for block ID arguments for which the content of the block should be
|
|
// included.
|
|
static auto InstBlockProfileArgFunction(llvm::FoldingSetNodeID& id,
|
|
const File& sem_ir, int32_t arg)
|
|
-> void {
|
|
for (auto inst_id : sem_ir.inst_blocks().Get(InstBlockId(arg))) {
|
|
id.AddInteger(inst_id.index);
|
|
}
|
|
}
|
|
|
|
// Profiling for type block ID arguments for which the content of the block
|
|
// should be included.
|
|
static auto TypeBlockProfileArgFunction(llvm::FoldingSetNodeID& id,
|
|
const File& sem_ir, int32_t arg)
|
|
-> void {
|
|
for (auto type_id : sem_ir.type_blocks().Get(TypeBlockId(arg))) {
|
|
id.AddInteger(type_id.index);
|
|
}
|
|
}
|
|
|
|
// Profiling for integer IDs.
|
|
static auto IntProfileArgFunction(llvm::FoldingSetNodeID& id,
|
|
const File& sem_ir, int32_t arg) -> void {
|
|
sem_ir.ints().Get(IntId(arg)).Profile(id);
|
|
}
|
|
|
|
// Profiling for real number IDs.
|
|
static auto RealProfileArgFunction(llvm::FoldingSetNodeID& id,
|
|
const File& sem_ir, int32_t arg) -> void {
|
|
const auto& real = sem_ir.reals().Get(RealId(arg));
|
|
// TODO: Profile the value rather than the syntactic form.
|
|
real.mantissa.Profile(id);
|
|
real.exponent.Profile(id);
|
|
id.AddBoolean(real.is_decimal);
|
|
}
|
|
|
|
// Selects the function to use to profile argument N of instruction InstT. We
|
|
// compute this in advance so that we can reuse the profiling code for all
|
|
// instructions that are profiled in the same way. For example, all instructions
|
|
// that take two IDs that are profiled by value use the same profiling code,
|
|
// namely `ProfileArgs<DefaultProfileArgFunction, DefaultProfileArgFunction>`.
|
|
template <typename InstT, int N>
|
|
static constexpr auto SelectProfileArgFunction() -> ProfileArgFunction* {
|
|
if constexpr (N >= InstLikeTypeInfo<InstT>::NumArgs) {
|
|
// This argument is not used by this instruction; don't profile it.
|
|
return NullProfileArgFunction;
|
|
} else {
|
|
using ArgT = typename InstLikeTypeInfo<InstT>::template ArgType<N>;
|
|
if constexpr (std::is_same_v<ArgT, InstBlockId>) {
|
|
return InstBlockProfileArgFunction;
|
|
} else if constexpr (std::is_same_v<ArgT, TypeBlockId>) {
|
|
return TypeBlockProfileArgFunction;
|
|
} else if constexpr (std::is_same_v<ArgT, IntId>) {
|
|
return IntProfileArgFunction;
|
|
} else if constexpr (std::is_same_v<ArgT, RealId>) {
|
|
return RealProfileArgFunction;
|
|
} else {
|
|
return DefaultProfileArgFunction;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Profiles the given instruction arguments using the specified functions.
|
|
template <ProfileArgFunction* ProfileArg0, ProfileArgFunction* ProfileArg1>
|
|
static auto ProfileArgs(llvm::FoldingSetNodeID& id, const File& sem_ir,
|
|
int32_t arg0, int32_t arg1) -> void {
|
|
ProfileArg0(id, sem_ir, arg0);
|
|
ProfileArg1(id, sem_ir, arg1);
|
|
}
|
|
|
|
auto ProfileConstant(llvm::FoldingSetNodeID& id, const File& sem_ir, Inst inst)
|
|
-> void {
|
|
using ProfileArgsFunction =
|
|
auto(llvm::FoldingSetNodeID&, const File&, int32_t, int32_t)->void;
|
|
static constexpr ProfileArgsFunction* ProfileFunctions[] = {
|
|
#define CARBON_SEM_IR_INST_KIND(KindName) \
|
|
ProfileArgs<SelectProfileArgFunction<KindName, 0>(), \
|
|
SelectProfileArgFunction<KindName, 1>()>,
|
|
#include "toolchain/sem_ir/inst_kind.def"
|
|
};
|
|
|
|
inst.kind().Profile(id);
|
|
ProfileFunctions[inst.kind().AsInt()](id, sem_ir, inst.arg0(), inst.arg1());
|
|
}
|
|
|
|
} // namespace Carbon::SemIR
|