chromium/v8/src/objects/string.cc

// 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/objects/string.h"

#include "src/base/small-vector.h"
#include "src/common/assert-scope.h"
#include "src/common/globals.h"
#include "src/execution/isolate-utils.h"
#include "src/execution/thread-id.h"
#include "src/handles/handles-inl.h"
#include "src/heap/heap-inl.h"
#include "src/heap/local-factory-inl.h"
#include "src/heap/local-heap-inl.h"
#include "src/heap/mutable-page-metadata.h"
#include "src/heap/read-only-heap.h"
#include "src/numbers/conversions.h"
#include "src/objects/instance-type.h"
#include "src/objects/map.h"
#include "src/objects/oddball.h"
#include "src/objects/string-comparator.h"
#include "src/objects/string-inl.h"
#include "src/strings/char-predicates.h"
#include "src/strings/string-builder-inl.h"
#include "src/strings/string-hasher.h"
#include "src/strings/string-search.h"
#include "src/strings/string-stream.h"
#include "src/strings/unicode-inl.h"
#include "src/utils/ostreams.h"

namespace v8 {
namespace internal {

Handle<String> String::SlowFlatten(Isolate* isolate, Handle<ConsString> cons,
                                   AllocationType allocation) { … }

Handle<String> String::SlowShare(Isolate* isolate, Handle<String> source) { … }

namespace {

template <class StringClass>
void MigrateExternalStringResource(Isolate* isolate,
                                   Tagged<ExternalString> from,
                                   Tagged<StringClass> to) { … }

void MigrateExternalString(Isolate* isolate, Tagged<String> string,
                           Tagged<String> internalized) { … }

}  // namespace

void ExternalString::InitExternalPointerFieldsDuringExternalization(
    Tagged<Map> new_map, Isolate* isolate) { … }

template <typename IsolateT>
void String::MakeThin(IsolateT* isolate, Tagged<String> internalized) { … }

template EXPORT_TEMPLATE_DEFINE(…) void String::MakeThin(
    Isolate* isolate, Tagged<String> internalized);
template EXPORT_TEMPLATE_DEFINE(…) void String::MakeThin(
    LocalIsolate* isolate, Tagged<String> internalized);

template <typename T>
bool String::MarkForExternalizationDuringGC(Isolate* isolate, T* resource) { … }

namespace {

template <bool is_one_byte>
Tagged<Map> ComputeExternalStringMap(Isolate* isolate, Tagged<String> string,
                                     int size) { … }

}  // namespace

template <typename T>
void String::MakeExternalDuringGC(Isolate* isolate, T* resource) { … }

template EXPORT_TEMPLATE_DEFINE(…) void String::
    MakeExternalDuringGC(Isolate* isolate,
                         v8::String::ExternalOneByteStringResource*);
template EXPORT_TEMPLATE_DEFINE(…) void String::
    MakeExternalDuringGC(Isolate* isolate, v8::String::ExternalStringResource*);

bool String::MakeExternal(v8::String::ExternalStringResource* resource) { … }

bool String::MakeExternal(v8::String::ExternalOneByteStringResource* resource) { … }

bool String::SupportsExternalization(v8::String::Encoding encoding) { … }

const char* String::PrefixForDebugPrint() const { … }

const char* String::SuffixForDebugPrint() const { … }

void String::StringShortPrint(StringStream* accumulator) { … }

void String::PrintUC16(std::ostream& os, int start, int end) { … }

void String::PrintUC16(StringStream* accumulator, int start, int end) { … }

int32_t String::ToArrayIndex(Address addr) { … }

bool String::LooksValid() { … }

// static
Handle<Number> String::ToNumber(Isolate* isolate, Handle<String> subject) { … }

String::FlatContent String::SlowGetFlatContent(
    const DisallowGarbageCollection& no_gc,
    const SharedStringAccessGuardIfNeeded& access_guard) { … }

std::unique_ptr<char[]> String::ToCString(AllowNullsFlag allow_nulls,
                                          RobustnessFlag robust_flag,
                                          int offset, int length,
                                          int* length_return) { … }

std::unique_ptr<char[]> String::ToCString(AllowNullsFlag allow_nulls,
                                          RobustnessFlag robust_flag,
                                          int* length_return) { … }

// static
template <typename sinkchar>
void String::WriteToFlat(Tagged<String> source, sinkchar* sink, int start,
                         int length) { … }

// static
template <typename sinkchar>
void String::WriteToFlat(Tagged<String> source, sinkchar* sink, int start,
                         int length,
                         const SharedStringAccessGuardIfNeeded& access_guard) { … }

template <typename SourceChar>
static void CalculateLineEndsImpl(String::LineEndsVector* line_ends,
                                  base::Vector<const SourceChar> src,
                                  bool include_ending_line) { … }

template <typename IsolateT>
String::LineEndsVector String::CalculateLineEndsVector(
    IsolateT* isolate, Handle<String> src, bool include_ending_line) { … }

template String::LineEndsVector String::CalculateLineEndsVector(
    Isolate* isolate, Handle<String> src, bool include_ending_line);
template String::LineEndsVector String::CalculateLineEndsVector(
    LocalIsolate* isolate, Handle<String> src, bool include_ending_line);

template <typename IsolateT>
Handle<FixedArray> String::CalculateLineEnds(IsolateT* isolate,
                                             Handle<String> src,
                                             bool include_ending_line) { … }

template Handle<FixedArray> String::CalculateLineEnds(Isolate* isolate,
                                                      Handle<String> src,
                                                      bool include_ending_line);
template Handle<FixedArray> String::CalculateLineEnds(LocalIsolate* isolate,
                                                      Handle<String> src,
                                                      bool include_ending_line);

bool String::SlowEquals(Tagged<String> other) const { … }

bool String::SlowEquals(
    Tagged<String> other,
    const SharedStringAccessGuardIfNeeded& access_guard) const { … }

// static
bool String::SlowEquals(Isolate* isolate, Handle<String> one,
                        Handle<String> two) { … }

// static
ComparisonResult String::Compare(Isolate* isolate, Handle<String> x,
                                 Handle<String> y) { … }

namespace {

uint32_t ToValidIndex(Tagged<String> str, Tagged<Object> number) { … }

}  // namespace

Tagged<Object> String::IndexOf(Isolate* isolate, Handle<Object> receiver,
                               Handle<Object> search, Handle<Object> position) { … }

namespace {

template <typename T>
int SearchString(Isolate* isolate, String::FlatContent receiver_content,
                 base::Vector<T> pat_vector, int start_index) { … }

}  // namespace

int String::IndexOf(Isolate* isolate, Handle<String> receiver,
                    Handle<String> search, int start_index) { … }

MaybeHandle<String> String::GetSubstitution(Isolate* isolate, Match* match,
                                            Handle<String> replacement,
                                            int start_index) { … }

namespace {  // for String.Prototype.lastIndexOf

template <typename schar, typename pchar>
int StringMatchBackwards(base::Vector<const schar> subject,
                         base::Vector<const pchar> pattern, int idx) { … }

}  // namespace

Tagged<Object> String::LastIndexOf(Isolate* isolate, Handle<Object> receiver,
                                   Handle<Object> search,
                                   Handle<Object> position) { … }

bool String::HasOneBytePrefix(base::Vector<const char> str) { … }

namespace {

template <typename Char>
bool IsIdentifierVector(base::Vector<Char> vec) { … }

}  // namespace

// static
bool String::IsIdentifier(Isolate* isolate, Handle<String> str) { … }

namespace {

template <typename Char>
uint32_t HashString(Tagged<String> string, size_t start, int length,
                    uint64_t seed,
                    const SharedStringAccessGuardIfNeeded& access_guard) { … }

}  // namespace

uint32_t String::ComputeAndSetRawHash() { … }

uint32_t String::ComputeAndSetRawHash(
    const SharedStringAccessGuardIfNeeded& access_guard) { … }

bool String::SlowAsArrayIndex(uint32_t* index) { … }

bool String::SlowAsIntegerIndex(size_t* index) { … }

void String::PrintOn(FILE* file) { … }

void String::PrintOn(std::ostream& ostream) { … }

Handle<String> SeqString::Truncate(Isolate* isolate, Handle<SeqString> string,
                                   int new_length) { … }

SeqString::DataAndPaddingSizes SeqString::GetDataAndPaddingSizes() const { … }

SeqString::DataAndPaddingSizes SeqOneByteString::GetDataAndPaddingSizes()
    const { … }

SeqString::DataAndPaddingSizes SeqTwoByteString::GetDataAndPaddingSizes()
    const { … }

#ifdef VERIFY_HEAP
V8_EXPORT_PRIVATE void SeqString::SeqStringVerify(Isolate* isolate) { … }
#endif  // VERIFY_HEAP

void SeqString::ClearPadding() { … }

uint16_t ConsString::Get(
    int index, const SharedStringAccessGuardIfNeeded& access_guard) const { … }

uint16_t ThinString::Get(
    int index, const SharedStringAccessGuardIfNeeded& access_guard) const { … }

uint16_t SlicedString::Get(
    int index, const SharedStringAccessGuardIfNeeded& access_guard) const { … }

int ExternalString::ExternalPayloadSize() const { … }

FlatStringReader::FlatStringReader(Isolate* isolate, Handle<String> str)
    : … { … }

void FlatStringReader::PostGarbageCollection() { … }

void ConsStringIterator::Initialize(Tagged<ConsString> cons_string,
                                    int offset) { … }

Tagged<String> ConsStringIterator::Continue(int* offset_out) { … }

Tagged<String> ConsStringIterator::Search(int* offset_out) { … }

Tagged<String> ConsStringIterator::NextLeaf(bool* blew_stack) { … }

const uint8_t* String::AddressOfCharacterAt(
    int start_index, const DisallowGarbageCollection& no_gc) { … }

template EXPORT_TEMPLATE_DEFINE(…) void String::WriteToFlat(
    Tagged<String> source, uint16_t* sink, int from, int to);
template EXPORT_TEMPLATE_DEFINE(…) void String::WriteToFlat(
    Tagged<String> source, uint8_t* sink, int from, int to);
template EXPORT_TEMPLATE_DEFINE(…) void String::WriteToFlat(
    Tagged<String> source, uint16_t* sink, int from, int to,
    const SharedStringAccessGuardIfNeeded&);
template EXPORT_TEMPLATE_DEFINE(…) void String::WriteToFlat(
    Tagged<String> source, uint8_t* sink, int from, int to,
    const SharedStringAccessGuardIfNeeded&);

namespace {
// Check that the constants defined in src/objects/instance-type.h coincides
// with the Torque-definition of string instance types in src/objects/string.tq.

DEFINE_TORQUE_GENERATED_STRING_INSTANCE_TYPE(…)

static_assert(kStringRepresentationMask == RepresentationBits::kMask);

static_assert(kStringEncodingMask == IsOneByteBit::kMask);
static_assert(kTwoByteStringTag == IsOneByteBit::encode(false));
static_assert(kOneByteStringTag == IsOneByteBit::encode(true));

static_assert(kUncachedExternalStringMask == IsUncachedBit::kMask);
static_assert(kUncachedExternalStringTag == IsUncachedBit::encode(true));

static_assert(kIsNotInternalizedMask == IsNotInternalizedBit::kMask);
static_assert(kNotInternalizedTag == IsNotInternalizedBit::encode(true));
static_assert(kInternalizedTag == IsNotInternalizedBit::encode(false));
}  // namespace

}  // namespace internal
}  // namespace v8