1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

deps: update v8 to 3.22.24.9

Browse Source
This commit is contained in:
Fedor Indutny 2013-12-14 03:16:52 +04:00
parent 6b4dc61322
commit 8803aa3af7
17 changed files with 344 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/v8/src/code-stubs-hydrogen.cc vendored
View File

@ -1240,8 +1240,6 @@ HValue* CodeStubGraphBuilder<FastNewClosureStub>::BuildCodeStub() {
Add<HStoreNamedField>(js_function,
HObjectAccess::ForSharedFunctionInfoPointer(),
shared_info);
Add<HStoreNamedField>(js_function, HObjectAccess::ForFunctionContextPointer(),
shared_info);
Add<HStoreNamedField>(js_function, HObjectAccess::ForFunctionContextPointer(),
context());

7
deps/v8/src/compiler.cc vendored
View File

@ -262,8 +262,11 @@ static bool AlwaysFullCompiler(Isolate* isolate) {
void RecompileJob::RecordOptimizationStats() {
Handle<JSFunction> function = info()->closure();
int opt_count = function->shared()->opt_count();
function->shared()->set_opt_count(opt_count + 1);
if (!function->IsOptimized()) {
// Concurrent recompilation and OSR may race. Increment only once.
int opt_count = function->shared()->opt_count();
function->shared()->set_opt_count(opt_count + 1);
}
double ms_creategraph = time_taken_to_create_graph_.InMillisecondsF();
double ms_optimize = time_taken_to_optimize_.InMillisecondsF();
double ms_codegen = time_taken_to_codegen_.InMillisecondsF();

3
deps/v8/src/d8.cc vendored
View File

@ -1358,6 +1358,9 @@ bool Shell::SetOptions(int argc, char* argv[]) {
if (strcmp(argv[i], "--stress-opt") == 0) {
options.stress_opt = true;
argv[i] = NULL;
} else if (strcmp(argv[i], "--nostress-opt") == 0) {
options.stress_opt = false;
argv[i] = NULL;
} else if (strcmp(argv[i], "--stress-deopt") == 0) {
options.stress_deopt = true;
argv[i] = NULL;

2
deps/v8/src/flag-definitions.h vendored
View File

@ -235,7 +235,7 @@ DEFINE_bool(use_range, true, "use hydrogen range analysis")
DEFINE_bool(use_gvn, true, "use hydrogen global value numbering")
DEFINE_bool(use_canonicalizing, true, "use hydrogen instruction canonicalizing")
DEFINE_bool(use_inlining, true, "use function inlining")
DEFINE_bool(use_escape_analysis, true, "use hydrogen escape analysis")
DEFINE_bool(use_escape_analysis, false, "use hydrogen escape analysis")
DEFINE_bool(use_allocation_folding, true, "use allocation folding")
DEFINE_int(max_inlining_levels, 5, "maximum number of inlining levels")
DEFINE_int(max_inlined_source_size, 600,

21
deps/v8/src/heap.cc vendored
View File

@ -735,6 +735,7 @@ int Heap::NotifyContextDisposed() {
isolate()->optimizing_compiler_thread()->Flush();
}
flush_monomorphic_ics_ = true;
AgeInlineCaches();
return ++contexts_disposed_;
}
@ -1132,8 +1133,6 @@ void Heap::MarkCompact(GCTracer* tracer) {
isolate_->counters()->objs_since_last_full()->Set(0);
contexts_disposed_ = 0;
flush_monomorphic_ics_ = false;
}
@ -4080,13 +4079,12 @@ MaybeObject* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
return result;
}
Object* result;
SeqTwoByteString* result;
{ MaybeObject* maybe_result = AllocateRawTwoByteString(1);
if (!maybe_result->ToObject(&result)) return maybe_result;
if (!maybe_result->To<SeqTwoByteString>(&result)) return maybe_result;
}
String* answer = String::cast(result);
answer->Set(0, code);
return answer;
result->SeqTwoByteStringSet(0, code);
return result;
}
@ -5818,12 +5816,7 @@ bool Heap::IdleNotification(int hint) {
size_factor * IncrementalMarking::kAllocatedThreshold;
if (contexts_disposed_ > 0) {
if (hint >= kMaxHint) {
// The embedder is requesting a lot of GC work after context disposal,
// we age inline caches so that they don't keep objects from
// the old context alive.
AgeInlineCaches();
}
contexts_disposed_ = 0;
int mark_sweep_time = Min(TimeMarkSweepWouldTakeInMs(), 1000);
if (hint >= mark_sweep_time && !FLAG_expose_gc &&
incremental_marking()->IsStopped()) {
@ -5832,8 +5825,8 @@ bool Heap::IdleNotification(int hint) {
"idle notification: contexts disposed");
} else {
AdvanceIdleIncrementalMarking(step_size);
contexts_disposed_ = 0;
}
// After context disposal there is likely a lot of garbage remaining, reset
// the idle notification counters in order to trigger more incremental GCs
// on subsequent idle notifications.

10
deps/v8/src/hydrogen-instructions.h vendored
View File

@ -3257,9 +3257,6 @@ class HDematerializedObject : public HInstruction {
// List of values tracked by this marker.
ZoneList<HValue*> values_;
private:
virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; }
};
@ -3287,6 +3284,8 @@ class HArgumentsObject V8_FINAL : public HDematerializedObject {
set_representation(Representation::Tagged());
SetFlag(kIsArguments);
}
virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; }
};
@ -3323,6 +3322,11 @@ class HCapturedObject V8_FINAL : public HDematerializedObject {
private:
int capture_id_;
// Note that we cannot DCE captured objects as they are used to replay
// the environment. This method is here as an explicit reminder.
// TODO(mstarzinger): Turn HSimulates into full snapshots maybe?
virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return false; }
};

10
deps/v8/src/objects.cc vendored
View File

@ -9568,7 +9568,7 @@ MaybeObject* SharedFunctionInfo::AddToOptimizedCodeMap(Context* native_context,
if (value->IsSmi()) {
// No optimized code map.
ASSERT_EQ(0, Smi::cast(value)->value());
// Crate 3 entries per context {context, code, literals}.
// Create 3 entries per context {context, code, literals}.
MaybeObject* maybe = heap->AllocateFixedArray(kInitialLength);
if (!maybe->To(&new_code_map)) return maybe;
new_code_map->set(kEntriesStart + 0, native_context);
@ -11564,11 +11564,9 @@ Handle<DependentCode> DependentCode::Insert(Handle<DependentCode> entries,
int start = starts.at(group);
int end = starts.at(group + 1);
int number_of_entries = starts.number_of_entries();
if (start < end && entries->object_at(end - 1) == *object) {
// Do not append the compilation info if it is already in the array.
// It is sufficient to just check only the last element because
// we process embedded maps of an optimized code in one batch.
return entries;
// Check for existing entry to avoid duplicates.
for (int i = start; i < end; i++) {
if (entries->object_at(i) == *object) return entries;
}
if (entries->length() < kCodesStartIndex + number_of_entries + 1) {
Factory* factory = entries->GetIsolate()->factory();

2
deps/v8/src/platform-freebsd.cc vendored
View File

@ -182,7 +182,7 @@ void OS::LogSharedLibraryAddresses(Isolate* isolate) {
// There may be no filename in this line. Skip to next.
if (start_of_path == NULL) continue;
buffer[bytes_read] = 0;
LOG(isolate, SharedLibraryEvent(start_of_path, start, end));
LOG(isolate SharedLibraryEvent(start_of_path, start, end));
}
close(fd);
}

238
deps/v8/src/runtime.cc vendored
View File

@ -922,6 +922,12 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_TypedArrayInitialize) {
ASSERT(byte_length % element_size == 0);
size_t length = byte_length / element_size;
if (length > static_cast<unsigned>(Smi::kMaxValue)) {
return isolate->Throw(*isolate->factory()->
NewRangeError("invalid_typed_array_length",
HandleVector<Object>(NULL, 0)));
}
Handle<Object> length_obj = isolate->factory()->NewNumberFromSize(length);
holder->set_length(*length_obj);
holder->set_weak_next(buffer->weak_first_view());
@ -961,9 +967,11 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_TypedArrayInitializeFromArrayLike) {
Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
size_t length = NumberToSize(isolate, *length_obj);
if (length > (kMaxInt / element_size)) {
if ((length > static_cast<unsigned>(Smi::kMaxValue)) ||
(length > (kMaxInt / element_size))) {
return isolate->Throw(*isolate->factory()->
NewRangeError("invalid_array_buffer_length",
NewRangeError("invalid_typed_array_length",
HandleVector<Object>(NULL, 0)));
}
size_t byte_length = length * element_size;
@ -6222,6 +6230,7 @@ template <class Converter>
MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
Isolate* isolate,
String* s,
String::Encoding result_encoding,
int length,
int input_string_length,
unibrow::Mapping<Converter, 128>* mapping) {
@ -6237,7 +6246,7 @@ MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
// might break in the future if we implement more context and locale
// dependent upper/lower conversions.
Object* o;
{ MaybeObject* maybe_o = s->IsOneByteRepresentation()
{ MaybeObject* maybe_o = result_encoding == String::ONE_BYTE_ENCODING
? isolate->heap()->AllocateRawOneByteString(length)
: isolate->heap()->AllocateRawTwoByteString(length);
if (!maybe_o->ToObject(&o)) return maybe_o;
@ -6245,6 +6254,8 @@ MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
String* result = String::cast(o);
bool has_changed_character = false;
DisallowHeapAllocation no_gc;
// Convert all characters to upper case, assuming that they will fit
// in the buffer
Access<ConsStringIteratorOp> op(
@ -6253,6 +6264,10 @@ MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
unibrow::uchar chars[Converter::kMaxWidth];
// We can assume that the string is not empty
uc32 current = stream.GetNext();
// y with umlauts is the only character that stops fitting into one-byte
// when converting to uppercase.
static const uc32 yuml_code = 0xff;
bool ignore_yuml = result->IsSeqTwoByteString() || Converter::kIsToLower;
for (int i = 0; i < length;) {
bool has_next = stream.HasMore();
uc32 next = has_next ? stream.GetNext() : 0;
@ -6261,13 +6276,14 @@ MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
// The case conversion of this character is the character itself.
result->Set(i, current);
i++;
} else if (char_length == 1) {
} else if (char_length == 1 && (ignore_yuml || current != yuml_code)) {
// Common case: converting the letter resulted in one character.
ASSERT(static_cast<uc32>(chars[0]) != current);
result->Set(i, chars[0]);
has_changed_character = true;
i++;
} else if (length == input_string_length) {
bool found_yuml = (current == yuml_code);
// 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
@ -6287,6 +6303,7 @@ MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
int current_length = i + char_length + next_length;
while (stream.HasMore()) {
current = stream.GetNext();
found_yuml |= (current == yuml_code);
// 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
@ -6299,8 +6316,10 @@ MUST_USE_RESULT static MaybeObject* ConvertCaseHelper(
return Failure::OutOfMemoryException(0x13);
}
}
// Try again with the real length.
return Smi::FromInt(current_length);
// Try again with the real length. Return signed if we need
// to allocate a two-byte string for y-umlaut to uppercase.
return (found_yuml && !ignore_yuml) ? Smi::FromInt(-current_length)
: Smi::FromInt(current_length);
} else {
for (int j = 0; j < char_length; j++) {
result->Set(i, chars[j]);
@ -6346,121 +6365,107 @@ static inline uintptr_t AsciiRangeMask(uintptr_t w, char m, char n) {
}
enum AsciiCaseConversion {
ASCII_TO_LOWER,
ASCII_TO_UPPER
};
template <AsciiCaseConversion dir>
struct FastAsciiConverter {
static bool Convert(char* dst, char* src, int length, bool* changed_out) {
template<class Converter>
static bool FastAsciiConvert(char* dst,
char* src,
int length,
bool* changed_out) {
#ifdef DEBUG
char* saved_dst = dst;
char* saved_src = src;
#endif
// We rely on the distance between upper and lower case letters
// being a known power of 2.
ASSERT('a' - 'A' == (1 << 5));
// Boundaries for the range of input characters than require conversion.
const char lo = (dir == ASCII_TO_LOWER) ? 'A' - 1 : 'a' - 1;
const char hi = (dir == ASCII_TO_LOWER) ? 'Z' + 1 : 'z' + 1;
bool changed = false;
uintptr_t or_acc = 0;
char* const limit = src + length;
DisallowHeapAllocation no_gc;
// We rely on the distance between upper and lower case letters
// being a known power of 2.
ASSERT('a' - 'A' == (1 << 5));
// Boundaries for the range of input characters than require conversion.
static const char lo = Converter::kIsToLower ? 'A' - 1 : 'a' - 1;
static const char hi = Converter::kIsToLower ? 'Z' + 1 : 'z' + 1;
bool changed = false;
uintptr_t or_acc = 0;
char* const limit = src + length;
#ifdef V8_HOST_CAN_READ_UNALIGNED
// Process the prefix of the input that requires no conversion one
// (machine) word at a time.
while (src <= limit - sizeof(uintptr_t)) {
uintptr_t w = *reinterpret_cast<uintptr_t*>(src);
or_acc |= w;
if (AsciiRangeMask(w, lo, hi) != 0) {
changed = true;
break;
}
*reinterpret_cast<uintptr_t*>(dst) = w;
src += sizeof(uintptr_t);
dst += sizeof(uintptr_t);
// Process the prefix of the input that requires no conversion one
// (machine) word at a time.
while (src <= limit - sizeof(uintptr_t)) {
uintptr_t w = *reinterpret_cast<uintptr_t*>(src);
or_acc |= w;
if (AsciiRangeMask(w, lo, hi) != 0) {
changed = true;
break;
}
// Process the remainder of the input performing conversion when
// required one word at a time.
while (src <= limit - sizeof(uintptr_t)) {
uintptr_t w = *reinterpret_cast<uintptr_t*>(src);
or_acc |= w;
uintptr_t m = AsciiRangeMask(w, lo, hi);
// The mask has high (7th) bit set in every byte that needs
// conversion and we know that the distance between cases is
// 1 << 5.
*reinterpret_cast<uintptr_t*>(dst) = w ^ (m >> 2);
src += sizeof(uintptr_t);
dst += sizeof(uintptr_t);
}
#endif
// Process the last few bytes of the input (or the whole input if
// unaligned access is not supported).
while (src < limit) {
char c = *src;
or_acc |= c;
if (lo < c && c < hi) {
c ^= (1 << 5);
changed = true;
}
*dst = c;
++src;
++dst;
}
if ((or_acc & kAsciiMask) != 0) {
return false;
}
#ifdef DEBUG
CheckConvert(saved_dst, saved_src, length, changed);
#endif
*changed_out = changed;
return true;
*reinterpret_cast<uintptr_t*>(dst) = w;
src += sizeof(uintptr_t);
dst += sizeof(uintptr_t);
}
#ifdef DEBUG
static void CheckConvert(char* dst, char* src, int length, bool changed) {
bool expected_changed = false;
for (int i = 0; i < length; i++) {
if (dst[i] == src[i]) continue;
expected_changed = true;
if (dir == ASCII_TO_LOWER) {
ASSERT('A' <= src[i] && src[i] <= 'Z');
ASSERT(dst[i] == src[i] + ('a' - 'A'));
} else {
ASSERT(dir == ASCII_TO_UPPER);
ASSERT('a' <= src[i] && src[i] <= 'z');
ASSERT(dst[i] == src[i] - ('a' - 'A'));
}
}
ASSERT(expected_changed == changed);
// Process the remainder of the input performing conversion when
// required one word at a time.
while (src <= limit - sizeof(uintptr_t)) {
uintptr_t w = *reinterpret_cast<uintptr_t*>(src);
or_acc |= w;
uintptr_t m = AsciiRangeMask(w, lo, hi);
// The mask has high (7th) bit set in every byte that needs
// conversion and we know that the distance between cases is
// 1 << 5.
*reinterpret_cast<uintptr_t*>(dst) = w ^ (m >> 2);
src += sizeof(uintptr_t);
dst += sizeof(uintptr_t);
}
#endif
};
// Process the last few bytes of the input (or the whole input if
// unaligned access is not supported).
while (src < limit) {
char c = *src;
or_acc |= c;
if (lo < c && c < hi) {
c ^= (1 << 5);
changed = true;
}
*dst = c;
++src;
++dst;
}
if ((or_acc & kAsciiMask) != 0) {
return false;
}
ASSERT(CheckFastAsciiConvert(
saved_dst, saved_src, length, changed, Converter::kIsToLower));
struct ToLowerTraits {
typedef unibrow::ToLowercase UnibrowConverter;
*changed_out = changed;
return true;
}
typedef FastAsciiConverter<ASCII_TO_LOWER> AsciiConverter;
};
struct ToUpperTraits {
typedef unibrow::ToUppercase UnibrowConverter;
typedef FastAsciiConverter<ASCII_TO_UPPER> AsciiConverter;
};
#ifdef DEBUG
static bool CheckFastAsciiConvert(char* dst,
char* src,
int length,
bool changed,
bool is_to_lower) {
bool expected_changed = false;
for (int i = 0; i < length; i++) {
if (dst[i] == src[i]) continue;
expected_changed = true;
if (is_to_lower) {
ASSERT('A' <= src[i] && src[i] <= 'Z');
ASSERT(dst[i] == src[i] + ('a' - 'A'));
} else {
ASSERT('a' <= src[i] && src[i] <= 'z');
ASSERT(dst[i] == src[i] - ('a' - 'A'));
}
}
return (expected_changed == changed);
}
#endif
} // namespace
template <typename ConvertTraits>
template <class Converter>
MUST_USE_RESULT static MaybeObject* ConvertCase(
Arguments args,
Isolate* isolate,
unibrow::Mapping<typename ConvertTraits::UnibrowConverter, 128>* mapping) {
unibrow::Mapping<Converter, 128>* mapping) {
SealHandleScope shs(isolate);
CONVERT_ARG_CHECKED(String, s, 0);
s = s->TryFlattenGetString();
@ -6482,7 +6487,7 @@ MUST_USE_RESULT static MaybeObject* ConvertCase(
}
SeqOneByteString* result = SeqOneByteString::cast(o);
bool has_changed_character;
bool is_ascii = ConvertTraits::AsciiConverter::Convert(
bool is_ascii = FastAsciiConvert<Converter>(
reinterpret_cast<char*>(result->GetChars()),
reinterpret_cast<char*>(SeqOneByteString::cast(s)->GetChars()),
length,
@ -6493,31 +6498,35 @@ MUST_USE_RESULT static MaybeObject* ConvertCase(
}
}
String::Encoding result_encoding = s->IsOneByteRepresentation()
? String::ONE_BYTE_ENCODING : String::TWO_BYTE_ENCODING;
Object* answer;
{ MaybeObject* maybe_answer =
ConvertCaseHelper(isolate, s, length, length, mapping);
{ MaybeObject* maybe_answer = ConvertCaseHelper(
isolate, s, result_encoding, length, length, mapping);
if (!maybe_answer->ToObject(&answer)) return maybe_answer;
}
if (answer->IsSmi()) {
// Retry with correct length.
{ MaybeObject* maybe_answer =
ConvertCaseHelper(isolate,
s, Smi::cast(answer)->value(), length, mapping);
if (!maybe_answer->ToObject(&answer)) return maybe_answer;
int new_length = Smi::cast(answer)->value();
if (new_length < 0) {
result_encoding = String::TWO_BYTE_ENCODING;
new_length = -new_length;
}
MaybeObject* maybe_answer = ConvertCaseHelper(
isolate, s, result_encoding, new_length, length, mapping);
if (!maybe_answer->ToObject(&answer)) return maybe_answer;
}
return answer;
}
RUNTIME_FUNCTION(MaybeObject*, Runtime_StringToLowerCase) {
return ConvertCase<ToLowerTraits>(
return ConvertCase(
args, isolate, isolate->runtime_state()->to_lower_mapping());
}
RUNTIME_FUNCTION(MaybeObject*, Runtime_StringToUpperCase) {
return ConvertCase<ToUpperTraits>(
return ConvertCase(
args, isolate, isolate->runtime_state()->to_upper_mapping());
}
@ -14789,6 +14798,11 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InternalArrayConstructor) {
}
RUNTIME_FUNCTION(MaybeObject*, Runtime_MaxSmi) {
return Smi::FromInt(Smi::kMaxValue);
}
// ----------------------------------------------------------------------------
// Implementation of Runtime

1
deps/v8/src/runtime.h vendored
View File

@ -112,6 +112,7 @@ namespace internal {
F(FlattenString, 1, 1) \
F(MigrateInstance, 1, 1) \
F(NotifyContextDisposed, 0, 1) \
F(MaxSmi, 0, 1) \
\
/* Array join support */ \
F(PushIfAbsent, 2, 1) \

3
deps/v8/src/typedarray.js vendored
View File

@ -69,6 +69,9 @@ function CreateTypedArrayConstructor(name, elementSize, arrayId, constructor) {
function ConstructByLength(obj, length) {
var l = ToPositiveInteger(length, "invalid_typed_array_length");
if (l > %MaxSmi()) {
throw MakeRangeError("invalid_typed_array_length");
}
var byteLength = l * elementSize;
var buffer = new $ArrayBuffer(byteLength);
%TypedArrayInitialize(obj, arrayId, buffer, 0, byteLength);

2
deps/v8/src/unicode.h vendored
View File

@ -235,6 +235,7 @@ struct ConnectorPunctuation {
};
struct ToLowercase {
static const int kMaxWidth = 3;
static const bool kIsToLower = true;
static int Convert(uchar c,
uchar n,
uchar* result,
@ -242,6 +243,7 @@ struct ToLowercase {
};
struct ToUppercase {
static const int kMaxWidth = 3;
static const bool kIsToLower = false;
static int Convert(uchar c,
uchar n,
uchar* result,

2
deps/v8/src/version.cc vendored
View File

@ -35,7 +35,7 @@
#define MAJOR_VERSION 3
#define MINOR_VERSION 22
#define BUILD_NUMBER 24
#define PATCH_LEVEL 5
#define PATCH_LEVEL 9
// Use 1 for candidates and 0 otherwise.
// (Boolean macro values are not supported by all preprocessors.)
#define IS_CANDIDATE_VERSION 0

34
deps/v8/test/mjsunit/regress/regress-2984.js vendored Normal file
View File

@ -0,0 +1,34 @@
// Copyright 2013 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
assertEquals("\u0178", "\xff".toUpperCase());
assertEquals("abcdefghijklmn\xffopq",
("ABCDEFGHIJKL" + "MN\u0178OPQ").toLowerCase());
assertEquals("\xff", "\u0178".toLowerCase());
assertEquals("ABCDEFGHIJKLMN\u0178OPQ",
("abcdefghijk" + "lmn\xffopq").toUpperCase());

57
deps/v8/test/mjsunit/regress/regress-2987.js vendored Normal file
View File

@ -0,0 +1,57 @@
// Copyright 2013 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --allow-natives-syntax --dead-code-elimination
// This tests that stores on captured objects are correctly tracked even
// when DCE is enabled. We cannot delete simulations of captured objects
// that are still needed to replay the environment correctly.
function constructor() {
this.x = 0;
}
var deopt = { deopt:false };
function boogeyman(mode, value) {
var object = new constructor();
if (mode) {
object.x = 1;
} else {
object.x = 2;
}
deopt.deopt;
assertEquals(value, object.x);
}
boogeyman(true, 1);
boogeyman(true, 1);
boogeyman(false, 2);
boogeyman(false, 2);
%OptimizeFunctionOnNextCall(boogeyman);
boogeyman(false, 2);
delete deopt.deopt;
boogeyman(false, 2);

47
deps/v8/test/mjsunit/regress/regress-319722-ArrayBuffer.js vendored Normal file
View File

@ -0,0 +1,47 @@
// Copyright 2013 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --nostress-opt --allow-natives-syntax
var maxSize = %MaxSmi() + 1;
var ab = new ArrayBuffer(maxSize);
function TestArray(constr) {
assertThrows(function() {
new constr(ab, 0, maxSize);
}, RangeError);
}
TestArray(Uint8Array);
TestArray(Int8Array);
TestArray(Uint16Array);
TestArray(Int16Array);
TestArray(Uint32Array);
TestArray(Int32Array);
TestArray(Float32Array);
TestArray(Float64Array);
TestArray(Uint8ClampedArray);

45
deps/v8/test/mjsunit/regress/regress-319722-TypedArrays.js vendored Normal file
View File

@ -0,0 +1,45 @@
// Copyright 2013 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Flags: --nostress-opt --allow-natives-syntax
var maxSize = %MaxSmi() + 1;
function TestArray(constr) {
assertThrows(function() {
new constr(maxSize);
}, RangeError);
}
TestArray(Uint8Array);
TestArray(Int8Array);
TestArray(Uint16Array);
TestArray(Int16Array);
TestArray(Uint32Array);
TestArray(Int32Array);
TestArray(Float32Array);
TestArray(Float64Array);
TestArray(Uint8ClampedArray);