mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-02 10:55:51 +01:00
Chandler Carruth
dd0890619a
Just spotted these while looking at warnings that seem to fire on our code are probably are things we'd fix if we saw them. None of these seem important FWIW. Also removes a redundant flag that is part of `-Wall`. I have a follow-up for the high-value warning I spotted that motivated me to look at all of this. But it's noisy so kept it as a separate PR.
105 lines
3.9 KiB
C++
105 lines
3.9 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_EXPLORER_INTERPRETER_HEAP_H_
|
|
#define CARBON_EXPLORER_INTERPRETER_HEAP_H_
|
|
|
|
#include <vector>
|
|
|
|
#include "common/ostream.h"
|
|
#include "explorer/ast/address.h"
|
|
#include "explorer/ast/value.h"
|
|
#include "explorer/ast/value_node.h"
|
|
#include "explorer/base/nonnull.h"
|
|
#include "explorer/base/source_location.h"
|
|
#include "explorer/base/trace_stream.h"
|
|
#include "explorer/interpreter/heap_allocation_interface.h"
|
|
|
|
namespace Carbon {
|
|
|
|
// A Heap represents the abstract machine's dynamically allocated memory.
|
|
class Heap : public HeapAllocationInterface, public Printable<Heap> {
|
|
public:
|
|
enum class ValueState {
|
|
Uninitialized,
|
|
Discarded,
|
|
Alive,
|
|
Dead,
|
|
};
|
|
|
|
// Constructs an empty Heap.
|
|
explicit Heap(Nonnull<TraceStream*> trace_stream, Nonnull<Arena*> arena)
|
|
: arena_(arena), trace_stream_(trace_stream) {}
|
|
|
|
Heap(const Heap&) = delete;
|
|
auto operator=(const Heap&) -> Heap& = delete;
|
|
|
|
// Returns the value at the given address in the heap after
|
|
// checking that it is alive.
|
|
auto Read(const Address& a, SourceLocation source_loc) const
|
|
-> ErrorOr<Nonnull<const Value*>> override;
|
|
|
|
// Writes the given value at the address in the heap after
|
|
// checking that the address is alive.
|
|
auto Write(const Address& a, Nonnull<const Value*> v,
|
|
SourceLocation source_loc) -> ErrorOr<Success> override;
|
|
|
|
// Returns whether the value bound at the given node is still alive.
|
|
auto is_bound_value_alive(const ValueNodeView& node, const Address& a) const
|
|
-> bool override;
|
|
|
|
void BindValueToReference(const ValueNodeView& node,
|
|
const Address& a) override;
|
|
|
|
// Put the given value on the heap and mark its state.
|
|
// Mark UninitializedValue as uninitialized and other values as alive.
|
|
auto AllocateValue(Nonnull<const Value*> v) -> AllocationId override;
|
|
|
|
// Marks this allocation, and all of its sub-objects, as dead.
|
|
auto Deallocate(AllocationId allocation) -> ErrorOr<Success> override;
|
|
auto Deallocate(const Address& a) -> ErrorOr<Success>;
|
|
|
|
// Marks this allocation, and all its sub-objects, as discarded.
|
|
void Discard(AllocationId allocation);
|
|
// Returns whether the given allocation was unused and discarded.
|
|
auto is_discarded(AllocationId allocation) const -> bool;
|
|
// Returns whether the given allocation was initialized.
|
|
auto is_initialized(AllocationId allocation) const -> bool;
|
|
|
|
// Print all the values on the heap to the stream `out`.
|
|
void Print(llvm::raw_ostream& out) const;
|
|
|
|
auto arena() const -> Arena& override { return *arena_; }
|
|
|
|
private:
|
|
// Returns whether the address have the same AllocationdId and their path
|
|
// are strictly nested.
|
|
static auto AddressesAreStrictlyNested(const Address& first,
|
|
const Address& second) -> bool;
|
|
|
|
// Returns whether the provided paths are strictly nested. This checks the
|
|
// name, index, and base element only, and might not valid if used to
|
|
// compare paths based on a different AllocationId.
|
|
static auto PathsAreStrictlyNested(const ElementPath& first,
|
|
const ElementPath& second) -> bool;
|
|
|
|
// Signal an error if the allocation is no longer alive.
|
|
auto CheckAlive(AllocationId allocation, SourceLocation source_loc) const
|
|
-> ErrorOr<Success>;
|
|
|
|
// Signal an error if the allocation has not been initialized.
|
|
auto CheckInit(AllocationId allocation, SourceLocation source_loc) const
|
|
-> ErrorOr<Success>;
|
|
|
|
Nonnull<Arena*> arena_;
|
|
std::vector<Nonnull<const Value*>> values_;
|
|
std::vector<ValueState> states_;
|
|
std::vector<llvm::DenseMap<const AstNode*, Address>> bound_values_;
|
|
Nonnull<TraceStream*> trace_stream_;
|
|
};
|
|
|
|
} // namespace Carbon
|
|
|
|
#endif // CARBON_EXPLORER_INTERPRETER_HEAP_H_
|