chromium/v8/src/compiler/wasm-graph-assembler.cc

// Copyright 2022 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/wasm-graph-assembler.h"

#include "src/common/globals.h"
#include "src/compiler/access-builder.h"
#include "src/compiler/diamond.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/wasm-compiler-definitions.h"
#include "src/objects/string.h"
#include "src/wasm/object-access.h"
#include "src/wasm/wasm-objects.h"

namespace v8::internal::compiler {

// static
CallDescriptor* GetBuiltinCallDescriptor(Builtin name, Zone* zone,
                                         StubCallMode stub_mode,
                                         bool needs_frame_state,
                                         Operator::Properties properties) { … }

// static
ObjectAccess ObjectAccessForGCStores(wasm::ValueType type) { … }

// Sets {true_node} and {false_node} to their corresponding Branch outputs.
// Returns the Branch node. Does not change control().
Node* WasmGraphAssembler::Branch(Node* cond, Node** true_node,
                                 Node** false_node, BranchHint hint) { … }

Node* WasmGraphAssembler::BuildTruncateIntPtrToInt32(Node* value) { … }

Node* WasmGraphAssembler::BuildChangeInt32ToIntPtr(Node* value) { … }

Node* WasmGraphAssembler::BuildChangeIntPtrToInt64(Node* value) { … }

Node* WasmGraphAssembler::BuildChangeUint32ToUintPtr(Node* node) { … }

Node* WasmGraphAssembler::BuildSmiShiftBitsConstant() { … }

Node* WasmGraphAssembler::BuildSmiShiftBitsConstant32() { … }

Node* WasmGraphAssembler::BuildChangeInt32ToSmi(Node* value) { … }

Node* WasmGraphAssembler::BuildChangeUint31ToSmi(Node* value) { … }

Node* WasmGraphAssembler::BuildChangeSmiToInt32(Node* value) { … }

Node* WasmGraphAssembler::BuildConvertUint32ToSmiWithSaturation(
    Node* value, uint32_t maxval) { … }

Node* WasmGraphAssembler::BuildChangeSmiToIntPtr(Node* value) { … }

// Helper functions for dealing with HeapObjects.
// Rule of thumb: if access to a given field in an object is required in
// at least two places, put a helper function here.

Node* WasmGraphAssembler::Allocate(int size) { … }

Node* WasmGraphAssembler::Allocate(Node* size) { … }

Node* WasmGraphAssembler::LoadFromObject(MachineType type, Node* base,
                                         Node* offset) { … }

Node* WasmGraphAssembler::LoadProtectedPointerFromObject(Node* object,
                                                         Node* offset) { … }

Node* WasmGraphAssembler::LoadImmutableProtectedPointerFromObject(
    Node* object, Node* offset) { … }

Node* WasmGraphAssembler::LoadImmutableFromObject(MachineType type, Node* base,
                                                  Node* offset) { … }

Node* WasmGraphAssembler::LoadImmutable(LoadRepresentation rep, Node* base,
                                        Node* offset) { … }

Node* WasmGraphAssembler::StoreToObject(ObjectAccess access, Node* base,
                                        Node* offset, Node* value) { … }

Node* WasmGraphAssembler::InitializeImmutableInObject(ObjectAccess access,
                                                      Node* base, Node* offset,
                                                      Node* value) { … }

Node* WasmGraphAssembler::BuildDecodeSandboxedExternalPointer(
    Node* handle, ExternalPointerTag tag, Node* isolate_root) { … }

Node* WasmGraphAssembler::BuildDecodeTrustedPointer(Node* handle,
                                                    IndirectPointerTag tag) { … }

Node* WasmGraphAssembler::BuildLoadExternalPointerFromObject(
    Node* object, int field_offset, ExternalPointerTag tag,
    Node* isolate_root) { … }

Node* WasmGraphAssembler::IsSmi(Node* object) { … }

// Maps and their contents.
Node* WasmGraphAssembler::LoadMap(Node* object) { … }

void WasmGraphAssembler::StoreMap(Node* heap_object, Node* map) { … }

Node* WasmGraphAssembler::LoadInstanceType(Node* map) { … }
Node* WasmGraphAssembler::LoadWasmTypeInfo(Node* map) { … }

// FixedArrays.

Node* WasmGraphAssembler::LoadFixedArrayLengthAsSmi(Node* fixed_array) { … }

Node* WasmGraphAssembler::LoadFixedArrayElement(Node* fixed_array,
                                                Node* index_intptr,
                                                MachineType type) { … }

Node* WasmGraphAssembler::LoadWeakArrayListElement(Node* fixed_array,
                                                   Node* index_intptr,
                                                   MachineType type) { … }

Node* WasmGraphAssembler::LoadImmutableFixedArrayElement(Node* fixed_array,
                                                         Node* index_intptr,
                                                         MachineType type) { … }

Node* WasmGraphAssembler::LoadFixedArrayElement(Node* array, int index,
                                                MachineType type) { … }

Node* WasmGraphAssembler::LoadProtectedFixedArrayElement(Node* array,
                                                         int index) { … }

Node* WasmGraphAssembler::LoadProtectedFixedArrayElement(Node* array,
                                                         Node* index_intptr) { … }

Node* WasmGraphAssembler::LoadByteArrayElement(Node* byte_array,
                                               Node* index_intptr,
                                               MachineType type) { … }

Node* WasmGraphAssembler::LoadImmutableTrustedPointerFromObject(
    Node* object, int field_offset, IndirectPointerTag tag) { … }

Node* WasmGraphAssembler::LoadTrustedPointerFromObject(Node* object,
                                                       int field_offset,
                                                       IndirectPointerTag tag) { … }

std::pair<Node*, Node*>
WasmGraphAssembler::LoadTrustedPointerFromObjectTrapOnNull(
    Node* object, int field_offset, IndirectPointerTag tag) { … }

Node* WasmGraphAssembler::StoreFixedArrayElement(Node* array, int index,
                                                 Node* value,
                                                 ObjectAccess access) { … }

// Functions, SharedFunctionInfos, FunctionData.

Node* WasmGraphAssembler::LoadSharedFunctionInfo(Node* js_function) { … }
Node* WasmGraphAssembler::LoadContextFromJSFunction(Node* js_function) { … }

Node* WasmGraphAssembler::LoadFunctionDataFromJSFunction(Node* js_function) { … }

Node* WasmGraphAssembler::LoadExportedFunctionIndexAsSmi(
    Node* exported_function_data) { … }
Node* WasmGraphAssembler::LoadExportedFunctionInstanceData(
    Node* exported_function_data) { … }

// JavaScript objects.

Node* WasmGraphAssembler::LoadJSArrayElements(Node* js_array) { … }

// WasmGC objects.

Node* WasmGraphAssembler::FieldOffset(const wasm::StructType* type,
                                      uint32_t field_index) { … }

Node* WasmGraphAssembler::WasmArrayElementOffset(Node* index,
                                                 wasm::ValueType element_type) { … }

Node* WasmGraphAssembler::IsDataRefMap(Node* map) { … }

Node* WasmGraphAssembler::WasmTypeCheck(Node* object, Node* rtt,
                                        WasmTypeCheckConfig config) { … }

Node* WasmGraphAssembler::WasmTypeCheckAbstract(Node* object,
                                                WasmTypeCheckConfig config) { … }

Node* WasmGraphAssembler::WasmTypeCast(Node* object, Node* rtt,
                                       WasmTypeCheckConfig config) { … }

Node* WasmGraphAssembler::WasmTypeCastAbstract(Node* object,
                                               WasmTypeCheckConfig config) { … }

Node* WasmGraphAssembler::Null(wasm::ValueType type) { … }

Node* WasmGraphAssembler::IsNull(Node* object, wasm::ValueType type) { … }

Node* WasmGraphAssembler::IsNotNull(Node* object, wasm::ValueType type) { … }

Node* WasmGraphAssembler::AssertNotNull(Node* object, wasm::ValueType type,
                                        TrapId trap_id) { … }

Node* WasmGraphAssembler::WasmAnyConvertExtern(Node* object) { … }

Node* WasmGraphAssembler::WasmExternConvertAny(Node* object) { … }

Node* WasmGraphAssembler::StructGet(Node* object, const wasm::StructType* type,
                                    int field_index, bool is_signed,
                                    CheckForNull null_check) { … }

void WasmGraphAssembler::StructSet(Node* object, Node* value,
                                   const wasm::StructType* type,
                                   int field_index, CheckForNull null_check) { … }

Node* WasmGraphAssembler::ArrayGet(Node* array, Node* index,
                                   const wasm::ArrayType* type,
                                   bool is_signed) { … }

void WasmGraphAssembler::ArraySet(Node* array, Node* index, Node* value,
                                  const wasm::ArrayType* type) { … }

Node* WasmGraphAssembler::ArrayLength(Node* array, CheckForNull null_check) { … }

void WasmGraphAssembler::ArrayInitializeLength(Node* array, Node* length) { … }

Node* WasmGraphAssembler::LoadStringLength(Node* string) { … }

Node* WasmGraphAssembler::StringAsWtf16(Node* string) { … }

Node* WasmGraphAssembler::StringPrepareForGetCodeunit(Node* string) { … }

Node* WasmGraphAssembler::LoadTrustedDataFromInstanceObject(
    Node* instance_object) { … }

// Generic HeapObject helpers.

Node* WasmGraphAssembler::HasInstanceType(Node* heap_object,
                                          InstanceType type) { … }

}  // namespace v8::internal::compiler