Reviewers: William Hesse,
Description:
Add InternalArrayCodeGeneric
[email protected]
BUG=none
TEST=none
Please review this at http://codereview.chromium.org/9006051/
SVN Base: https://v8.googlecode.com/svn/branches/bleeding_edge
Affected files:
M src/arguments.h
M src/arm/builtins-arm.cc
M src/builtins.h
M src/builtins.cc
M src/ia32/builtins-ia32.cc
M src/objects-inl.h
M src/objects.h
M src/objects.cc
M src/v8natives.js
M src/x64/builtins-x64.cc
Index: src/arguments.h
diff --git a/src/arguments.h b/src/arguments.h
index
e9a32702cfeea70225cac7540a5c129c4bf14cd9..d142902d22750f8b8db8114ef2c10ebb70979993
100644
--- a/src/arguments.h
+++ b/src/arguments.h
@@ -1,4 +1,4 @@
-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Copyright 2011 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:
@@ -55,19 +55,25 @@ class Arguments BASE_EMBEDDED {
return arguments_[-index];
}
- template <class S> Handle<S> at(int index) {
- Object** value = &((*this)[index]);
+ Object* operator[] (int index) const {
+ ASSERT(0 <= index && index < length_);
+ return arguments_[-index];
+ }
+
+ template <class S> Handle<S> at(int index) const {
+ ASSERT(0 <= index && index < length_);
+ Object** value = arguments_ - index;
// This cast checks that the object we're accessing does indeed have
the
// expected type.
S::cast(*value);
return Handle<S>(reinterpret_cast<S**>(value));
}
- int smi_at(int index) {
+ int smi_at(int index) const {
return Smi::cast((*this)[index])->value();
}
- double number_at(int index) {
+ double number_at(int index) const {
return (*this)[index]->Number();
}
@@ -76,6 +82,8 @@ class Arguments BASE_EMBEDDED {
Object** arguments() { return arguments_; }
+ Object* const * arguments() const { return arguments_; }
+
private:
int length_;
Object** arguments_;
Index: src/arm/builtins-arm.cc
diff --git a/src/arm/builtins-arm.cc b/src/arm/builtins-arm.cc
index
71fa82d42cebfb686b8d47c6e80c27c7f4222f6d..c452821ff64d20b9a2092d0242db424306a9b858
100644
--- a/src/arm/builtins-arm.cc
+++ b/src/arm/builtins-arm.cc
@@ -463,7 +463,7 @@ void
Builtins::Generate_InternalArrayCode(MacroAssembler* masm) {
__ bind(&generic_array_code);
Handle<Code> array_code =
- masm->isolate()->builtins()->ArrayCodeGeneric();
+ masm->isolate()->builtins()->InternalArrayCodeGeneric();
__ Jump(array_code, RelocInfo::CODE_TARGET);
}
Index: src/builtins.cc
diff --git a/src/builtins.cc b/src/builtins.cc
index
4d874c54ff5fa986c12aa2822205888a6338d05b..d7baa2a0416093edf69213db746908d95f577502
100644
--- a/src/builtins.cc
+++ b/src/builtins.cc
@@ -184,17 +184,17 @@ BUILTIN(EmptyFunction) {
}
-BUILTIN(ArrayCodeGeneric) {
+static MaybeObject* ArrayCodeGenericCommon(const Arguments& args,
+ Isolate* isolate,
+ JSFunction* constructor) {
Heap* heap = isolate->heap();
isolate->counters()->array_function_runtime()->Increment();
JSArray* array;
if (CalledAsConstructor(isolate)) {
- array = JSArray::cast(*args.receiver());
+ array = JSArray::cast(args[0]);
} else {
// Allocate the JS Array
- JSFunction* constructor =
- isolate->context()->global_context()->array_function();
Object* obj;
{ MaybeObject* maybe_obj = heap->AllocateJSObject(constructor);
if (!maybe_obj->ToObject(&obj)) return maybe_obj;
@@ -202,9 +202,6 @@ BUILTIN(ArrayCodeGeneric) {
array = JSArray::cast(obj);
}
- // 'array' now contains the JSArray we should initialize.
- ASSERT(array->HasFastTypeElements());
-
// Optimize the case where there is one argument and the argument is a
// small smi.
if (args.length() == 2) {
@@ -236,7 +233,7 @@ BUILTIN(ArrayCodeGeneric) {
// Set length and elements on the array.
int number_of_elements = args.length() - 1;
MaybeObject* maybe_object =
- array->EnsureCanContainElements(&args, 1, number_of_elements,
+ array->EnsureCanContainElements(args, 1, number_of_elements,
ALLOW_CONVERTED_DOUBLE_ELEMENTS);
if (maybe_object->IsFailure()) return maybe_object;
@@ -288,6 +285,22 @@ BUILTIN(ArrayCodeGeneric) {
}
+BUILTIN(InternalArrayCodeGeneric) {
+ return ArrayCodeGenericCommon(
+ args,
+ isolate,
+ isolate->context()->global_context()->internal_array_function());
+}
+
+
+BUILTIN(ArrayCodeGeneric) {
+ return ArrayCodeGenericCommon(
+ args,
+ isolate,
+ isolate->context()->global_context()->array_function());
+}
+
+
MUST_USE_RESULT static MaybeObject* AllocateJSArray(Heap* heap) {
JSFunction* array_function =
heap->isolate()->context()->global_context()->array_function();
@@ -424,7 +437,7 @@ static bool ArrayPrototypeHasNoElements(Heap* heap,
MUST_USE_RESULT
static inline MaybeObject* EnsureJSArrayWithWritableFastElements(
- Heap* heap, Object* receiver, Arguments* args, int first_added_arg) {
+ Heap* heap, Object* receiver, const Arguments* args, int
first_added_arg) {
if (!receiver->IsJSArray()) return NULL;
JSArray* array = JSArray::cast(receiver);
HeapObject* elms = array->elements();
@@ -449,7 +462,7 @@ static inline MaybeObject*
EnsureJSArrayWithWritableFastElements(
if (first_added_arg >= args_length) return array->elements();
MaybeObject* maybe_array = array->EnsureCanContainElements(
- args,
+ *args,
first_added_arg,
args_length - first_added_arg,
DONT_ALLOW_DOUBLE_ELEMENTS);
@@ -655,7 +668,7 @@ BUILTIN(ArrayUnshift) {
ASSERT(to_add <= (Smi::kMaxValue - len));
MaybeObject* maybe_object =
- array->EnsureCanContainElements(&args, 1, to_add,
+ array->EnsureCanContainElements(args, 1, to_add,
DONT_ALLOW_DOUBLE_ELEMENTS);
if (maybe_object->IsFailure()) return maybe_object;
Index: src/builtins.h
diff --git a/src/builtins.h b/src/builtins.h
index
a85797b17872eef5c7674c0dc9ad429c0ac1edc9..6a84f2ddd19f805b4a42c6a083d5279d3f9ded05
100644
--- a/src/builtins.h
+++ b/src/builtins.h
@@ -44,6 +44,7 @@ enum BuiltinExtraArguments {
\
V(EmptyFunction, NO_EXTRA_ARGUMENTS) \
\
+ V(InternalArrayCodeGeneric, NO_EXTRA_ARGUMENTS) \
V(ArrayCodeGeneric, NO_EXTRA_ARGUMENTS) \
\
V(ArrayPush, NO_EXTRA_ARGUMENTS) \
Index: src/ia32/builtins-ia32.cc
diff --git a/src/ia32/builtins-ia32.cc b/src/ia32/builtins-ia32.cc
index
1d6064facd87d3123bc96b000c4be057bc477c38..3d274f2e6b8130ab671634b9ab0856b195af519b
100644
--- a/src/ia32/builtins-ia32.cc
+++ b/src/ia32/builtins-ia32.cc
@@ -1337,7 +1337,7 @@ void
Builtins::Generate_InternalArrayCode(MacroAssembler* masm) {
// the construction.
__ bind(&generic_array_code);
Handle<Code> array_code =
- masm->isolate()->builtins()->ArrayCodeGeneric();
+ masm->isolate()->builtins()->InternalArrayCodeGeneric();
__ jmp(array_code, RelocInfo::CODE_TARGET);
}
Index: src/objects-inl.h
diff --git a/src/objects-inl.h b/src/objects-inl.h
index
7c7f0940067ad7500c80d1ed416f38c818e7f192..ab3cbeb43f4718fd0b5ed90b0598e219b197c9bd
100644
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -1238,7 +1238,7 @@ MaybeObject*
JSObject::EnsureCanContainHeapObjectElements() {
}
-MaybeObject* JSObject::EnsureCanContainElements(Object** objects,
+MaybeObject* JSObject::EnsureCanContainElements(Object* const * objects,
uint32_t count,
EnsureElementsMode mode) {
ElementsKind current_kind = map()->elements_kind();
Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index
ae5aa78cae57fc078a87ed41d290a3c9b10a1597..ccbf017f0267bb30bc3fa357f2154391d447e2e1
100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -8526,7 +8526,7 @@ MaybeObject* JSReceiver::SetPrototype(Object* value,
}
-MaybeObject* JSObject::EnsureCanContainElements(Arguments* args,
+MaybeObject* JSObject::EnsureCanContainElements(const Arguments& args,
uint32_t first_arg,
uint32_t arg_count,
EnsureElementsMode mode) {
@@ -8534,7 +8534,7 @@ MaybeObject*
JSObject::EnsureCanContainElements(Arguments* args,
// stack), but the method that's called here iterates over them in
forward
// direction.
return EnsureCanContainElements(
- args->arguments() - first_arg - (arg_count - 1),
+ args.arguments() - first_arg - (arg_count - 1),
arg_count, mode);
}
Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index
5346585bd3e0aad0e7bcf6b2b49cdc6680ecb315..f7cfecc4f7456626eb71c3bd322b6c999b74345a
100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -1625,12 +1625,12 @@ class JSObject: public JSReceiver {
inline MaybeObject* EnsureCanContainHeapObjectElements();
// Makes sure that this object can contain the specified elements.
- inline MaybeObject* EnsureCanContainElements(Object** elements,
+ inline MaybeObject* EnsureCanContainElements(Object* const * elements,
uint32_t count,
EnsureElementsMode mode);
inline MaybeObject* EnsureCanContainElements(FixedArrayBase* elements,
EnsureElementsMode mode);
- MaybeObject* EnsureCanContainElements(Arguments* arguments,
+ MaybeObject* EnsureCanContainElements(const Arguments& arguments,
uint32_t first_arg,
uint32_t arg_count,
EnsureElementsMode mode);
Index: src/v8natives.js
diff --git a/src/v8natives.js b/src/v8natives.js
index
1d54e28e97687ca981372b41525ffbed6b150e3a..9dae36b7fe2db75d905d0131b481eec512a3fde8
100644
--- a/src/v8natives.js
+++ b/src/v8natives.js
@@ -1,3 +1,4 @@
+
// Copyright 2011 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
Index: src/x64/builtins-x64.cc
diff --git a/src/x64/builtins-x64.cc b/src/x64/builtins-x64.cc
index
74c7add97306bca3420a333ff0b23644d5e2200b..dff55fb74de9fe3b67203d935c922b83d7227205
100644
--- a/src/x64/builtins-x64.cc
+++ b/src/x64/builtins-x64.cc
@@ -1357,7 +1357,7 @@ void
Builtins::Generate_InternalArrayCode(MacroAssembler* masm) {
// the construction.
__ bind(&generic_array_code);
Handle<Code> array_code =
- masm->isolate()->builtins()->ArrayCodeGeneric();
+ masm->isolate()->builtins()->InternalArrayCodeGeneric();
__ Jump(array_code, RelocInfo::CODE_TARGET);
}
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
