// Copyright 2016 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/builtins/builtins-regexp.h" #include "src/builtins/builtins-utils.h" #include "src/builtins/builtins.h" #include "src/code-factory.h" #include "src/code-stub-assembler.h" #include "src/conversions.h" #include "src/counters.h" #include "src/objects-inl.h" #include "src/regexp/regexp-utils.h" #include "src/string-case.h" #include "src/unicode-inl.h" #include "src/unicode.h" namespace v8 { namespace internal { typedef CodeStubAssembler::ResultMode ResultMode; typedef CodeStubAssembler::RelationalComparisonMode RelationalComparisonMode; class StringBuiltinsAssembler : public CodeStubAssembler { public: explicit StringBuiltinsAssembler(compiler::CodeAssemblerState* state) : CodeStubAssembler(state) {} protected: Node* DirectStringData(Node* string, Node* string_instance_type) { // Compute the effective offset of the first character. Variable var_data(this, MachineType::PointerRepresentation()); Label if_sequential(this), if_external(this), if_join(this); Branch(Word32Equal(Word32And(string_instance_type, Int32Constant(kStringRepresentationMask)), Int32Constant(kSeqStringTag)), &if_sequential, &if_external); Bind(&if_sequential); { var_data.Bind(IntPtrAdd( IntPtrConstant(SeqOneByteString::kHeaderSize - kHeapObjectTag), BitcastTaggedToWord(string))); Goto(&if_join); } Bind(&if_external); { // This is only valid for ExternalStrings where the resource data // pointer is cached (i.e. no short external strings). CSA_ASSERT(this, Word32NotEqual( Word32And(string_instance_type, Int32Constant(kShortExternalStringMask)), Int32Constant(kShortExternalStringTag))); var_data.Bind(LoadObjectField(string, ExternalString::kResourceDataOffset, MachineType::Pointer())); Goto(&if_join); } Bind(&if_join); return var_data.value(); } Node* LoadOneByteChar(Node* string, Node* index) { return Load(MachineType::Uint8(), string, OneByteCharOffset(index)); } Node* OneByteCharAddress(Node* string, Node* index) { Node* offset = OneByteCharOffset(index); return IntPtrAdd(string, offset); } Node* OneByteCharOffset(Node* index) { return CharOffset(String::ONE_BYTE_ENCODING, index); } Node* CharOffset(String::Encoding encoding, Node* index) { const int header = SeqOneByteString::kHeaderSize - kHeapObjectTag; Node* offset = index; if (encoding == String::TWO_BYTE_ENCODING) { offset = IntPtrAdd(offset, offset); } offset = IntPtrAdd(offset, IntPtrConstant(header)); return offset; } void DispatchOnStringInstanceType(Node* const instance_type, Label* if_onebyte_sequential, Label* if_onebyte_external, Label* if_otherwise) { const int kMask = kStringRepresentationMask | kStringEncodingMask; Node* const encoding_and_representation = Word32And(instance_type, Int32Constant(kMask)); int32_t values[] = { kOneByteStringTag | kSeqStringTag, kOneByteStringTag | kExternalStringTag, }; Label* labels[] = { if_onebyte_sequential, if_onebyte_external, }; STATIC_ASSERT(arraysize(values) == arraysize(labels)); Switch(encoding_and_representation, if_otherwise, values, labels, arraysize(values)); } void GenerateStringEqual(ResultMode mode); void GenerateStringRelationalComparison(RelationalComparisonMode mode); Node* ToSmiBetweenZeroAnd(Node* context, Node* value, Node* limit); Node* LoadSurrogatePairAt(Node* string, Node* length, Node* index, UnicodeEncoding encoding); void StringIndexOf(Node* receiver, Node* instance_type, Node* search_string, Node* search_string_instance_type, Node* position, std::function f_return); Node* IsNullOrUndefined(Node* const value); void RequireObjectCoercible(Node* const context, Node* const value, const char* method_name); Node* SmiIsNegative(Node* const value) { return SmiLessThan(value, SmiConstant(0)); } // Implements boilerplate logic for {match, split, replace, search} of the // form: // // if (!IS_NULL_OR_UNDEFINED(object)) { // var maybe_function = object[symbol]; // if (!IS_UNDEFINED(maybe_function)) { // return %_Call(maybe_function, ...); // } // } // // Contains fast paths for Smi and RegExp objects. typedef std::function NodeFunction0; typedef std::function NodeFunction1; void MaybeCallFunctionAtSymbol(Node* const context, Node* const object, Node* const maybe_string, Handle symbol, const NodeFunction0& regexp_call, const NodeFunction1& generic_call); }; void StringBuiltinsAssembler::GenerateStringEqual(ResultMode mode) { // Here's pseudo-code for the algorithm below in case of kDontNegateResult // mode; for kNegateResult mode we properly negate the result. // // if (lhs == rhs) return true; // if (lhs->length() != rhs->length()) return false; // if (lhs->IsInternalizedString() && rhs->IsInternalizedString()) { // return false; // } // if (lhs->IsSeqOneByteString() && rhs->IsSeqOneByteString()) { // for (i = 0; i != lhs->length(); ++i) { // if (lhs[i] != rhs[i]) return false; // } // return true; // } // if (lhs and/or rhs are indirect strings) { // unwrap them and restart from the beginning; // } // return %StringEqual(lhs, rhs); Variable var_left(this, MachineRepresentation::kTagged); Variable var_right(this, MachineRepresentation::kTagged); var_left.Bind(Parameter(0)); var_right.Bind(Parameter(1)); Node* context = Parameter(2); Variable* input_vars[2] = {&var_left, &var_right}; Label if_equal(this), if_notequal(this), restart(this, 2, input_vars); Goto(&restart); Bind(&restart); Node* lhs = var_left.value(); Node* rhs = var_right.value(); // Fast check to see if {lhs} and {rhs} refer to the same String object. GotoIf(WordEqual(lhs, rhs), &if_equal); // Load the length of {lhs} and {rhs}. Node* lhs_length = LoadStringLength(lhs); Node* rhs_length = LoadStringLength(rhs); // Strings with different lengths cannot be equal. GotoIf(WordNotEqual(lhs_length, rhs_length), &if_notequal); // Load instance types of {lhs} and {rhs}. Node* lhs_instance_type = LoadInstanceType(lhs); Node* rhs_instance_type = LoadInstanceType(rhs); // Combine the instance types into a single 16-bit value, so we can check // both of them at once. Node* both_instance_types = Word32Or( lhs_instance_type, Word32Shl(rhs_instance_type, Int32Constant(8))); // Check if both {lhs} and {rhs} are internalized. Since we already know // that they're not the same object, they're not equal in that case. int const kBothInternalizedMask = kIsNotInternalizedMask | (kIsNotInternalizedMask << 8); int const kBothInternalizedTag = kInternalizedTag | (kInternalizedTag << 8); GotoIf(Word32Equal(Word32And(both_instance_types, Int32Constant(kBothInternalizedMask)), Int32Constant(kBothInternalizedTag)), &if_notequal); // Check that both {lhs} and {rhs} are flat one-byte strings, and that // in case of ExternalStrings the data pointer is cached.. STATIC_ASSERT(kShortExternalStringTag != 0); int const kBothDirectOneByteStringMask = kStringEncodingMask | kIsIndirectStringMask | kShortExternalStringMask | ((kStringEncodingMask | kIsIndirectStringMask | kShortExternalStringMask) << 8); int const kBothDirectOneByteStringTag = kOneByteStringTag | (kOneByteStringTag << 8); Label if_bothdirectonebytestrings(this), if_notbothdirectonebytestrings(this); Branch(Word32Equal(Word32And(both_instance_types, Int32Constant(kBothDirectOneByteStringMask)), Int32Constant(kBothDirectOneByteStringTag)), &if_bothdirectonebytestrings, &if_notbothdirectonebytestrings); Bind(&if_bothdirectonebytestrings); { // Compute the effective offset of the first character. Node* lhs_data = DirectStringData(lhs, lhs_instance_type); Node* rhs_data = DirectStringData(rhs, rhs_instance_type); // Compute the first offset after the string from the length. Node* length = SmiUntag(lhs_length); // Loop over the {lhs} and {rhs} strings to see if they are equal. Variable var_offset(this, MachineType::PointerRepresentation()); Label loop(this, &var_offset); var_offset.Bind(IntPtrConstant(0)); Goto(&loop); Bind(&loop); { // If {offset} equals {end}, no difference was found, so the // strings are equal. Node* offset = var_offset.value(); GotoIf(WordEqual(offset, length), &if_equal); // Load the next characters from {lhs} and {rhs}. Node* lhs_value = Load(MachineType::Uint8(), lhs_data, offset); Node* rhs_value = Load(MachineType::Uint8(), rhs_data, offset); // Check if the characters match. GotoIf(Word32NotEqual(lhs_value, rhs_value), &if_notequal); // Advance to next character. var_offset.Bind(IntPtrAdd(offset, IntPtrConstant(1))); Goto(&loop); } } Bind(&if_notbothdirectonebytestrings); { // Try to unwrap indirect strings, restart the above attempt on success. MaybeDerefIndirectStrings(&var_left, lhs_instance_type, &var_right, rhs_instance_type, &restart); // TODO(bmeurer): Add support for two byte string equality checks. Runtime::FunctionId function_id = (mode == ResultMode::kDontNegateResult) ? Runtime::kStringEqual : Runtime::kStringNotEqual; TailCallRuntime(function_id, context, lhs, rhs); } Bind(&if_equal); Return(BooleanConstant(mode == ResultMode::kDontNegateResult)); Bind(&if_notequal); Return(BooleanConstant(mode == ResultMode::kNegateResult)); } void StringBuiltinsAssembler::GenerateStringRelationalComparison( RelationalComparisonMode mode) { Variable var_left(this, MachineRepresentation::kTagged); Variable var_right(this, MachineRepresentation::kTagged); var_left.Bind(Parameter(0)); var_right.Bind(Parameter(1)); Node* context = Parameter(2); Variable* input_vars[2] = {&var_left, &var_right}; Label if_less(this), if_equal(this), if_greater(this); Label restart(this, 2, input_vars); Goto(&restart); Bind(&restart); Node* lhs = var_left.value(); Node* rhs = var_right.value(); // Fast check to see if {lhs} and {rhs} refer to the same String object. GotoIf(WordEqual(lhs, rhs), &if_equal); // Load instance types of {lhs} and {rhs}. Node* lhs_instance_type = LoadInstanceType(lhs); Node* rhs_instance_type = LoadInstanceType(rhs); // Combine the instance types into a single 16-bit value, so we can check // both of them at once. Node* both_instance_types = Word32Or( lhs_instance_type, Word32Shl(rhs_instance_type, Int32Constant(8))); // Check that both {lhs} and {rhs} are flat one-byte strings. int const kBothSeqOneByteStringMask = kStringEncodingMask | kStringRepresentationMask | ((kStringEncodingMask | kStringRepresentationMask) << 8); int const kBothSeqOneByteStringTag = kOneByteStringTag | kSeqStringTag | ((kOneByteStringTag | kSeqStringTag) << 8); Label if_bothonebyteseqstrings(this), if_notbothonebyteseqstrings(this); Branch(Word32Equal(Word32And(both_instance_types, Int32Constant(kBothSeqOneByteStringMask)), Int32Constant(kBothSeqOneByteStringTag)), &if_bothonebyteseqstrings, &if_notbothonebyteseqstrings); Bind(&if_bothonebyteseqstrings); { // Load the length of {lhs} and {rhs}. Node* lhs_length = LoadStringLength(lhs); Node* rhs_length = LoadStringLength(rhs); // Determine the minimum length. Node* length = SmiMin(lhs_length, rhs_length); // Compute the effective offset of the first character. Node* begin = IntPtrConstant(SeqOneByteString::kHeaderSize - kHeapObjectTag); // Compute the first offset after the string from the length. Node* end = IntPtrAdd(begin, SmiUntag(length)); // Loop over the {lhs} and {rhs} strings to see if they are equal. Variable var_offset(this, MachineType::PointerRepresentation()); Label loop(this, &var_offset); var_offset.Bind(begin); Goto(&loop); Bind(&loop); { // Check if {offset} equals {end}. Node* offset = var_offset.value(); Label if_done(this), if_notdone(this); Branch(WordEqual(offset, end), &if_done, &if_notdone); Bind(&if_notdone); { // Load the next characters from {lhs} and {rhs}. Node* lhs_value = Load(MachineType::Uint8(), lhs, offset); Node* rhs_value = Load(MachineType::Uint8(), rhs, offset); // Check if the characters match. Label if_valueissame(this), if_valueisnotsame(this); Branch(Word32Equal(lhs_value, rhs_value), &if_valueissame, &if_valueisnotsame); Bind(&if_valueissame); { // Advance to next character. var_offset.Bind(IntPtrAdd(offset, IntPtrConstant(1))); } Goto(&loop); Bind(&if_valueisnotsame); Branch(Uint32LessThan(lhs_value, rhs_value), &if_less, &if_greater); } Bind(&if_done); { // All characters up to the min length are equal, decide based on // string length. GotoIf(SmiEqual(lhs_length, rhs_length), &if_equal); BranchIfSmiLessThan(lhs_length, rhs_length, &if_less, &if_greater); } } } Bind(&if_notbothonebyteseqstrings); { // Try to unwrap indirect strings, restart the above attempt on success. MaybeDerefIndirectStrings(&var_left, lhs_instance_type, &var_right, rhs_instance_type, &restart); // TODO(bmeurer): Add support for two byte string relational comparisons. switch (mode) { case RelationalComparisonMode::kLessThan: TailCallRuntime(Runtime::kStringLessThan, context, lhs, rhs); break; case RelationalComparisonMode::kLessThanOrEqual: TailCallRuntime(Runtime::kStringLessThanOrEqual, context, lhs, rhs); break; case RelationalComparisonMode::kGreaterThan: TailCallRuntime(Runtime::kStringGreaterThan, context, lhs, rhs); break; case RelationalComparisonMode::kGreaterThanOrEqual: TailCallRuntime(Runtime::kStringGreaterThanOrEqual, context, lhs, rhs); break; } } Bind(&if_less); switch (mode) { case RelationalComparisonMode::kLessThan: case RelationalComparisonMode::kLessThanOrEqual: Return(BooleanConstant(true)); break; case RelationalComparisonMode::kGreaterThan: case RelationalComparisonMode::kGreaterThanOrEqual: Return(BooleanConstant(false)); break; } Bind(&if_equal); switch (mode) { case RelationalComparisonMode::kLessThan: case RelationalComparisonMode::kGreaterThan: Return(BooleanConstant(false)); break; case RelationalComparisonMode::kLessThanOrEqual: case RelationalComparisonMode::kGreaterThanOrEqual: Return(BooleanConstant(true)); break; } Bind(&if_greater); switch (mode) { case RelationalComparisonMode::kLessThan: case RelationalComparisonMode::kLessThanOrEqual: Return(BooleanConstant(false)); break; case RelationalComparisonMode::kGreaterThan: case RelationalComparisonMode::kGreaterThanOrEqual: Return(BooleanConstant(true)); break; } } TF_BUILTIN(StringEqual, StringBuiltinsAssembler) { GenerateStringEqual(ResultMode::kDontNegateResult); } TF_BUILTIN(StringNotEqual, StringBuiltinsAssembler) { GenerateStringEqual(ResultMode::kNegateResult); } TF_BUILTIN(StringLessThan, StringBuiltinsAssembler) { GenerateStringRelationalComparison(RelationalComparisonMode::kLessThan); } TF_BUILTIN(StringLessThanOrEqual, StringBuiltinsAssembler) { GenerateStringRelationalComparison( RelationalComparisonMode::kLessThanOrEqual); } TF_BUILTIN(StringGreaterThan, StringBuiltinsAssembler) { GenerateStringRelationalComparison(RelationalComparisonMode::kGreaterThan); } TF_BUILTIN(StringGreaterThanOrEqual, StringBuiltinsAssembler) { GenerateStringRelationalComparison( RelationalComparisonMode::kGreaterThanOrEqual); } TF_BUILTIN(StringCharAt, CodeStubAssembler) { Node* receiver = Parameter(0); Node* position = Parameter(1); // Load the character code at the {position} from the {receiver}. Node* code = StringCharCodeAt(receiver, position, INTPTR_PARAMETERS); // And return the single character string with only that {code} Node* result = StringFromCharCode(code); Return(result); } TF_BUILTIN(StringCharCodeAt, CodeStubAssembler) { Node* receiver = Parameter(0); Node* position = Parameter(1); // Load the character code at the {position} from the {receiver}. Node* code = StringCharCodeAt(receiver, position, INTPTR_PARAMETERS); // And return it as TaggedSigned value. // TODO(turbofan): Allow builtins to return values untagged. Node* result = SmiFromWord32(code); Return(result); } // ----------------------------------------------------------------------------- // ES6 section 21.1 String Objects // ES6 section 21.1.2.1 String.fromCharCode ( ...codeUnits ) TF_BUILTIN(StringFromCharCode, CodeStubAssembler) { Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount); Node* context = Parameter(BuiltinDescriptor::kContext); CodeStubArguments arguments(this, ChangeInt32ToIntPtr(argc)); // From now on use word-size argc value. argc = arguments.GetLength(); // Check if we have exactly one argument (plus the implicit receiver), i.e. // if the parent frame is not an arguments adaptor frame. Label if_oneargument(this), if_notoneargument(this); Branch(WordEqual(argc, IntPtrConstant(1)), &if_oneargument, &if_notoneargument); Bind(&if_oneargument); { // Single argument case, perform fast single character string cache lookup // for one-byte code units, or fall back to creating a single character // string on the fly otherwise. Node* code = arguments.AtIndex(0); Node* code32 = TruncateTaggedToWord32(context, code); Node* code16 = Word32And(code32, Int32Constant(String::kMaxUtf16CodeUnit)); Node* result = StringFromCharCode(code16); arguments.PopAndReturn(result); } Node* code16 = nullptr; Bind(&if_notoneargument); { Label two_byte(this); // Assume that the resulting string contains only one-byte characters. Node* one_byte_result = AllocateSeqOneByteString(context, argc); Variable max_index(this, MachineType::PointerRepresentation()); max_index.Bind(IntPtrConstant(0)); // Iterate over the incoming arguments, converting them to 8-bit character // codes. Stop if any of the conversions generates a code that doesn't fit // in 8 bits. CodeStubAssembler::VariableList vars({&max_index}, zone()); arguments.ForEach(vars, [this, context, &two_byte, &max_index, &code16, one_byte_result](Node* arg) { Node* code32 = TruncateTaggedToWord32(context, arg); code16 = Word32And(code32, Int32Constant(String::kMaxUtf16CodeUnit)); GotoIf( Int32GreaterThan(code16, Int32Constant(String::kMaxOneByteCharCode)), &two_byte); // The {code16} fits into the SeqOneByteString {one_byte_result}. Node* offset = ElementOffsetFromIndex( max_index.value(), UINT8_ELEMENTS, CodeStubAssembler::INTPTR_PARAMETERS, SeqOneByteString::kHeaderSize - kHeapObjectTag); StoreNoWriteBarrier(MachineRepresentation::kWord8, one_byte_result, offset, code16); max_index.Bind(IntPtrAdd(max_index.value(), IntPtrConstant(1))); }); arguments.PopAndReturn(one_byte_result); Bind(&two_byte); // At least one of the characters in the string requires a 16-bit // representation. Allocate a SeqTwoByteString to hold the resulting // string. Node* two_byte_result = AllocateSeqTwoByteString(context, argc); // Copy the characters that have already been put in the 8-bit string into // their corresponding positions in the new 16-bit string. Node* zero = IntPtrConstant(0); CopyStringCharacters(one_byte_result, two_byte_result, zero, zero, max_index.value(), String::ONE_BYTE_ENCODING, String::TWO_BYTE_ENCODING, CodeStubAssembler::INTPTR_PARAMETERS); // Write the character that caused the 8-bit to 16-bit fault. Node* max_index_offset = ElementOffsetFromIndex(max_index.value(), UINT16_ELEMENTS, CodeStubAssembler::INTPTR_PARAMETERS, SeqTwoByteString::kHeaderSize - kHeapObjectTag); StoreNoWriteBarrier(MachineRepresentation::kWord16, two_byte_result, max_index_offset, code16); max_index.Bind(IntPtrAdd(max_index.value(), IntPtrConstant(1))); // Resume copying the passed-in arguments from the same place where the // 8-bit copy stopped, but this time copying over all of the characters // using a 16-bit representation. arguments.ForEach( vars, [this, context, two_byte_result, &max_index](Node* arg) { Node* code32 = TruncateTaggedToWord32(context, arg); Node* code16 = Word32And(code32, Int32Constant(String::kMaxUtf16CodeUnit)); Node* offset = ElementOffsetFromIndex( max_index.value(), UINT16_ELEMENTS, CodeStubAssembler::INTPTR_PARAMETERS, SeqTwoByteString::kHeaderSize - kHeapObjectTag); StoreNoWriteBarrier(MachineRepresentation::kWord16, two_byte_result, offset, code16); max_index.Bind(IntPtrAdd(max_index.value(), IntPtrConstant(1))); }, max_index.value()); arguments.PopAndReturn(two_byte_result); } } namespace { // for String.fromCodePoint bool IsValidCodePoint(Isolate* isolate, Handle value) { if (!value->IsNumber() && !Object::ToNumber(value).ToHandle(&value)) { return false; } if (Object::ToInteger(isolate, value).ToHandleChecked()->Number() != value->Number()) { return false; } if (value->Number() < 0 || value->Number() > 0x10FFFF) { return false; } return true; } uc32 NextCodePoint(Isolate* isolate, BuiltinArguments args, int index) { Handle value = args.at(1 + index); ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, value, Object::ToNumber(value), -1); if (!IsValidCodePoint(isolate, value)) { isolate->Throw(*isolate->factory()->NewRangeError( MessageTemplate::kInvalidCodePoint, value)); return -1; } return DoubleToUint32(value->Number()); } } // namespace // ES6 section 21.1.2.2 String.fromCodePoint ( ...codePoints ) BUILTIN(StringFromCodePoint) { HandleScope scope(isolate); int const length = args.length() - 1; if (length == 0) return isolate->heap()->empty_string(); DCHECK_LT(0, length); // Optimistically assume that the resulting String contains only one byte // characters. List one_byte_buffer(length); uc32 code = 0; int index; for (index = 0; index < length; index++) { code = NextCodePoint(isolate, args, index); if (code < 0) { return isolate->heap()->exception(); } if (code > String::kMaxOneByteCharCode) { break; } one_byte_buffer.Add(code); } if (index == length) { RETURN_RESULT_OR_FAILURE(isolate, isolate->factory()->NewStringFromOneByte( one_byte_buffer.ToConstVector())); } List two_byte_buffer(length - index); while (true) { if (code <= static_cast(unibrow::Utf16::kMaxNonSurrogateCharCode)) { two_byte_buffer.Add(code); } else { two_byte_buffer.Add(unibrow::Utf16::LeadSurrogate(code)); two_byte_buffer.Add(unibrow::Utf16::TrailSurrogate(code)); } if (++index == length) { break; } code = NextCodePoint(isolate, args, index); if (code < 0) { return isolate->heap()->exception(); } } Handle result; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, result, isolate->factory()->NewRawTwoByteString(one_byte_buffer.length() + two_byte_buffer.length())); CopyChars(result->GetChars(), one_byte_buffer.ToConstVector().start(), one_byte_buffer.length()); CopyChars(result->GetChars() + one_byte_buffer.length(), two_byte_buffer.ToConstVector().start(), two_byte_buffer.length()); return *result; } // ES6 section 21.1.3.1 String.prototype.charAt ( pos ) TF_BUILTIN(StringPrototypeCharAt, CodeStubAssembler) { Node* receiver = Parameter(0); Node* position = Parameter(1); Node* context = Parameter(4); // Check that {receiver} is coercible to Object and convert it to a String. receiver = ToThisString(context, receiver, "String.prototype.charAt"); // Convert the {position} to a Smi and check that it's in bounds of the // {receiver}. { Label return_emptystring(this, Label::kDeferred); position = ToInteger(context, position, CodeStubAssembler::kTruncateMinusZero); GotoIfNot(TaggedIsSmi(position), &return_emptystring); // Determine the actual length of the {receiver} String. Node* receiver_length = LoadObjectField(receiver, String::kLengthOffset); // Return "" if the Smi {position} is outside the bounds of the {receiver}. Label if_positioninbounds(this); Branch(SmiAboveOrEqual(position, receiver_length), &return_emptystring, &if_positioninbounds); Bind(&return_emptystring); Return(EmptyStringConstant()); Bind(&if_positioninbounds); } // Load the character code at the {position} from the {receiver}. Node* code = StringCharCodeAt(receiver, position); // And return the single character string with only that {code}. Node* result = StringFromCharCode(code); Return(result); } // ES6 section 21.1.3.2 String.prototype.charCodeAt ( pos ) TF_BUILTIN(StringPrototypeCharCodeAt, CodeStubAssembler) { Node* receiver = Parameter(0); Node* position = Parameter(1); Node* context = Parameter(4); // Check that {receiver} is coercible to Object and convert it to a String. receiver = ToThisString(context, receiver, "String.prototype.charCodeAt"); // Convert the {position} to a Smi and check that it's in bounds of the // {receiver}. { Label return_nan(this, Label::kDeferred); position = ToInteger(context, position, CodeStubAssembler::kTruncateMinusZero); GotoIfNot(TaggedIsSmi(position), &return_nan); // Determine the actual length of the {receiver} String. Node* receiver_length = LoadObjectField(receiver, String::kLengthOffset); // Return NaN if the Smi {position} is outside the bounds of the {receiver}. Label if_positioninbounds(this); Branch(SmiAboveOrEqual(position, receiver_length), &return_nan, &if_positioninbounds); Bind(&return_nan); Return(NaNConstant()); Bind(&if_positioninbounds); } // Load the character at the {position} from the {receiver}. Node* value = StringCharCodeAt(receiver, position); Node* result = SmiFromWord32(value); Return(result); } // ES6 section 21.1.3.6 // String.prototype.endsWith ( searchString [ , endPosition ] ) BUILTIN(StringPrototypeEndsWith) { HandleScope handle_scope(isolate); TO_THIS_STRING(str, "String.prototype.endsWith"); // Check if the search string is a regExp and fail if it is. Handle search = args.atOrUndefined(isolate, 1); Maybe is_reg_exp = RegExpUtils::IsRegExp(isolate, search); if (is_reg_exp.IsNothing()) { DCHECK(isolate->has_pending_exception()); return isolate->heap()->exception(); } if (is_reg_exp.FromJust()) { THROW_NEW_ERROR_RETURN_FAILURE( isolate, NewTypeError(MessageTemplate::kFirstArgumentNotRegExp, isolate->factory()->NewStringFromStaticChars( "String.prototype.endsWith"))); } Handle search_string; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, search_string, Object::ToString(isolate, search)); Handle position = args.atOrUndefined(isolate, 2); int end; if (position->IsUndefined(isolate)) { end = str->length(); } else { ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, position, Object::ToInteger(isolate, position)); end = str->ToValidIndex(*position); } int start = end - search_string->length(); if (start < 0) return isolate->heap()->false_value(); str = String::Flatten(str); search_string = String::Flatten(search_string); DisallowHeapAllocation no_gc; // ensure vectors stay valid String::FlatContent str_content = str->GetFlatContent(); String::FlatContent search_content = search_string->GetFlatContent(); if (str_content.IsOneByte() && search_content.IsOneByte()) { Vector str_vector = str_content.ToOneByteVector(); Vector search_vector = search_content.ToOneByteVector(); return isolate->heap()->ToBoolean(memcmp(str_vector.start() + start, search_vector.start(), search_string->length()) == 0); } FlatStringReader str_reader(isolate, str); FlatStringReader search_reader(isolate, search_string); for (int i = 0; i < search_string->length(); i++) { if (str_reader.Get(start + i) != search_reader.Get(i)) { return isolate->heap()->false_value(); } } return isolate->heap()->true_value(); } // ES6 section 21.1.3.7 // String.prototype.includes ( searchString [ , position ] ) BUILTIN(StringPrototypeIncludes) { HandleScope handle_scope(isolate); TO_THIS_STRING(str, "String.prototype.includes"); // Check if the search string is a regExp and fail if it is. Handle search = args.atOrUndefined(isolate, 1); Maybe is_reg_exp = RegExpUtils::IsRegExp(isolate, search); if (is_reg_exp.IsNothing()) { DCHECK(isolate->has_pending_exception()); return isolate->heap()->exception(); } if (is_reg_exp.FromJust()) { THROW_NEW_ERROR_RETURN_FAILURE( isolate, NewTypeError(MessageTemplate::kFirstArgumentNotRegExp, isolate->factory()->NewStringFromStaticChars( "String.prototype.includes"))); } Handle search_string; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, search_string, Object::ToString(isolate, search)); Handle position; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, position, Object::ToInteger(isolate, args.atOrUndefined(isolate, 2))); uint32_t index = str->ToValidIndex(*position); int index_in_str = String::IndexOf(isolate, str, search_string, index); return *isolate->factory()->ToBoolean(index_in_str != -1); } void StringBuiltinsAssembler::StringIndexOf( Node* receiver, Node* instance_type, Node* search_string, Node* search_string_instance_type, Node* position, std::function f_return) { CSA_ASSERT(this, IsString(receiver)); CSA_ASSERT(this, IsString(search_string)); CSA_ASSERT(this, TaggedIsSmi(position)); Label zero_length_needle(this), call_runtime_unchecked(this, Label::kDeferred), return_minus_1(this), check_search_string(this), continue_fast_path(this); Node* const int_zero = IntPtrConstant(0); Variable var_needle_byte(this, MachineType::PointerRepresentation(), int_zero); Variable var_string_addr(this, MachineType::PointerRepresentation(), int_zero); Node* needle_length = SmiUntag(LoadStringLength(search_string)); // Use faster/complex runtime fallback for long search strings. GotoIf(IntPtrLessThan(IntPtrConstant(1), needle_length), &call_runtime_unchecked); Node* string_length = SmiUntag(LoadStringLength(receiver)); Node* start_position = IntPtrMax(SmiUntag(position), int_zero); GotoIf(IntPtrEqual(int_zero, needle_length), &zero_length_needle); // Check that the needle fits in the start position. GotoIfNot(IntPtrLessThanOrEqual(needle_length, IntPtrSub(string_length, start_position)), &return_minus_1); // Load the string address. { Label if_onebyte_sequential(this); Label if_onebyte_external(this, Label::kDeferred); // Only support one-byte strings on the fast path. DispatchOnStringInstanceType(instance_type, &if_onebyte_sequential, &if_onebyte_external, &call_runtime_unchecked); Bind(&if_onebyte_sequential); { var_string_addr.Bind( OneByteCharAddress(BitcastTaggedToWord(receiver), start_position)); Goto(&check_search_string); } Bind(&if_onebyte_external); { Node* const unpacked = TryDerefExternalString(receiver, instance_type, &call_runtime_unchecked); var_string_addr.Bind(OneByteCharAddress(unpacked, start_position)); Goto(&check_search_string); } } // Load the needle character. Bind(&check_search_string); { Label if_onebyte_sequential(this); Label if_onebyte_external(this, Label::kDeferred); DispatchOnStringInstanceType(search_string_instance_type, &if_onebyte_sequential, &if_onebyte_external, &call_runtime_unchecked); Bind(&if_onebyte_sequential); { var_needle_byte.Bind( ChangeInt32ToIntPtr(LoadOneByteChar(search_string, int_zero))); Goto(&continue_fast_path); } Bind(&if_onebyte_external); { Node* const unpacked = TryDerefExternalString( search_string, search_string_instance_type, &call_runtime_unchecked); var_needle_byte.Bind( ChangeInt32ToIntPtr(LoadOneByteChar(unpacked, int_zero))); Goto(&continue_fast_path); } } Bind(&continue_fast_path); { Node* needle_byte = var_needle_byte.value(); Node* string_addr = var_string_addr.value(); Node* search_length = IntPtrSub(string_length, start_position); // Call out to the highly optimized memchr to perform the actual byte // search. Node* memchr = ExternalConstant(ExternalReference::libc_memchr_function(isolate())); Node* result_address = CallCFunction3(MachineType::Pointer(), MachineType::Pointer(), MachineType::IntPtr(), MachineType::UintPtr(), memchr, string_addr, needle_byte, search_length); GotoIf(WordEqual(result_address, int_zero), &return_minus_1); Node* result_index = IntPtrAdd(IntPtrSub(result_address, string_addr), start_position); f_return(SmiTag(result_index)); } Bind(&return_minus_1); f_return(SmiConstant(-1)); Bind(&zero_length_needle); { Comment("0-length search_string"); f_return(SmiTag(IntPtrMin(string_length, start_position))); } Bind(&call_runtime_unchecked); { // Simplified version of the runtime call where the types of the arguments // are already known due to type checks in this stub. Comment("Call Runtime Unchecked"); Node* result = CallRuntime(Runtime::kStringIndexOfUnchecked, SmiConstant(0), receiver, search_string, position); f_return(result); } } // ES6 String.prototype.indexOf(searchString [, position]) // #sec-string.prototype.indexof // Unchecked helper for builtins lowering. TF_BUILTIN(StringIndexOf, StringBuiltinsAssembler) { Node* receiver = Parameter(0); Node* search_string = Parameter(1); Node* position = Parameter(2); Node* instance_type = LoadInstanceType(receiver); Node* search_string_instance_type = LoadInstanceType(search_string); StringIndexOf(receiver, instance_type, search_string, search_string_instance_type, position, [this](Node* result) { this->Return(result); }); } // ES6 String.prototype.indexOf(searchString [, position]) // #sec-string.prototype.indexof TF_BUILTIN(StringPrototypeIndexOf, StringBuiltinsAssembler) { Variable search_string(this, MachineRepresentation::kTagged), position(this, MachineRepresentation::kTagged); Label call_runtime(this), call_runtime_unchecked(this), argc_0(this), no_argc_0(this), argc_1(this), no_argc_1(this), argc_2(this), fast_path(this), return_minus_1(this); Node* argc = Parameter(BuiltinDescriptor::kArgumentsCount); Node* context = Parameter(BuiltinDescriptor::kContext); CodeStubArguments arguments(this, ChangeInt32ToIntPtr(argc)); Node* receiver = arguments.GetReceiver(); // From now on use word-size argc value. argc = arguments.GetLength(); GotoIf(IntPtrEqual(argc, IntPtrConstant(0)), &argc_0); GotoIf(IntPtrEqual(argc, IntPtrConstant(1)), &argc_1); Goto(&argc_2); Bind(&argc_0); { Comment("0 Argument case"); Node* undefined = UndefinedConstant(); search_string.Bind(undefined); position.Bind(undefined); Goto(&call_runtime); } Bind(&argc_1); { Comment("1 Argument case"); search_string.Bind(arguments.AtIndex(0)); position.Bind(SmiConstant(0)); Goto(&fast_path); } Bind(&argc_2); { Comment("2 Argument case"); search_string.Bind(arguments.AtIndex(0)); position.Bind(arguments.AtIndex(1)); GotoIfNot(TaggedIsSmi(position.value()), &call_runtime); Goto(&fast_path); } Bind(&fast_path); { Comment("Fast Path"); GotoIf(TaggedIsSmi(receiver), &call_runtime); Node* needle = search_string.value(); GotoIf(TaggedIsSmi(needle), &call_runtime); Node* instance_type = LoadInstanceType(receiver); GotoIfNot(IsStringInstanceType(instance_type), &call_runtime); Node* needle_instance_type = LoadInstanceType(needle); GotoIfNot(IsStringInstanceType(needle_instance_type), &call_runtime); StringIndexOf( receiver, instance_type, needle, needle_instance_type, position.value(), [&arguments](Node* result) { arguments.PopAndReturn(result); }); } Bind(&call_runtime); { Comment("Call Runtime"); Node* result = CallRuntime(Runtime::kStringIndexOf, context, receiver, search_string.value(), position.value()); arguments.PopAndReturn(result); } } // ES6 section 21.1.3.9 // String.prototype.lastIndexOf ( searchString [ , position ] ) BUILTIN(StringPrototypeLastIndexOf) { HandleScope handle_scope(isolate); return String::LastIndexOf(isolate, args.receiver(), args.atOrUndefined(isolate, 1), args.atOrUndefined(isolate, 2)); } // ES6 section 21.1.3.10 String.prototype.localeCompare ( that ) // // This function is implementation specific. For now, we do not // do anything locale specific. // If internationalization is enabled, then i18n.js will override this function // and provide the proper functionality, so this is just a fallback. BUILTIN(StringPrototypeLocaleCompare) { HandleScope handle_scope(isolate); DCHECK_EQ(2, args.length()); TO_THIS_STRING(str1, "String.prototype.localeCompare"); Handle str2; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, str2, Object::ToString(isolate, args.at(1))); if (str1.is_identical_to(str2)) return Smi::kZero; // Equal. int str1_length = str1->length(); int str2_length = str2->length(); // Decide trivial cases without flattening. if (str1_length == 0) { if (str2_length == 0) return Smi::kZero; // Equal. return Smi::FromInt(-str2_length); } else { if (str2_length == 0) return Smi::FromInt(str1_length); } int end = str1_length < str2_length ? str1_length : str2_length; // No need to flatten if we are going to find the answer on the first // character. At this point we know there is at least one character // in each string, due to the trivial case handling above. int d = str1->Get(0) - str2->Get(0); if (d != 0) return Smi::FromInt(d); str1 = String::Flatten(str1); str2 = String::Flatten(str2); DisallowHeapAllocation no_gc; String::FlatContent flat1 = str1->GetFlatContent(); String::FlatContent flat2 = str2->GetFlatContent(); for (int i = 0; i < end; i++) { if (flat1.Get(i) != flat2.Get(i)) { return Smi::FromInt(flat1.Get(i) - flat2.Get(i)); } } return Smi::FromInt(str1_length - str2_length); } // ES6 section 21.1.3.12 String.prototype.normalize ( [form] ) // // Simply checks the argument is valid and returns the string itself. // If internationalization is enabled, then i18n.js will override this function // and provide the proper functionality, so this is just a fallback. BUILTIN(StringPrototypeNormalize) { HandleScope handle_scope(isolate); TO_THIS_STRING(string, "String.prototype.normalize"); Handle form_input = args.atOrUndefined(isolate, 1); if (form_input->IsUndefined(isolate)) return *string; Handle form; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, form, Object::ToString(isolate, form_input)); if (!(String::Equals(form, isolate->factory()->NewStringFromStaticChars("NFC")) || String::Equals(form, isolate->factory()->NewStringFromStaticChars("NFD")) || String::Equals(form, isolate->factory()->NewStringFromStaticChars("NFKC")) || String::Equals(form, isolate->factory()->NewStringFromStaticChars("NFKD")))) { Handle valid_forms = isolate->factory()->NewStringFromStaticChars("NFC, NFD, NFKC, NFKD"); THROW_NEW_ERROR_RETURN_FAILURE( isolate, NewRangeError(MessageTemplate::kNormalizationForm, valid_forms)); } return *string; } compiler::Node* StringBuiltinsAssembler::IsNullOrUndefined(Node* const value) { return Word32Or(IsUndefined(value), IsNull(value)); } void StringBuiltinsAssembler::RequireObjectCoercible(Node* const context, Node* const value, const char* method_name) { Label out(this), throw_exception(this, Label::kDeferred); Branch(IsNullOrUndefined(value), &throw_exception, &out); Bind(&throw_exception); TailCallRuntime( Runtime::kThrowCalledOnNullOrUndefined, context, HeapConstant(factory()->NewStringFromAsciiChecked(method_name, TENURED))); Bind(&out); } void StringBuiltinsAssembler::MaybeCallFunctionAtSymbol( Node* const context, Node* const object, Node* const maybe_string, Handle symbol, const NodeFunction0& regexp_call, const NodeFunction1& generic_call) { Label out(this); // Smis definitely don't have an attached symbol. GotoIf(TaggedIsSmi(object), &out); Node* const object_map = LoadMap(object); // Skip the slow lookup for Strings. { Label next(this); GotoIfNot(IsStringInstanceType(LoadMapInstanceType(object_map)), &next); Node* const native_context = LoadNativeContext(context); Node* const initial_proto_initial_map = LoadContextElement( native_context, Context::STRING_FUNCTION_PROTOTYPE_MAP_INDEX); Node* const string_fun = LoadContextElement(native_context, Context::STRING_FUNCTION_INDEX); Node* const initial_map = LoadObjectField(string_fun, JSFunction::kPrototypeOrInitialMapOffset); Node* const proto_map = LoadMap(LoadMapPrototype(initial_map)); Branch(WordEqual(proto_map, initial_proto_initial_map), &out, &next); Bind(&next); } // Take the fast path for RegExps. // There's two conditions: {object} needs to be a fast regexp, and // {maybe_string} must be a string (we can't call ToString on the fast path // since it may mutate {object}). { Label stub_call(this), slow_lookup(this); GotoIf(TaggedIsSmi(maybe_string), &slow_lookup); GotoIfNot(IsString(maybe_string), &slow_lookup); RegExpBuiltinsAssembler regexp_asm(state()); regexp_asm.BranchIfFastRegExp(context, object, object_map, &stub_call, &slow_lookup); Bind(&stub_call); Return(regexp_call()); Bind(&slow_lookup); } GotoIf(IsNullOrUndefined(object), &out); // Fall back to a slow lookup of {object[symbol]}. Callable getproperty_callable = CodeFactory::GetProperty(isolate()); Node* const key = HeapConstant(symbol); Node* const maybe_func = CallStub(getproperty_callable, context, object, key); GotoIf(IsUndefined(maybe_func), &out); // Attempt to call the function. Node* const result = generic_call(maybe_func); Return(result); Bind(&out); } // ES6 section 21.1.3.16 String.prototype.replace ( search, replace ) TF_BUILTIN(StringPrototypeReplace, StringBuiltinsAssembler) { Label out(this); Node* const receiver = Parameter(0); Node* const search = Parameter(1); Node* const replace = Parameter(2); Node* const context = Parameter(5); Node* const smi_zero = SmiConstant(0); RequireObjectCoercible(context, receiver, "String.prototype.replace"); // Redirect to replacer method if {search[@@replace]} is not undefined. MaybeCallFunctionAtSymbol( context, search, receiver, isolate()->factory()->replace_symbol(), [=]() { Callable tostring_callable = CodeFactory::ToString(isolate()); Node* const subject_string = CallStub(tostring_callable, context, receiver); Callable replace_callable = CodeFactory::RegExpReplace(isolate()); return CallStub(replace_callable, context, search, subject_string, replace); }, [=](Node* fn) { Callable call_callable = CodeFactory::Call(isolate()); return CallJS(call_callable, context, fn, search, receiver, replace); }); // Convert {receiver} and {search} to strings. Callable tostring_callable = CodeFactory::ToString(isolate()); Callable indexof_callable = CodeFactory::StringIndexOf(isolate()); Node* const subject_string = CallStub(tostring_callable, context, receiver); Node* const search_string = CallStub(tostring_callable, context, search); Node* const subject_length = LoadStringLength(subject_string); Node* const search_length = LoadStringLength(search_string); // Fast-path single-char {search}, long {receiver}, and simple string // {replace}. { Label next(this); GotoIfNot(SmiEqual(search_length, SmiConstant(1)), &next); GotoIfNot(SmiGreaterThan(subject_length, SmiConstant(0xFF)), &next); GotoIf(TaggedIsSmi(replace), &next); GotoIfNot(IsString(replace), &next); Node* const dollar_string = HeapConstant( isolate()->factory()->LookupSingleCharacterStringFromCode('$')); Node* const dollar_ix = CallStub(indexof_callable, context, replace, dollar_string, smi_zero); GotoIfNot(SmiIsNegative(dollar_ix), &next); // Searching by traversing a cons string tree and replace with cons of // slices works only when the replaced string is a single character, being // replaced by a simple string and only pays off for long strings. // TODO(jgruber): Reevaluate if this is still beneficial. // TODO(jgruber): TailCallRuntime when it correctly handles adapter frames. Return(CallRuntime(Runtime::kStringReplaceOneCharWithString, context, subject_string, search_string, replace)); Bind(&next); } // TODO(jgruber): Extend StringIndexOf to handle two-byte strings and // longer substrings - we can handle up to 8 chars (one-byte) / 4 chars // (2-byte). Node* const match_start_index = CallStub( indexof_callable, context, subject_string, search_string, smi_zero); CSA_ASSERT(this, TaggedIsSmi(match_start_index)); // Early exit if no match found. { Label next(this), return_subject(this); GotoIfNot(SmiIsNegative(match_start_index), &next); // The spec requires to perform ToString(replace) if the {replace} is not // callable even if we are going to exit here. // Since ToString() being applied to Smi does not have side effects for // numbers we can skip it. GotoIf(TaggedIsSmi(replace), &return_subject); GotoIf(IsCallableMap(LoadMap(replace)), &return_subject); // TODO(jgruber): Could introduce ToStringSideeffectsStub which only // performs observable parts of ToString. CallStub(tostring_callable, context, replace); Goto(&return_subject); Bind(&return_subject); Return(subject_string); Bind(&next); } Node* const match_end_index = SmiAdd(match_start_index, search_length); Callable substring_callable = CodeFactory::SubString(isolate()); Callable stringadd_callable = CodeFactory::StringAdd(isolate(), STRING_ADD_CHECK_NONE, NOT_TENURED); Variable var_result(this, MachineRepresentation::kTagged, EmptyStringConstant()); // Compute the prefix. { Label next(this); GotoIf(SmiEqual(match_start_index, smi_zero), &next); Node* const prefix = CallStub(substring_callable, context, subject_string, smi_zero, match_start_index); var_result.Bind(prefix); Goto(&next); Bind(&next); } // Compute the string to replace with. Label if_iscallablereplace(this), if_notcallablereplace(this); GotoIf(TaggedIsSmi(replace), &if_notcallablereplace); Branch(IsCallableMap(LoadMap(replace)), &if_iscallablereplace, &if_notcallablereplace); Bind(&if_iscallablereplace); { Callable call_callable = CodeFactory::Call(isolate()); Node* const replacement = CallJS(call_callable, context, replace, UndefinedConstant(), search_string, match_start_index, subject_string); Node* const replacement_string = CallStub(tostring_callable, context, replacement); var_result.Bind(CallStub(stringadd_callable, context, var_result.value(), replacement_string)); Goto(&out); } Bind(&if_notcallablereplace); { Node* const replace_string = CallStub(tostring_callable, context, replace); // TODO(jgruber): Simplified GetSubstitution implementation in CSA. Node* const matched = CallStub(substring_callable, context, subject_string, match_start_index, match_end_index); Node* const replacement_string = CallRuntime(Runtime::kGetSubstitution, context, matched, subject_string, match_start_index, replace_string); var_result.Bind(CallStub(stringadd_callable, context, var_result.value(), replacement_string)); Goto(&out); } Bind(&out); { Node* const suffix = CallStub(substring_callable, context, subject_string, match_end_index, subject_length); Node* const result = CallStub(stringadd_callable, context, var_result.value(), suffix); Return(result); } } // ES6 section 21.1.3.19 String.prototype.split ( separator, limit ) TF_BUILTIN(StringPrototypeSplit, StringBuiltinsAssembler) { Label out(this); Node* const receiver = Parameter(0); Node* const separator = Parameter(1); Node* const limit = Parameter(2); Node* const context = Parameter(5); Node* const smi_zero = SmiConstant(0); RequireObjectCoercible(context, receiver, "String.prototype.split"); // Redirect to splitter method if {separator[@@split]} is not undefined. MaybeCallFunctionAtSymbol( context, separator, receiver, isolate()->factory()->split_symbol(), [=]() { Callable tostring_callable = CodeFactory::ToString(isolate()); Node* const subject_string = CallStub(tostring_callable, context, receiver); Callable split_callable = CodeFactory::RegExpSplit(isolate()); return CallStub(split_callable, context, separator, subject_string, limit); }, [=](Node* fn) { Callable call_callable = CodeFactory::Call(isolate()); return CallJS(call_callable, context, fn, separator, receiver, limit); }); // String and integer conversions. // TODO(jgruber): The old implementation used Uint32Max instead of SmiMax - // but AFAIK there should not be a difference since arrays are capped at Smi // lengths. Callable tostring_callable = CodeFactory::ToString(isolate()); Node* const subject_string = CallStub(tostring_callable, context, receiver); Node* const limit_number = Select(IsUndefined(limit), [=]() { return SmiConstant(Smi::kMaxValue); }, [=]() { return ToUint32(context, limit); }, MachineRepresentation::kTagged); Node* const separator_string = CallStub(tostring_callable, context, separator); // Shortcut for {limit} == 0. { Label next(this); GotoIfNot(SmiEqual(limit_number, smi_zero), &next); const ElementsKind kind = FAST_ELEMENTS; Node* const native_context = LoadNativeContext(context); Node* const array_map = LoadJSArrayElementsMap(kind, native_context); Node* const length = smi_zero; Node* const capacity = IntPtrConstant(0); Node* const result = AllocateJSArray(kind, array_map, capacity, length); Return(result); Bind(&next); } // ECMA-262 says that if {separator} is undefined, the result should // be an array of size 1 containing the entire string. { Label next(this); GotoIfNot(IsUndefined(separator), &next); const ElementsKind kind = FAST_ELEMENTS; Node* const native_context = LoadNativeContext(context); Node* const array_map = LoadJSArrayElementsMap(kind, native_context); Node* const length = SmiConstant(1); Node* const capacity = IntPtrConstant(1); Node* const result = AllocateJSArray(kind, array_map, capacity, length); Node* const fixed_array = LoadElements(result); StoreFixedArrayElement(fixed_array, 0, subject_string); Return(result); Bind(&next); } // If the separator string is empty then return the elements in the subject. { Label next(this); GotoIfNot(SmiEqual(LoadStringLength(separator_string), smi_zero), &next); Node* const result = CallRuntime(Runtime::kStringToArray, context, subject_string, limit_number); Return(result); Bind(&next); } Node* const result = CallRuntime(Runtime::kStringSplit, context, subject_string, separator_string, limit_number); Return(result); } // ES6 section B.2.3.1 String.prototype.substr ( start, length ) TF_BUILTIN(StringPrototypeSubstr, CodeStubAssembler) { Label out(this), handle_length(this); Variable var_start(this, MachineRepresentation::kTagged); Variable var_length(this, MachineRepresentation::kTagged); Node* const receiver = Parameter(0); Node* const start = Parameter(1); Node* const length = Parameter(2); Node* const context = Parameter(5); Node* const zero = SmiConstant(Smi::kZero); // Check that {receiver} is coercible to Object and convert it to a String. Node* const string = ToThisString(context, receiver, "String.prototype.substr"); Node* const string_length = LoadStringLength(string); // Conversions and bounds-checks for {start}. { Node* const start_int = ToInteger(context, start, CodeStubAssembler::kTruncateMinusZero); Label if_issmi(this), if_isheapnumber(this, Label::kDeferred); Branch(TaggedIsSmi(start_int), &if_issmi, &if_isheapnumber); Bind(&if_issmi); { Node* const length_plus_start = SmiAdd(string_length, start_int); var_start.Bind(Select(SmiLessThan(start_int, zero), [&] { return SmiMax(length_plus_start, zero); }, [&] { return start_int; }, MachineRepresentation::kTagged)); Goto(&handle_length); } Bind(&if_isheapnumber); { // If {start} is a heap number, it is definitely out of bounds. If it is // negative, {start} = max({string_length} + {start}),0) = 0'. If it is // positive, set {start} to {string_length} which ultimately results in // returning an empty string. Node* const float_zero = Float64Constant(0.); Node* const start_float = LoadHeapNumberValue(start_int); var_start.Bind(SelectTaggedConstant( Float64LessThan(start_float, float_zero), zero, string_length)); Goto(&handle_length); } } // Conversions and bounds-checks for {length}. Bind(&handle_length); { Label if_issmi(this), if_isheapnumber(this, Label::kDeferred); // Default to {string_length} if {length} is undefined. { Label if_isundefined(this, Label::kDeferred), if_isnotundefined(this); Branch(WordEqual(length, UndefinedConstant()), &if_isundefined, &if_isnotundefined); Bind(&if_isundefined); var_length.Bind(string_length); Goto(&if_issmi); Bind(&if_isnotundefined); var_length.Bind( ToInteger(context, length, CodeStubAssembler::kTruncateMinusZero)); } Branch(TaggedIsSmi(var_length.value()), &if_issmi, &if_isheapnumber); // Set {length} to min(max({length}, 0), {string_length} - {start} Bind(&if_issmi); { Node* const positive_length = SmiMax(var_length.value(), zero); Node* const minimal_length = SmiSub(string_length, var_start.value()); var_length.Bind(SmiMin(positive_length, minimal_length)); GotoIfNot(SmiLessThanOrEqual(var_length.value(), zero), &out); Return(EmptyStringConstant()); } Bind(&if_isheapnumber); { // If {length} is a heap number, it is definitely out of bounds. There are // two cases according to the spec: if it is negative, "" is returned; if // it is positive, then length is set to {string_length} - {start}. CSA_ASSERT(this, IsHeapNumberMap(LoadMap(var_length.value()))); Label if_isnegative(this), if_ispositive(this); Node* const float_zero = Float64Constant(0.); Node* const length_float = LoadHeapNumberValue(var_length.value()); Branch(Float64LessThan(length_float, float_zero), &if_isnegative, &if_ispositive); Bind(&if_isnegative); Return(EmptyStringConstant()); Bind(&if_ispositive); { var_length.Bind(SmiSub(string_length, var_start.value())); GotoIfNot(SmiLessThanOrEqual(var_length.value(), zero), &out); Return(EmptyStringConstant()); } } } Bind(&out); { Node* const end = SmiAdd(var_start.value(), var_length.value()); Node* const result = SubString(context, string, var_start.value(), end); Return(result); } } compiler::Node* StringBuiltinsAssembler::ToSmiBetweenZeroAnd(Node* context, Node* value, Node* limit) { Label out(this); Variable var_result(this, MachineRepresentation::kTagged); Node* const value_int = this->ToInteger(context, value, CodeStubAssembler::kTruncateMinusZero); Label if_issmi(this), if_isnotsmi(this, Label::kDeferred); Branch(TaggedIsSmi(value_int), &if_issmi, &if_isnotsmi); Bind(&if_issmi); { Label if_isinbounds(this), if_isoutofbounds(this, Label::kDeferred); Branch(SmiAbove(value_int, limit), &if_isoutofbounds, &if_isinbounds); Bind(&if_isinbounds); { var_result.Bind(value_int); Goto(&out); } Bind(&if_isoutofbounds); { Node* const zero = SmiConstant(Smi::kZero); var_result.Bind( SelectTaggedConstant(SmiLessThan(value_int, zero), zero, limit)); Goto(&out); } } Bind(&if_isnotsmi); { // {value} is a heap number - in this case, it is definitely out of bounds. CSA_ASSERT(this, IsHeapNumberMap(LoadMap(value_int))); Node* const float_zero = Float64Constant(0.); Node* const smi_zero = SmiConstant(Smi::kZero); Node* const value_float = LoadHeapNumberValue(value_int); var_result.Bind(SelectTaggedConstant( Float64LessThan(value_float, float_zero), smi_zero, limit)); Goto(&out); } Bind(&out); return var_result.value(); } // ES6 section 21.1.3.19 String.prototype.substring ( start, end ) TF_BUILTIN(StringPrototypeSubstring, StringBuiltinsAssembler) { Label out(this); Variable var_start(this, MachineRepresentation::kTagged); Variable var_end(this, MachineRepresentation::kTagged); Node* const receiver = Parameter(0); Node* const start = Parameter(1); Node* const end = Parameter(2); Node* const context = Parameter(5); // Check that {receiver} is coercible to Object and convert it to a String. Node* const string = ToThisString(context, receiver, "String.prototype.substring"); Node* const length = LoadStringLength(string); // Conversion and bounds-checks for {start}. var_start.Bind(ToSmiBetweenZeroAnd(context, start, length)); // Conversion and bounds-checks for {end}. { var_end.Bind(length); GotoIf(WordEqual(end, UndefinedConstant()), &out); var_end.Bind(ToSmiBetweenZeroAnd(context, end, length)); Label if_endislessthanstart(this); Branch(SmiLessThan(var_end.value(), var_start.value()), &if_endislessthanstart, &out); Bind(&if_endislessthanstart); { Node* const tmp = var_end.value(); var_end.Bind(var_start.value()); var_start.Bind(tmp); Goto(&out); } } Bind(&out); { Node* result = SubString(context, string, var_start.value(), var_end.value()); Return(result); } } BUILTIN(StringPrototypeStartsWith) { HandleScope handle_scope(isolate); TO_THIS_STRING(str, "String.prototype.startsWith"); // Check if the search string is a regExp and fail if it is. Handle search = args.atOrUndefined(isolate, 1); Maybe is_reg_exp = RegExpUtils::IsRegExp(isolate, search); if (is_reg_exp.IsNothing()) { DCHECK(isolate->has_pending_exception()); return isolate->heap()->exception(); } if (is_reg_exp.FromJust()) { THROW_NEW_ERROR_RETURN_FAILURE( isolate, NewTypeError(MessageTemplate::kFirstArgumentNotRegExp, isolate->factory()->NewStringFromStaticChars( "String.prototype.startsWith"))); } Handle search_string; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, search_string, Object::ToString(isolate, search)); Handle position = args.atOrUndefined(isolate, 2); int start; if (position->IsUndefined(isolate)) { start = 0; } else { ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, position, Object::ToInteger(isolate, position)); start = str->ToValidIndex(*position); } if (start + search_string->length() > str->length()) { return isolate->heap()->false_value(); } FlatStringReader str_reader(isolate, String::Flatten(str)); FlatStringReader search_reader(isolate, String::Flatten(search_string)); for (int i = 0; i < search_string->length(); i++) { if (str_reader.Get(start + i) != search_reader.Get(i)) { return isolate->heap()->false_value(); } } return isolate->heap()->true_value(); } // ES6 section 21.1.3.25 String.prototype.toString () TF_BUILTIN(StringPrototypeToString, CodeStubAssembler) { Node* receiver = Parameter(0); Node* context = Parameter(3); Node* result = ToThisValue(context, receiver, PrimitiveType::kString, "String.prototype.toString"); Return(result); } // ES6 section 21.1.3.27 String.prototype.trim () BUILTIN(StringPrototypeTrim) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.trim"); return *String::Trim(string, String::kTrim); } // Non-standard WebKit extension BUILTIN(StringPrototypeTrimLeft) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.trimLeft"); return *String::Trim(string, String::kTrimLeft); } // Non-standard WebKit extension BUILTIN(StringPrototypeTrimRight) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.trimRight"); return *String::Trim(string, String::kTrimRight); } // ES6 section 21.1.3.28 String.prototype.valueOf ( ) TF_BUILTIN(StringPrototypeValueOf, CodeStubAssembler) { Node* receiver = Parameter(0); Node* context = Parameter(3); Node* result = ToThisValue(context, receiver, PrimitiveType::kString, "String.prototype.valueOf"); Return(result); } TF_BUILTIN(StringPrototypeIterator, CodeStubAssembler) { Node* receiver = Parameter(0); Node* context = Parameter(3); Node* string = ToThisString(context, receiver, "String.prototype[Symbol.iterator]"); Node* native_context = LoadNativeContext(context); Node* map = LoadContextElement(native_context, Context::STRING_ITERATOR_MAP_INDEX); Node* iterator = Allocate(JSStringIterator::kSize); StoreMapNoWriteBarrier(iterator, map); StoreObjectFieldRoot(iterator, JSValue::kPropertiesOffset, Heap::kEmptyFixedArrayRootIndex); StoreObjectFieldRoot(iterator, JSObject::kElementsOffset, Heap::kEmptyFixedArrayRootIndex); StoreObjectFieldNoWriteBarrier(iterator, JSStringIterator::kStringOffset, string); Node* index = SmiConstant(Smi::kZero); StoreObjectFieldNoWriteBarrier(iterator, JSStringIterator::kNextIndexOffset, index); Return(iterator); } // Return the |word32| codepoint at {index}. Supports SeqStrings and // ExternalStrings. compiler::Node* StringBuiltinsAssembler::LoadSurrogatePairAt( compiler::Node* string, compiler::Node* length, compiler::Node* index, UnicodeEncoding encoding) { Label handle_surrogate_pair(this), return_result(this); Variable var_result(this, MachineRepresentation::kWord32); Variable var_trail(this, MachineRepresentation::kWord32); var_result.Bind(StringCharCodeAt(string, index)); var_trail.Bind(Int32Constant(0)); GotoIf(Word32NotEqual(Word32And(var_result.value(), Int32Constant(0xFC00)), Int32Constant(0xD800)), &return_result); Node* next_index = SmiAdd(index, SmiConstant(Smi::FromInt(1))); GotoIfNot(SmiLessThan(next_index, length), &return_result); var_trail.Bind(StringCharCodeAt(string, next_index)); Branch(Word32Equal(Word32And(var_trail.value(), Int32Constant(0xFC00)), Int32Constant(0xDC00)), &handle_surrogate_pair, &return_result); Bind(&handle_surrogate_pair); { Node* lead = var_result.value(); Node* trail = var_trail.value(); // Check that this path is only taken if a surrogate pair is found CSA_SLOW_ASSERT(this, Uint32GreaterThanOrEqual(lead, Int32Constant(0xD800))); CSA_SLOW_ASSERT(this, Uint32LessThan(lead, Int32Constant(0xDC00))); CSA_SLOW_ASSERT(this, Uint32GreaterThanOrEqual(trail, Int32Constant(0xDC00))); CSA_SLOW_ASSERT(this, Uint32LessThan(trail, Int32Constant(0xE000))); switch (encoding) { case UnicodeEncoding::UTF16: var_result.Bind(Word32Or( // Need to swap the order for big-endian platforms #if V8_TARGET_BIG_ENDIAN Word32Shl(lead, Int32Constant(16)), trail)); #else Word32Shl(trail, Int32Constant(16)), lead)); #endif break; case UnicodeEncoding::UTF32: { // Convert UTF16 surrogate pair into |word32| code point, encoded as // UTF32. Node* surrogate_offset = Int32Constant(0x10000 - (0xD800 << 10) - 0xDC00); // (lead << 10) + trail + SURROGATE_OFFSET var_result.Bind(Int32Add(WordShl(lead, Int32Constant(10)), Int32Add(trail, surrogate_offset))); break; } } Goto(&return_result); } Bind(&return_result); return var_result.value(); } TF_BUILTIN(StringIteratorPrototypeNext, StringBuiltinsAssembler) { Variable var_value(this, MachineRepresentation::kTagged); Variable var_done(this, MachineRepresentation::kTagged); var_value.Bind(UndefinedConstant()); var_done.Bind(BooleanConstant(true)); Label throw_bad_receiver(this), next_codepoint(this), return_result(this); Node* iterator = Parameter(0); Node* context = Parameter(3); GotoIf(TaggedIsSmi(iterator), &throw_bad_receiver); GotoIfNot(Word32Equal(LoadInstanceType(iterator), Int32Constant(JS_STRING_ITERATOR_TYPE)), &throw_bad_receiver); Node* string = LoadObjectField(iterator, JSStringIterator::kStringOffset); Node* position = LoadObjectField(iterator, JSStringIterator::kNextIndexOffset); Node* length = LoadObjectField(string, String::kLengthOffset); Branch(SmiLessThan(position, length), &next_codepoint, &return_result); Bind(&next_codepoint); { UnicodeEncoding encoding = UnicodeEncoding::UTF16; Node* ch = LoadSurrogatePairAt(string, length, position, encoding); Node* value = StringFromCodePoint(ch, encoding); var_value.Bind(value); Node* length = LoadObjectField(value, String::kLengthOffset); StoreObjectFieldNoWriteBarrier(iterator, JSStringIterator::kNextIndexOffset, SmiAdd(position, length)); var_done.Bind(BooleanConstant(false)); Goto(&return_result); } Bind(&return_result); { Node* native_context = LoadNativeContext(context); Node* map = LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX); Node* result = Allocate(JSIteratorResult::kSize); StoreMapNoWriteBarrier(result, map); StoreObjectFieldRoot(result, JSIteratorResult::kPropertiesOffset, Heap::kEmptyFixedArrayRootIndex); StoreObjectFieldRoot(result, JSIteratorResult::kElementsOffset, Heap::kEmptyFixedArrayRootIndex); StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kValueOffset, var_value.value()); StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kDoneOffset, var_done.value()); Return(result); } Bind(&throw_bad_receiver); { // The {receiver} is not a valid JSGeneratorObject. CallRuntime(Runtime::kThrowIncompatibleMethodReceiver, context, HeapConstant(factory()->NewStringFromAsciiChecked( "String Iterator.prototype.next", TENURED)), iterator); Unreachable(); } } namespace { inline bool ToUpperOverflows(uc32 character) { // y with umlauts and the micro sign are the only characters that stop // fitting into one-byte when converting to uppercase. static const uc32 yuml_code = 0xff; static const uc32 micro_code = 0xb5; return (character == yuml_code || character == micro_code); } template MUST_USE_RESULT static Object* ConvertCaseHelper( Isolate* isolate, String* string, SeqString* result, int result_length, unibrow::Mapping* mapping) { DisallowHeapAllocation no_gc; // We try this twice, once with the assumption that the result is no longer // than the input and, if that assumption breaks, again with the exact // length. This may not be pretty, but it is nicer than what was here before // and I hereby claim my vaffel-is. // // NOTE: This assumes that the upper/lower case of an ASCII // character is also ASCII. This is currently the case, but it // might break in the future if we implement more context and locale // dependent upper/lower conversions. bool has_changed_character = false; // Convert all characters to upper case, assuming that they will fit // in the buffer StringCharacterStream stream(string); unibrow::uchar chars[Converter::kMaxWidth]; // We can assume that the string is not empty uc32 current = stream.GetNext(); bool ignore_overflow = Converter::kIsToLower || result->IsSeqTwoByteString(); for (int i = 0; i < result_length;) { bool has_next = stream.HasMore(); uc32 next = has_next ? stream.GetNext() : 0; int char_length = mapping->get(current, next, chars); if (char_length == 0) { // The case conversion of this character is the character itself. result->Set(i, current); i++; } else if (char_length == 1 && (ignore_overflow || !ToUpperOverflows(current))) { // Common case: converting the letter resulted in one character. DCHECK(static_cast(chars[0]) != current); result->Set(i, chars[0]); has_changed_character = true; i++; } else if (result_length == string->length()) { bool overflows = ToUpperOverflows(current); // We've assumed that the result would be as long as the // input but here is a character that converts to several // characters. No matter, we calculate the exact length // of the result and try the whole thing again. // // Note that this leaves room for optimization. We could just // memcpy what we already have to the result string. Also, // the result string is the last object allocated we could // "realloc" it and probably, in the vast majority of cases, // extend the existing string to be able to hold the full // result. int next_length = 0; if (has_next) { next_length = mapping->get(next, 0, chars); if (next_length == 0) next_length = 1; } int current_length = i + char_length + next_length; while (stream.HasMore()) { current = stream.GetNext(); overflows |= ToUpperOverflows(current); // NOTE: we use 0 as the next character here because, while // the next character may affect what a character converts to, // it does not in any case affect the length of what it convert // to. int char_length = mapping->get(current, 0, chars); if (char_length == 0) char_length = 1; current_length += char_length; if (current_length > String::kMaxLength) { AllowHeapAllocation allocate_error_and_return; THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewInvalidStringLengthError()); } } // Try again with the real length. Return signed if we need // to allocate a two-byte string for to uppercase. return (overflows && !ignore_overflow) ? Smi::FromInt(-current_length) : Smi::FromInt(current_length); } else { for (int j = 0; j < char_length; j++) { result->Set(i, chars[j]); i++; } has_changed_character = true; } current = next; } if (has_changed_character) { return result; } else { // If we didn't actually change anything in doing the conversion // we simple return the result and let the converted string // become garbage; there is no reason to keep two identical strings // alive. return string; } } template MUST_USE_RESULT static Object* ConvertCase( Handle s, Isolate* isolate, unibrow::Mapping* mapping) { s = String::Flatten(s); int length = s->length(); // Assume that the string is not empty; we need this assumption later if (length == 0) return *s; // Simpler handling of ASCII strings. // // NOTE: This assumes that the upper/lower case of an ASCII // character is also ASCII. This is currently the case, but it // might break in the future if we implement more context and locale // dependent upper/lower conversions. if (s->IsOneByteRepresentationUnderneath()) { // Same length as input. Handle result = isolate->factory()->NewRawOneByteString(length).ToHandleChecked(); DisallowHeapAllocation no_gc; String::FlatContent flat_content = s->GetFlatContent(); DCHECK(flat_content.IsFlat()); bool has_changed_character = false; int index_to_first_unprocessed = FastAsciiConvert( reinterpret_cast(result->GetChars()), reinterpret_cast(flat_content.ToOneByteVector().start()), length, &has_changed_character); // If not ASCII, we discard the result and take the 2 byte path. if (index_to_first_unprocessed == length) return has_changed_character ? *result : *s; } Handle result; // Same length as input. if (s->IsOneByteRepresentation()) { result = isolate->factory()->NewRawOneByteString(length).ToHandleChecked(); } else { result = isolate->factory()->NewRawTwoByteString(length).ToHandleChecked(); } Object* answer = ConvertCaseHelper(isolate, *s, *result, length, mapping); if (answer->IsException(isolate) || answer->IsString()) return answer; DCHECK(answer->IsSmi()); length = Smi::cast(answer)->value(); if (s->IsOneByteRepresentation() && length > 0) { ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, result, isolate->factory()->NewRawOneByteString(length)); } else { if (length < 0) length = -length; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, result, isolate->factory()->NewRawTwoByteString(length)); } return ConvertCaseHelper(isolate, *s, *result, length, mapping); } } // namespace BUILTIN(StringPrototypeToLocaleLowerCase) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.toLocaleLowerCase"); return ConvertCase(string, isolate, isolate->runtime_state()->to_lower_mapping()); } BUILTIN(StringPrototypeToLocaleUpperCase) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.toLocaleUpperCase"); return ConvertCase(string, isolate, isolate->runtime_state()->to_upper_mapping()); } BUILTIN(StringPrototypeToLowerCase) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.toLowerCase"); return ConvertCase(string, isolate, isolate->runtime_state()->to_lower_mapping()); } BUILTIN(StringPrototypeToUpperCase) { HandleScope scope(isolate); TO_THIS_STRING(string, "String.prototype.toUpperCase"); return ConvertCase(string, isolate, isolate->runtime_state()->to_upper_mapping()); } } // namespace internal } // namespace v8