Revision: 12943
Author: [email protected]
Date: Tue Nov 13 02:53:34 2012
Log: Revert change r12912
(http://code.google.com/p/v8/source/detail?r=12912) due to x64 perf issue
[email protected]
BUG=
Review URL: https://codereview.chromium.org/11312206
http://code.google.com/p/v8/source/detail?r=12943
Modified:
/branches/bleeding_edge/src/arm/lithium-arm.cc
/branches/bleeding_edge/src/ia32/lithium-codegen-ia32.cc
/branches/bleeding_edge/src/ia32/lithium-ia32.cc
/branches/bleeding_edge/src/ia32/lithium-ia32.h
/branches/bleeding_edge/src/x64/lithium-codegen-x64.cc
/branches/bleeding_edge/src/x64/lithium-codegen-x64.h
/branches/bleeding_edge/src/x64/lithium-x64.cc
/branches/bleeding_edge/src/x64/lithium-x64.h
=======================================
--- /branches/bleeding_edge/src/arm/lithium-arm.cc Fri Nov 9 02:21:07 2012
+++ /branches/bleeding_edge/src/arm/lithium-arm.cc Tue Nov 13 02:53:34 2012
@@ -1881,7 +1881,6 @@
(instr->representation().IsDouble() &&
((elements_kind == EXTERNAL_FLOAT_ELEMENTS) ||
(elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
-
LOperand* external_pointer = UseRegister(instr->elements());
result = new(zone()) LLoadKeyed(external_pointer, key);
}
@@ -1906,22 +1905,32 @@
LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
- LOperand* elements = UseRegisterAtStart(instr->elements());
- LOperand* key;
- LOperand* val;
- if (instr->NeedsWriteBarrier()) {
- key = UseTempRegister(instr->key());
- val = UseTempRegister(instr->value());
- } else {
- key = UseRegisterOrConstantAtStart(instr->key());
- val = UseRegisterAtStart(instr->value());
- }
+ ElementsKind elements_kind = instr->elements_kind();
+ bool needs_write_barrier = instr->NeedsWriteBarrier();
+ LOperand* key = needs_write_barrier
+ ? UseTempRegister(instr->key())
+ : UseRegisterOrConstantAtStart(instr->key());
+ bool val_is_temp_register =
+ elements_kind == EXTERNAL_PIXEL_ELEMENTS ||
+ elements_kind == EXTERNAL_FLOAT_ELEMENTS;
+ LOperand* val = val_is_temp_register || needs_write_barrier
+ ? UseTempRegister(instr->value())
+ : UseRegister(instr->value());
-#ifdef DEBUG
+ LStoreKeyed* result = NULL;
if (!instr->is_external()) {
ASSERT(instr->elements()->representation().IsTagged());
+
+ LOperand* object = NULL;
+ if (instr->value()->representation().IsDouble()) {
+ object = UseRegisterAtStart(instr->elements());
+ } else {
+ ASSERT(instr->value()->representation().IsTagged());
+ object = UseTempRegister(instr->elements());
+ }
+
+ result = new(zone()) LStoreKeyed(object, key, val);
} else {
- ElementsKind elements_kind = instr->elements_kind();
ASSERT(
(instr->value()->representation().IsInteger32() &&
(elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
@@ -1930,10 +1939,11 @@
((elements_kind == EXTERNAL_FLOAT_ELEMENTS) ||
(elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
ASSERT(instr->elements()->representation().IsExternal());
+
+ LOperand* external_pointer = UseRegister(instr->elements());
+ result = new(zone()) LStoreKeyed(external_pointer, key, val);
}
-#endif
- LStoreKeyed* result = new(zone()) LStoreKeyed(elements, key, val);
ASSERT(result != NULL);
return result;
}
=======================================
--- /branches/bleeding_edge/src/ia32/lithium-codegen-ia32.cc Fri Nov 9
05:04:51 2012
+++ /branches/bleeding_edge/src/ia32/lithium-codegen-ia32.cc Tue Nov 13
02:53:34 2012
@@ -2775,12 +2775,15 @@
void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
ElementsKind elements_kind = instr->elements_kind();
- if (ExternalArrayOpRequiresTemp<HLoadKeyed>(instr->hydrogen())) {
- __ SmiUntag(ToRegister(instr->key()));
+ LOperand* key = instr->key();
+ if (!key->IsConstantOperand() &&
+
ExternalArrayOpRequiresTemp(instr->hydrogen()->key()->representation(),
+ elements_kind)) {
+ __ SmiUntag(ToRegister(key));
}
Operand operand(BuildFastArrayOperand(
instr->elements(),
- instr->key(),
+ key,
instr->hydrogen()->key()->representation(),
elements_kind,
0,
@@ -3850,12 +3853,15 @@
void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
ElementsKind elements_kind = instr->elements_kind();
- if (ExternalArrayOpRequiresTemp<HStoreKeyed>(instr->hydrogen())) {
- __ SmiUntag(ToRegister(instr->key()));
+ LOperand* key = instr->key();
+ if (!key->IsConstantOperand() &&
+
ExternalArrayOpRequiresTemp(instr->hydrogen()->key()->representation(),
+ elements_kind)) {
+ __ SmiUntag(ToRegister(key));
}
Operand operand(BuildFastArrayOperand(
instr->elements(),
- instr->key(),
+ key,
instr->hydrogen()->key()->representation(),
elements_kind,
0,
=======================================
--- /branches/bleeding_edge/src/ia32/lithium-ia32.cc Fri Nov 9 02:21:07
2012
+++ /branches/bleeding_edge/src/ia32/lithium-ia32.cc Tue Nov 13 02:53:34
2012
@@ -1933,14 +1933,17 @@
ASSERT(instr->key()->representation().IsInteger32() ||
instr->key()->representation().IsTagged());
ElementsKind elements_kind = instr->elements_kind();
- LOperand* elements = UseRegisterAtStart(instr->elements());
- LOperand* key = instr->is_external() &&
- ExternalArrayOpRequiresTemp<HLoadKeyed>(instr)
+ bool clobbers_key = ExternalArrayOpRequiresTemp(
+ instr->key()->representation(), elements_kind);
+ LOperand* key = clobbers_key
? UseTempRegister(instr->key())
: UseRegisterOrConstantAtStart(instr->key());
+ LLoadKeyed* result = NULL;
-#ifdef DEBUG
- if (instr->is_external()) {
+ if (!instr->is_external()) {
+ LOperand* obj = UseRegisterAtStart(instr->elements());
+ result = new(zone()) LLoadKeyed(obj, key);
+ } else {
ASSERT(
(instr->representation().IsInteger32() &&
(elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
@@ -1948,10 +1951,10 @@
(instr->representation().IsDouble() &&
((elements_kind == EXTERNAL_FLOAT_ELEMENTS) ||
(elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
+ LOperand* external_pointer = UseRegister(instr->elements());
+ result = new(zone()) LLoadKeyed(external_pointer, key);
}
-#endif
- LLoadKeyed* result = new(zone()) LLoadKeyed(elements, key);
DefineAsRegister(result);
bool can_deoptimize = instr->RequiresHoleCheck() ||
(elements_kind == EXTERNAL_UNSIGNED_INT_ELEMENTS);
@@ -1973,27 +1976,34 @@
LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
- ElementsKind elements_kind = instr->elements_kind();
- LOperand* elements;
- LOperand* val;
- LOperand* key;
+ LStoreKeyed* result = NULL;
if (!instr->is_external()) {
ASSERT(instr->elements()->representation().IsTagged());
ASSERT(instr->key()->representation().IsInteger32() ||
instr->key()->representation().IsTagged());
- if (instr->NeedsWriteBarrier() &&
- !IsFastDoubleElementsKind(elements_kind)) {
- val = UseTempRegister(instr->value());
- key = UseTempRegister(instr->key());
- elements = UseRegister(instr->elements());
+ if (instr->value()->representation().IsDouble()) {
+ LOperand* object = UseRegisterAtStart(instr->elements());
+ LOperand* val = UseTempRegister(instr->value());
+ LOperand* key = UseRegisterOrConstantAtStart(instr->key());
+
+ result = new(zone()) LStoreKeyed(object, key, val);
} else {
- val = UseRegisterAtStart(instr->value());
- key = UseRegisterOrConstantAtStart(instr->key());
- elements = UseRegisterAtStart(instr->elements());
+ ASSERT(instr->value()->representation().IsTagged());
+ bool needs_write_barrier = instr->NeedsWriteBarrier();
+
+ LOperand* obj = UseRegister(instr->elements());
+ LOperand* val = needs_write_barrier
+ ? UseTempRegister(instr->value())
+ : UseRegisterAtStart(instr->value());
+ LOperand* key = needs_write_barrier
+ ? UseTempRegister(instr->key())
+ : UseRegisterOrConstantAtStart(instr->key());
+ result = new(zone()) LStoreKeyed(obj, key, val);
}
} else {
+ ElementsKind elements_kind = instr->elements_kind();
ASSERT(
(instr->value()->representation().IsInteger32() &&
(elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
@@ -2003,25 +2013,26 @@
(elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
ASSERT(instr->elements()->representation().IsExternal());
- if (ExternalArrayOpRequiresTemp<HStoreKeyed>(instr)) {
- key = UseTempRegister(instr->key());
- elements = UseRegister(instr->elements());
- } else {
- key = UseRegisterOrConstantAtStart(instr->key());
- elements = UseRegisterAtStart(instr->elements());
- }
-
+ LOperand* external_pointer = UseRegister(instr->elements());
// Determine if we need a byte register in this case for the value.
bool val_is_fixed_register =
elements_kind == EXTERNAL_BYTE_ELEMENTS ||
elements_kind == EXTERNAL_UNSIGNED_BYTE_ELEMENTS ||
elements_kind == EXTERNAL_PIXEL_ELEMENTS;
- val = val_is_fixed_register
+
+ LOperand* val = val_is_fixed_register
? UseFixed(instr->value(), eax)
: UseRegister(instr->value());
+ bool clobbers_key = ExternalArrayOpRequiresTemp(
+ instr->key()->representation(), elements_kind);
+ LOperand* key = clobbers_key
+ ? UseTempRegister(instr->key())
+ : UseRegisterOrConstantAtStart(instr->key());
+ result = new(zone()) LStoreKeyed(external_pointer,
+ key,
+ val);
}
- LStoreKeyed* result = new(zone()) LStoreKeyed(elements, key, val);
ASSERT(result != NULL);
return result;
}
=======================================
--- /branches/bleeding_edge/src/ia32/lithium-ia32.h Fri Nov 9 02:21:07 2012
+++ /branches/bleeding_edge/src/ia32/lithium-ia32.h Tue Nov 13 02:53:34 2012
@@ -1408,16 +1408,13 @@
};
-template <class T>
-inline static bool ExternalArrayOpRequiresTemp(T* value) {
- CHECK(value->IsLoadKeyed() || value->IsStoreKeyed());
- Representation key_representation = value->key()->representation();
- ElementsKind elements_kind = value->elements_kind();
-
+inline static bool ExternalArrayOpRequiresTemp(
+ Representation key_representation,
+ ElementsKind elements_kind) {
// Operations that require the key to be divided by two to be converted
into
// an index cannot fold the scale operation into a load and need an extra
// temp register to do the work.
- return !value->IsConstant() && key_representation.IsTagged() &&
+ return key_representation.IsTagged() &&
(elements_kind == EXTERNAL_BYTE_ELEMENTS ||
elements_kind == EXTERNAL_UNSIGNED_BYTE_ELEMENTS ||
elements_kind == EXTERNAL_PIXEL_ELEMENTS);
=======================================
--- /branches/bleeding_edge/src/x64/lithium-codegen-x64.cc Fri Nov 9
05:04:51 2012
+++ /branches/bleeding_edge/src/x64/lithium-codegen-x64.cc Tue Nov 13
02:53:34 2012
@@ -2624,30 +2624,24 @@
}
-template <class T>
-inline void LCodeGen::PrepareKeyForKeyedOp(T* hydrogen_instr, LOperand*
key) {
- if (ArrayOpClobbersKey<T>(hydrogen_instr)) {
+void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
+ ElementsKind elements_kind = instr->elements_kind();
+ LOperand* key = instr->key();
+ if (!key->IsConstantOperand()) {
+ Register key_reg = ToRegister(key);
// Even though the HLoad/StoreKeyed (in this case) instructions force
// the input representation for the key to be an integer, the input
// gets replaced during bound check elimination with the index argument
// to the bounds check, which can be tagged, so that case must be
// handled here, too.
- Register key_reg = ToRegister(key);
- if (hydrogen_instr->key()->representation().IsTagged()) {
+ if (instr->hydrogen()->key()->representation().IsTagged()) {
__ SmiToInteger64(key_reg, key_reg);
- } else if (hydrogen_instr->IsDehoisted()) {
+ } else if (instr->hydrogen()->IsDehoisted()) {
// Sign extend key because it could be a 32 bit negative value
// and the dehoisted address computation happens in 64 bits
__ movsxlq(key_reg, key_reg);
}
}
-}
-
-
-void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
- ElementsKind elements_kind = instr->elements_kind();
- LOperand* key = instr->key();
- PrepareKeyForKeyedOp(instr->hydrogen(), key);
Operand operand(BuildFastArrayOperand(
instr->elements(),
key,
@@ -2707,7 +2701,21 @@
void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
XMMRegister result(ToDoubleRegister(instr->result()));
LOperand* key = instr->key();
- PrepareKeyForKeyedOp<HLoadKeyed>(instr->hydrogen(), key);
+ if (!key->IsConstantOperand()) {
+ Register key_reg = ToRegister(key);
+ // Even though the HLoad/StoreKeyed instructions force the input
+ // representation for the key to be an integer, the input gets replaced
+ // during bound check elimination with the index argument to the bounds
+ // check, which can be tagged, so that case must be handled here, too.
+ if (instr->hydrogen()->key()->representation().IsTagged()) {
+ __ SmiToInteger64(key_reg, key_reg);
+ } else if (instr->hydrogen()->IsDehoisted()) {
+ // Sign extend key because it could be a 32 bit negative value
+ // and the dehoisted address computation happens in 64 bits
+ __ movsxlq(key_reg, key_reg);
+ }
+ }
+
if (instr->hydrogen()->RequiresHoleCheck()) {
int offset = FixedDoubleArray::kHeaderSize - kHeapObjectTag +
sizeof(kHoleNanLower32);
@@ -2734,7 +2742,21 @@
void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
Register result = ToRegister(instr->result());
LOperand* key = instr->key();
- PrepareKeyForKeyedOp<HLoadKeyed>(instr->hydrogen(), key);
+ if (!key->IsConstantOperand()) {
+ Register key_reg = ToRegister(key);
+ // Even though the HLoad/StoreKeyedFastElement instructions force
+ // the input representation for the key to be an integer, the input
+ // gets replaced during bound check elimination with the index
+ // argument to the bounds check, which can be tagged, so that
+ // case must be handled here, too.
+ if (instr->hydrogen()->key()->representation().IsTagged()) {
+ __ SmiToInteger64(key_reg, key_reg);
+ } else if (instr->hydrogen()->IsDehoisted()) {
+ // Sign extend key because it could be a 32 bit negative value
+ // and the dehoisted address computation happens in 64 bits
+ __ movsxlq(key_reg, key_reg);
+ }
+ }
// Load the result.
__ movq(result,
@@ -3729,7 +3751,21 @@
void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
ElementsKind elements_kind = instr->elements_kind();
LOperand* key = instr->key();
- PrepareKeyForKeyedOp<HStoreKeyed>(instr->hydrogen(), key);
+ if (!key->IsConstantOperand()) {
+ Register key_reg = ToRegister(key);
+ // Even though the HLoad/StoreKeyedFastElement instructions force
+ // the input representation for the key to be an integer, the input
+ // gets replaced during bound check elimination with the index
+ // argument to the bounds check, which can be tagged, so that case
+ // must be handled here, too.
+ if (instr->hydrogen()->key()->representation().IsTagged()) {
+ __ SmiToInteger64(key_reg, key_reg);
+ } else if (instr->hydrogen()->IsDehoisted()) {
+ // Sign extend key because it could be a 32 bit negative value
+ // and the dehoisted address computation happens in 64 bits
+ __ movsxlq(key_reg, key_reg);
+ }
+ }
Operand operand(BuildFastArrayOperand(
instr->elements(),
key,
@@ -3779,7 +3815,22 @@
void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
XMMRegister value = ToDoubleRegister(instr->value());
LOperand* key = instr->key();
- PrepareKeyForKeyedOp<HStoreKeyed>(instr->hydrogen(), key);
+ if (!key->IsConstantOperand()) {
+ Register key_reg = ToRegister(key);
+ // Even though the HLoad/StoreKeyedFastElement instructions force
+ // the input representation for the key to be an integer, the
+ // input gets replaced during bound check elimination with the index
+ // argument to the bounds check, which can be tagged, so that case
+ // must be handled here, too.
+ if (instr->hydrogen()->key()->representation().IsTagged()) {
+ __ SmiToInteger64(key_reg, key_reg);
+ } else if (instr->hydrogen()->IsDehoisted()) {
+ // Sign extend key because it could be a 32 bit negative value
+ // and the dehoisted address computation happens in 64 bits
+ __ movsxlq(key_reg, key_reg);
+ }
+ }
+
if (instr->NeedsCanonicalization()) {
Label have_value;
@@ -3808,7 +3859,21 @@
Register value = ToRegister(instr->value());
Register elements = ToRegister(instr->elements());
LOperand* key = instr->key();
- PrepareKeyForKeyedOp<HStoreKeyed>(instr->hydrogen(), key);
+ if (!key->IsConstantOperand()) {
+ Register key_reg = ToRegister(key);
+ // Even though the HLoad/StoreKeyedFastElement instructions force
+ // the input representation for the key to be an integer, the
+ // input gets replaced during bound check elimination with the index
+ // argument to the bounds check, which can be tagged, so that case
+ // must be handled here, too.
+ if (instr->hydrogen()->key()->representation().IsTagged()) {
+ __ SmiToInteger64(key_reg, key_reg);
+ } else if (instr->hydrogen()->IsDehoisted()) {
+ // Sign extend key because it could be a 32 bit negative value
+ // and the dehoisted address computation happens in 64 bits
+ __ movsxlq(key_reg, key_reg);
+ }
+ }
Operand operand =
BuildFastArrayOperand(instr->elements(),
=======================================
--- /branches/bleeding_edge/src/x64/lithium-codegen-x64.h Fri Nov 9
02:21:07 2012
+++ /branches/bleeding_edge/src/x64/lithium-codegen-x64.h Tue Nov 13
02:53:34 2012
@@ -341,8 +341,6 @@
void DoStoreKeyedExternalArray(LStoreKeyed* instr);
void DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr);
void DoStoreKeyedFixedArray(LStoreKeyed* instr);
- template <class T>
- void PrepareKeyForKeyedOp(T* hydrogen_instr, LOperand* key);
Zone* zone_;
LPlatformChunk* const chunk_;
=======================================
--- /branches/bleeding_edge/src/x64/lithium-x64.cc Fri Nov 9 02:21:07 2012
+++ /branches/bleeding_edge/src/x64/lithium-x64.cc Tue Nov 13 02:53:34 2012
@@ -1844,15 +1844,16 @@
ASSERT(instr->key()->representation().IsInteger32() ||
instr->key()->representation().IsTagged());
ElementsKind elements_kind = instr->elements_kind();
- bool clobbers_key = ArrayOpClobbersKey<HLoadKeyed>(instr);
+ bool clobbers_key = instr->key()->representation().IsTagged();
LOperand* key = clobbers_key
? UseTempRegister(instr->key())
: UseRegisterOrConstantAtStart(instr->key());
- LOperand* elements = UseRegisterAtStart(instr->elements());
- LLoadKeyed* result = new(zone()) LLoadKeyed(elements, key);
+ LLoadKeyed* result = NULL;
-#ifdef DEBUG
- if (instr->is_external()) {
+ if (!instr->is_external()) {
+ LOperand* obj = UseRegisterAtStart(instr->elements());
+ result = new(zone()) LLoadKeyed(obj, key);
+ } else {
ASSERT(
(instr->representation().IsInteger32() &&
(elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
@@ -1860,8 +1861,9 @@
(instr->representation().IsDouble() &&
((elements_kind == EXTERNAL_FLOAT_ELEMENTS) ||
(elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
+ LOperand* external_pointer = UseRegister(instr->elements());
+ result = new(zone()) LLoadKeyed(external_pointer, key);
}
-#endif
DefineAsRegister(result);
bool can_deoptimize = instr->RequiresHoleCheck() ||
@@ -1882,21 +1884,33 @@
LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
+ ElementsKind elements_kind = instr->elements_kind();
bool needs_write_barrier = instr->NeedsWriteBarrier();
- bool clobbers_key = ArrayOpClobbersKey<HStoreKeyed>(instr);
+ bool clobbers_key = instr->key()->representation().IsTagged();
LOperand* key = (clobbers_key || needs_write_barrier)
? UseTempRegister(instr->key())
: UseRegisterOrConstantAtStart(instr->key());
- LOperand* val = needs_write_barrier
+ bool val_is_temp_register =
+ elements_kind == EXTERNAL_PIXEL_ELEMENTS ||
+ elements_kind == EXTERNAL_FLOAT_ELEMENTS;
+ LOperand* val = (needs_write_barrier || val_is_temp_register)
? UseTempRegister(instr->value())
: UseRegisterAtStart(instr->value());
- LOperand* elements = UseRegisterAtStart(instr->elements());
+ LStoreKeyed* result = NULL;
-#ifdef DEBUG
if (!instr->is_external()) {
ASSERT(instr->elements()->representation().IsTagged());
+
+ LOperand* object = NULL;
+ if (instr->value()->representation().IsDouble()) {
+ object = UseRegisterAtStart(instr->elements());
+ } else {
+ ASSERT(instr->value()->representation().IsTagged());
+ object = UseTempRegister(instr->elements());
+ }
+
+ result = new(zone()) LStoreKeyed(object, key, val);
} else {
- ElementsKind elements_kind = instr->elements_kind();
ASSERT(
(instr->value()->representation().IsInteger32() &&
(elements_kind != EXTERNAL_FLOAT_ELEMENTS) &&
@@ -1905,10 +1919,11 @@
((elements_kind == EXTERNAL_FLOAT_ELEMENTS) ||
(elements_kind == EXTERNAL_DOUBLE_ELEMENTS))));
ASSERT(instr->elements()->representation().IsExternal());
+
+ LOperand* external_pointer = UseRegister(instr->elements());
+ result = new(zone()) LStoreKeyed(external_pointer, key, val);
}
-#endif
- LStoreKeyed* result = new(zone()) LStoreKeyed(elements, key, val);
ASSERT(result != NULL);
return result;
}
=======================================
--- /branches/bleeding_edge/src/x64/lithium-x64.h Fri Nov 9 02:21:07 2012
+++ /branches/bleeding_edge/src/x64/lithium-x64.h Tue Nov 13 02:53:34 2012
@@ -1369,14 +1369,6 @@
return hydrogen()->elements_kind();
}
};
-
-
-template <class T>
-inline static bool ArrayOpClobbersKey(T *value) {
- CHECK(value->IsLoadKeyed() || value->IsStoreKeyed());
- return !value->IsConstant() && (value->key()->representation().IsTagged()
- || value->IsDehoisted());
-}
class LLoadKeyedGeneric: public LTemplateInstruction<1, 2, 0> {
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
