mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 19:20:13 +01:00
Chandler Carruth
d010d52f37
As part of this, move functions that seem reasonable to make out-of-line to a separate `_impl.h` header file that is only included where the explicit instantiation _definition_ is provided. By using explicit instantiation we can make these templates behave more like non-template classes in terms of supporting out-of-line definitions that don't need to be compiled by every translation unit. The set of eventual instantiations here is fundamentally known, and there tend to be headers that define a canonical "leaf" type where it makes sense to trigger the explicit instantiation. Where we already had a `.cpp` file to put the explicit instantiation definition, use it. But in some places we didn't have such a `.cpp` file so this PR adds those. This also requires that we have precise constraints on APIs that _can't_ be instantiated for specific argument types, as now we don't do this lazily. Combined, this appears to reduce the sum of object file sizes in the `check` directory by almost 40% (122mb -> 74mb) in my measurement. My actual goal was to improve compile times, but so far I don't have a great methodology for measuring these... But the object file size reduction seems to confirm this is a net win and likely represents a non-trivial improvement in compile time. Assisted-by: Antigravity with Gemini
89 lines
3.4 KiB
C++
89 lines
3.4 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
|
|
|
|
#ifndef CARBON_TOOLCHAIN_BASE_BLOCK_VALUE_STORE_IMPL_H_
|
|
#define CARBON_TOOLCHAIN_BASE_BLOCK_VALUE_STORE_IMPL_H_
|
|
|
|
#include "toolchain/base/block_value_store.h"
|
|
|
|
namespace Carbon {
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
BlockValueStore<IdT, ElementT, TagIdT>::BlockValueStore(
|
|
llvm::BumpPtrAllocator& allocator, IdTagType::TagIdType tag_id,
|
|
int32_t initial_reserved_ids)
|
|
requires(!IdTagIsUntagged<IdTagType>)
|
|
: allocator_(&allocator), values_(tag_id, initial_reserved_ids) {
|
|
if constexpr (requires { IdT::Empty; }) {
|
|
auto empty = RefType();
|
|
auto empty_val = canonical_blocks_.Insert(
|
|
empty, [&] { return values_.Add(empty); }, KeyContext(this));
|
|
CARBON_CHECK(empty_val.key() == IdT::Empty);
|
|
}
|
|
}
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
BlockValueStore<IdT, ElementT, TagIdT>::~BlockValueStore() = default;
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
BlockValueStore<IdT, ElementT, TagIdT>::BlockValueStore(
|
|
BlockValueStore&&) noexcept = default;
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
auto BlockValueStore<IdT, ElementT, TagIdT>::operator=(
|
|
BlockValueStore&&) noexcept -> BlockValueStore& = default;
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
auto BlockValueStore<IdT, ElementT, TagIdT>::OutputYaml() const
|
|
-> Yaml::OutputMapping {
|
|
return Yaml::OutputMapping([&](Yaml::OutputMapping::Map map) {
|
|
for (auto [block_id, block] : values_.enumerate()) {
|
|
map.Add(PrintToString(block_id),
|
|
Yaml::OutputMapping([&](Yaml::OutputMapping::Map map) {
|
|
for (auto [i, elem_id] : llvm::enumerate(block)) {
|
|
if constexpr (requires(llvm::raw_ostream& out) {
|
|
out << elem_id;
|
|
}) {
|
|
map.Add(llvm::itostr(i), Yaml::OutputScalar(elem_id));
|
|
} else {
|
|
map.Add(llvm::itostr(i),
|
|
Yaml::OutputScalar("<unprintable>"));
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
});
|
|
}
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
auto BlockValueStore<IdT, ElementT, TagIdT>::CollectMemUsage(
|
|
MemUsage& mem_usage, llvm::StringRef label) const -> void {
|
|
mem_usage.Collect(MemUsage::ConcatLabel(label, "values_"), values_);
|
|
mem_usage.Collect(MemUsage::ConcatLabel(label, "canonical_blocks_"),
|
|
canonical_blocks_, KeyContext(this));
|
|
}
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
auto BlockValueStore<IdT, ElementT, TagIdT>::AllocateCopy(ConstRefType data)
|
|
-> RefType {
|
|
auto result = AllocateUninitialized(data.size());
|
|
std::uninitialized_copy(data.begin(), data.end(), result.begin());
|
|
return result;
|
|
}
|
|
|
|
template <typename IdT, typename ElementT, typename TagIdT>
|
|
auto BlockValueStore<IdT, ElementT, TagIdT>::AllocateUninitialized(size_t size)
|
|
-> RefType {
|
|
// We're not going to run a destructor, so ensure that's OK.
|
|
static_assert(std::is_trivially_destructible_v<ElementType>);
|
|
|
|
auto storage = static_cast<ElementType*>(
|
|
allocator_->Allocate(size * sizeof(ElementType), alignof(ElementType)));
|
|
return RefType(storage, size);
|
|
}
|
|
|
|
} // namespace Carbon
|
|
|
|
#endif // CARBON_TOOLCHAIN_BASE_BLOCK_VALUE_STORE_IMPL_H_
|