memory-lowering.cc | Explore in Territory

// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/compiler/memory-lowering.h"

#include "src/codegen/interface-descriptors-inl.h"
#include "src/common/globals.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/linkage.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/node-properties.h"
#include "src/compiler/node.h"
#include "src/compiler/simplified-operator.h"
#include "src/roots/roots-inl.h"
#include "src/sandbox/external-pointer-inl.h"

#if V8_ENABLE_WEBASSEMBLY
#include "src/wasm/wasm-linkage.h"
#include "src/wasm/wasm-objects.h"
#endif
namespace v8 {
namespace internal {
namespace compiler {

// An allocation group represents a set of allocations that have been folded
// together.
class MemoryLowering::AllocationGroup final : public ZoneObject { … };

MemoryLowering::MemoryLowering(JSGraph* jsgraph, Zone* zone,
                               JSGraphAssembler* graph_assembler, bool is_wasm,
                               AllocationFolding allocation_folding,
                               WriteBarrierAssertFailedCallback callback,
                               const char* function_debug_name)
    : … { … }

Zone* MemoryLowering::graph_zone() const { … }

Reduction MemoryLowering::Reduce(Node* node) { … }

void MemoryLowering::EnsureAllocateOperator() { … }

#if V8_ENABLE_WEBASSEMBLY
Node* MemoryLowering::GetWasmInstanceNode() { … }
#endif  // V8_ENABLE_WEBASSEMBLY

#define __ …

Node* MemoryLowering::AlignToAllocationAlignment(Node* value) { … }

Reduction MemoryLowering::ReduceAllocateRaw(Node* node,
                                            AllocationType allocation_type,
                                            AllocationState const** state_ptr) { … }

Reduction MemoryLowering::ReduceLoadFromObject(Node* node) { … }

Reduction MemoryLowering::ReduceLoadElement(Node* node) { … }

Reduction MemoryLowering::ReduceLoadExternalPointerField(Node* node) { … }

Reduction MemoryLowering::ReduceLoadBoundedSize(Node* node) { … }

Reduction MemoryLowering::ReduceLoadMap(Node* node) { … }

Reduction MemoryLowering::ReduceLoadField(Node* node) { … }

Reduction MemoryLowering::ReduceStoreToObject(Node* node,
                                              AllocationState const* state) { … }

Reduction MemoryLowering::ReduceStoreElement(Node* node,
                                             AllocationState const* state) { … }

Reduction MemoryLowering::ReduceStoreField(Node* node,
                                           AllocationState const* state) { … }

Reduction MemoryLowering::ReduceStore(Node* node,
                                      AllocationState const* state) { … }

Node* MemoryLowering::ComputeIndex(ElementAccess const& access, Node* index) { … }

#undef __

namespace {

bool ValueNeedsWriteBarrier(Node* value, Isolate* isolate) { … }

}  // namespace

Reduction MemoryLowering::ReduceAllocateRaw(Node* node) { … }

WriteBarrierKind MemoryLowering::ComputeWriteBarrierKind(
    Node* node, Node* object, Node* value, AllocationState const* state,
    WriteBarrierKind write_barrier_kind) { … }

MemoryLowering::AllocationGroup::AllocationGroup(Node* node,
                                                 AllocationType allocation,
                                                 Zone* zone)
    : … { … }

MemoryLowering::AllocationGroup::AllocationGroup(Node* node,
                                                 AllocationType allocation,
                                                 Node* size, Zone* zone)
    : … { … }

void MemoryLowering::AllocationGroup::Add(Node* node) { … }

bool MemoryLowering::AllocationGroup::Contains(Node* node) const { … }

MemoryLowering::AllocationState::AllocationState()
    : … { … }

MemoryLowering::AllocationState::AllocationState(AllocationGroup* group,
                                                 Node* effect)
    : … { … }

MemoryLowering::AllocationState::AllocationState(AllocationGroup* group,
                                                 intptr_t size, Node* top,
                                                 Node* effect)
    : … { … }

bool MemoryLowering::AllocationState::IsYoungGenerationAllocation() const { … }

}  // namespace compiler
}  // namespace internal
}  // namespace v8
chromium/v8/src/compiler/memory-lowering.cc
