Files
carbon-lang/toolchain/base/fixed_size_value_store.h
T
David BlaikieandRichard Smith 12fa65e53c Check for use of InstIds from the wrong SemIR::File (#5997)
Use the `CheckIRId` as a unique identifier for the scope of an `InstId`
- if an `InstId` is created within the scope of one `CheckIRId` it must
not be used in the scope of a different `CheckIRId`.

This is achieved without extra storage, but with false negatives for
large inputs.

When an `InstId` is created, the original index of the `Inst` is XORed
with a tag derived from the `CheckIRId` to produce the final `InstId`.
When the `InstId` is used, the expected tag is XORed with the `InstId`
to get back to the original index - if the tags don't match, the
resulting index will be corrupted, likely too large - resulting in an
out of bounds index CHECK-failure.

(the tag value is derived as such:
* take the CheckIRId
* left shift one bit (padding zero)
* left shift another bit (padding 1 - used to signify that the resulting
`InstId` has a tag combined into it)
* reverse the bits

In this way, the tag is unlikely to overlap with the index for small
test cases - making it possible to separate out the `CheckIRId` from the
index in these cases to provide more meaningful debugging/CHECK
messages, and more informative `SemIR` textual dumping that can now
include the `CheckIRId` along with the `Inst`'s index in the name of an
`inst`)

The test churn here is improved printing as tagged `InstId`s can now,
with best effort (more likely for small test cases where the `CheckIRId`
and the `Inst` index aren't at risk of overlapping from the high and low
bits), render the `CheckIRId` as part of the inst's name. Going from
`instNN` to `irMM.instNN`.

---------

Co-authored-by: Richard Smith <richard@metafoo.co.uk>
2025-10-02 23:07:36 +00:00

153 lines
5.1 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_FIXED_SIZE_VALUE_STORE_H_
#define CARBON_TOOLCHAIN_BASE_FIXED_SIZE_VALUE_STORE_H_
#include <concepts>
#include <type_traits>
#include "common/check.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator_range.h"
#include "toolchain/base/mem_usage.h"
#include "toolchain/base/value_store.h"
#include "toolchain/base/value_store_types.h"
namespace Carbon {
// A value store with a predetermined size.
template <typename IdT, typename ValueT>
class FixedSizeValueStore {
public:
using IdType = IdT;
using ValueType = ValueStoreTypes<ValueT>::ValueType;
using RefType = ValueStoreTypes<ValueT>::RefType;
using ConstRefType = ValueStoreTypes<ValueT>::ConstRefType;
// Makes a ValueStore of the specified size, but without initializing values.
// Entries must be set before reading.
static auto MakeForOverwriteWithExplicitSize(size_t size)
-> FixedSizeValueStore {
FixedSizeValueStore store;
store.values_.resize_for_overwrite(size);
return store;
}
// Makes a ValueStore of the same size as a source `ValueStoreT`, but without
// initializing values. Entries must be set before reading.
template <typename ValueStoreT>
requires std::same_as<IdT, typename ValueStoreT::IdType>
static auto MakeForOverwrite(const ValueStoreT& size_source)
-> FixedSizeValueStore {
FixedSizeValueStore store;
store.values_.resize_for_overwrite(size_source.size());
return store;
}
// Makes a ValueStore of the specified size, initialized to a default.
static auto MakeWithExplicitSize(IdTag tag, size_t size,
ConstRefType default_value)
-> FixedSizeValueStore {
FixedSizeValueStore store;
store.tag_ = tag;
store.values_.resize(size, default_value);
return store;
}
// Makes a ValueStore of the specified size, initialized to values returned
// from a callback. This allows initializing non-copyable values.
static auto MakeWithExplicitSizeFrom(
size_t size, llvm::function_ref<auto()->ValueT> callable)
-> FixedSizeValueStore {
FixedSizeValueStore store;
store.values_.reserve(size);
for (auto _ : llvm::seq(size)) {
store.values_.push_back(callable());
}
return store;
}
// Makes a ValueStore of the same size as a source `ValueStoreT`. This is
// the safest constructor to use, since it ensures everything's initialized to
// a default, and verifies a matching `IdT` for the size.
template <typename ValueStoreT>
requires std::same_as<IdT, typename ValueStoreT::IdType>
explicit FixedSizeValueStore(const ValueStoreT& size_source,
ConstRefType default_value)
: tag_(size_source.GetIdTag()) {
values_.resize(size_source.size(), default_value);
}
// Makes a ValueStore using a mapped range of `source`. The `factory_fn`
// receives each enumerated entry for construction of `ValueType`.
template <typename ValueStoreT>
requires std::same_as<IdT, typename ValueStoreT::IdType>
explicit FixedSizeValueStore(
const ValueStoreT& source,
llvm::function_ref<
auto(IdT, typename ValueStoreT::ConstRefType)->ValueType>
factory_fn)
: values_(llvm::map_range(source.enumerate(), factory_fn)),
tag_(GetIdTag(source)) {}
// Move-only.
FixedSizeValueStore(FixedSizeValueStore&&) noexcept = default;
auto operator=(FixedSizeValueStore&&) noexcept
-> FixedSizeValueStore& = default;
// Sets the value for an ID.
auto Set(IdT id, ValueType value) -> void {
auto index = tag_.Remove(id.index);
CARBON_DCHECK(index >= 0, "{0}", id);
values_[index] = value;
}
// Returns a mutable value for an ID.
auto Get(IdT id) -> RefType {
auto index = tag_.Remove(id.index);
CARBON_DCHECK(index >= 0, "{0}", id);
return values_[index];
}
// Returns the value for an ID.
auto Get(IdT id) const -> ConstRefType {
auto index = tag_.Remove(id.index);
CARBON_DCHECK(index >= 0, "{0}", id);
return values_[index];
}
// Collects memory usage of the values.
auto CollectMemUsage(MemUsage& mem_usage, llvm::StringRef label) const
-> void {
mem_usage.Collect(label.str(), values_);
}
auto size() const -> size_t { return values_.size(); }
auto values()
-> llvm::iterator_range<typename llvm::SmallVector<ValueT, 0>::iterator> {
return llvm::make_range(values_.begin(), values_.end());
}
auto values() const -> llvm::iterator_range<
typename llvm::SmallVector<ValueT, 0>::const_iterator> {
return llvm::make_range(values_.begin(), values_.end());
}
private:
// Allow default construction for `Make` functions.
FixedSizeValueStore() = default;
// Storage for the `ValueT` objects, indexed by the id.
llvm::SmallVector<ValueT, 0> values_;
IdTag tag_;
};
} // namespace Carbon
#endif // CARBON_TOOLCHAIN_BASE_FIXED_SIZE_VALUE_STORE_H_