Revision: 15358
Author: [email protected]
Date: Thu Jun 27 06:39:44 2013
Log: The check for internalized strings relied on the fact that we had
less
than 64 distinct InstanceTypes. We are hitting that boundary, so this
check needs to be more comprehensive. In fact, two bits need to be
tested: verify that kNotStringTag isn't set, and that kInternalizedTag
is set.
BUG=
[email protected]
Review URL: https://codereview.chromium.org/17895002
http://code.google.com/p/v8/source/detail?r=15358
Modified:
/branches/bleeding_edge/src/arm/code-stubs-arm.cc
/branches/bleeding_edge/src/arm/ic-arm.cc
/branches/bleeding_edge/src/arm/macro-assembler-arm.cc
/branches/bleeding_edge/src/arm/macro-assembler-arm.h
/branches/bleeding_edge/src/ia32/code-stubs-ia32.cc
/branches/bleeding_edge/src/ia32/ic-ia32.cc
/branches/bleeding_edge/src/ia32/macro-assembler-ia32.cc
/branches/bleeding_edge/src/ia32/macro-assembler-ia32.h
/branches/bleeding_edge/src/objects-inl.h
/branches/bleeding_edge/src/objects.h
/branches/bleeding_edge/src/x64/code-stubs-x64.cc
/branches/bleeding_edge/src/x64/ic-x64.cc
/branches/bleeding_edge/src/x64/macro-assembler-x64.cc
/branches/bleeding_edge/src/x64/macro-assembler-x64.h
=======================================
--- /branches/bleeding_edge/src/arm/code-stubs-arm.cc Tue Jun 25 09:31:07
2013
+++ /branches/bleeding_edge/src/arm/code-stubs-arm.cc Thu Jun 27 06:39:44
2013
@@ -892,12 +892,17 @@
// Now that we have the types we might as well check for
// internalized-internalized.
- // Ensure that no non-strings have the internalized bit set.
- STATIC_ASSERT(LAST_TYPE < kNotStringTag + kIsInternalizedMask);
+ Label not_internalized;
STATIC_ASSERT(kInternalizedTag != 0);
- __ and_(r2, r2, Operand(r3));
- __ tst(r2, Operand(kIsInternalizedMask));
- __ b(ne, &return_not_equal);
+ __ and_(r2, r2, Operand(kIsNotStringMask | kIsInternalizedMask));
+ __ cmp(r2, Operand(kInternalizedTag | kStringTag));
+ __ b(ne, ¬_internalized); // r2 (rhs) is not an internalized string
+
+ __ and_(r3, r3, Operand(kIsNotStringMask | kIsInternalizedMask));
+ __ cmp(r3, Operand(kInternalizedTag | kStringTag));
+ __ b(eq, &return_not_equal); // both rhs and lhs are internalized
strings
+
+ __ bind(¬_internalized);
}
@@ -937,7 +942,6 @@
(lhs.is(r1) && rhs.is(r0)));
// r2 is object type of rhs.
- // Ensure that no non-strings have the internalized bit set.
Label object_test;
STATIC_ASSERT(kInternalizedTag != 0);
__ tst(r2, Operand(kIsNotStringMask));
@@ -6213,9 +6217,14 @@
__ ldrb(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
__ ldrb(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
STATIC_ASSERT(kInternalizedTag != 0);
- __ and_(tmp1, tmp1, Operand(tmp2));
- __ tst(tmp1, Operand(kIsInternalizedMask));
- __ b(eq, &miss);
+
+ __ and_(tmp1, tmp1, Operand(kIsNotStringMask | kIsInternalizedMask));
+ __ cmp(tmp1, Operand(kInternalizedTag | kStringTag));
+ __ b(ne, &miss);
+
+ __ and_(tmp2, tmp2, Operand(kIsNotStringMask | kIsInternalizedMask));
+ __ cmp(tmp2, Operand(kInternalizedTag | kStringTag));
+ __ b(ne, &miss);
// Internalized strings are compared by identity.
__ cmp(left, right);
@@ -6254,19 +6263,8 @@
__ ldrb(tmp1, FieldMemOperand(tmp1, Map::kInstanceTypeOffset));
__ ldrb(tmp2, FieldMemOperand(tmp2, Map::kInstanceTypeOffset));
- Label succeed1;
- __ tst(tmp1, Operand(kIsInternalizedMask));
- __ b(ne, &succeed1);
- __ cmp(tmp1, Operand(SYMBOL_TYPE));
- __ b(ne, &miss);
- __ bind(&succeed1);
-
- Label succeed2;
- __ tst(tmp2, Operand(kIsInternalizedMask));
- __ b(ne, &succeed2);
- __ cmp(tmp2, Operand(SYMBOL_TYPE));
- __ b(ne, &miss);
- __ bind(&succeed2);
+ __ JumpIfNotUniqueName(tmp1, &miss);
+ __ JumpIfNotUniqueName(tmp2, &miss);
// Unique names are compared by identity.
__ cmp(left, right);
@@ -6321,7 +6319,8 @@
// Handle not identical strings.
// Check that both strings are internalized strings. If they are, we're
done
- // because we already know they are not identical.
+ // because we already know they are not identical. We know they are both
+ // strings.
if (equality) {
ASSERT(GetCondition() == eq);
STATIC_ASSERT(kInternalizedTag != 0);
@@ -6507,11 +6506,7 @@
__ ldr(entity_name, FieldMemOperand(entity_name,
HeapObject::kMapOffset));
__ ldrb(entity_name,
FieldMemOperand(entity_name, Map::kInstanceTypeOffset));
- __ tst(entity_name, Operand(kIsInternalizedMask));
- __ b(ne, &good);
- __ cmp(entity_name, Operand(SYMBOL_TYPE));
- __ b(ne, miss);
-
+ __ JumpIfNotUniqueName(entity_name, miss);
__ bind(&good);
// Restore the properties.
@@ -6678,15 +6673,10 @@
if (i != kTotalProbes - 1 && mode_ == NEGATIVE_LOOKUP) {
// Check if the entry name is not a unique name.
- Label cont;
__ ldr(entry_key, FieldMemOperand(entry_key,
HeapObject::kMapOffset));
__ ldrb(entry_key,
FieldMemOperand(entry_key, Map::kInstanceTypeOffset));
- __ tst(entry_key, Operand(kIsInternalizedMask));
- __ b(ne, &cont);
- __ cmp(entry_key, Operand(SYMBOL_TYPE));
- __ b(ne, &maybe_in_dictionary);
- __ bind(&cont);
+ __ JumpIfNotUniqueName(entry_key, &maybe_in_dictionary);
}
}
=======================================
--- /branches/bleeding_edge/src/arm/ic-arm.cc Fri Jun 14 04:21:34 2013
+++ /branches/bleeding_edge/src/arm/ic-arm.cc Thu Jun 27 06:39:44 2013
@@ -321,7 +321,8 @@
__ tst(hash, Operand(Name::kContainsCachedArrayIndexMask));
__ b(eq, index_string);
- // Is the string internalized?
+ // Is the string internalized? We know it's a string, so a single
+ // bit test is enough.
// map: key map
__ ldrb(hash, FieldMemOperand(map, Map::kInstanceTypeOffset));
STATIC_ASSERT(kInternalizedTag != 0);
=======================================
--- /branches/bleeding_edge/src/arm/macro-assembler-arm.cc Thu Jun 13
12:16:35 2013
+++ /branches/bleeding_edge/src/arm/macro-assembler-arm.cc Thu Jun 27
06:39:44 2013
@@ -3087,6 +3087,16 @@
scratch2,
failure);
}
+
+
+void MacroAssembler::JumpIfNotUniqueName(Register reg,
+ Label* not_unique_name) {
+ STATIC_ASSERT(((SYMBOL_TYPE - 1) & kIsInternalizedMask) ==
kInternalizedTag);
+ cmp(reg, Operand(kInternalizedTag));
+ b(lt, not_unique_name);
+ cmp(reg, Operand(SYMBOL_TYPE));
+ b(gt, not_unique_name);
+}
// Allocates a heap number or jumps to the need_gc label if the young space
=======================================
--- /branches/bleeding_edge/src/arm/macro-assembler-arm.h Thu Jun 13
12:16:35 2013
+++ /branches/bleeding_edge/src/arm/macro-assembler-arm.h Thu Jun 27
06:39:44 2013
@@ -1296,6 +1296,7 @@
Register scratch,
Label* failure);
+ void JumpIfNotUniqueName(Register reg, Label* not_unique_name);
//
---------------------------------------------------------------------------
// Patching helpers.
=======================================
--- /branches/bleeding_edge/src/ia32/code-stubs-ia32.cc Tue Jun 25 09:31:07
2013
+++ /branches/bleeding_edge/src/ia32/code-stubs-ia32.cc Thu Jun 27 06:39:44
2013
@@ -6853,9 +6853,13 @@
__ movzx_b(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
__ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
STATIC_ASSERT(kInternalizedTag != 0);
- __ and_(tmp1, tmp2);
- __ test(tmp1, Immediate(kIsInternalizedMask));
- __ j(zero, &miss, Label::kNear);
+ __ and_(tmp1, Immediate(kIsNotStringMask | kIsInternalizedMask));
+ __ cmpb(tmp1, kInternalizedTag | kStringTag);
+ __ j(not_equal, &miss, Label::kNear);
+
+ __ and_(tmp2, Immediate(kIsNotStringMask | kIsInternalizedMask));
+ __ cmpb(tmp2, kInternalizedTag | kStringTag);
+ __ j(not_equal, &miss, Label::kNear);
// Internalized strings are compared by identity.
Label done;
@@ -6900,19 +6904,8 @@
__ movzx_b(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
__ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
- Label succeed1;
- __ test(tmp1, Immediate(kIsInternalizedMask));
- __ j(not_zero, &succeed1);
- __ cmpb(tmp1, static_cast<uint8_t>(SYMBOL_TYPE));
- __ j(not_equal, &miss);
- __ bind(&succeed1);
-
- Label succeed2;
- __ test(tmp2, Immediate(kIsInternalizedMask));
- __ j(not_zero, &succeed2);
- __ cmpb(tmp2, static_cast<uint8_t>(SYMBOL_TYPE));
- __ j(not_equal, &miss);
- __ bind(&succeed2);
+ __ JumpIfNotUniqueName(tmp1, &miss, Label::kNear);
+ __ JumpIfNotUniqueName(tmp2, &miss, Label::kNear);
// Unique names are compared by identity.
Label done;
@@ -6977,7 +6970,8 @@
// Check that both strings are internalized. If they are, we're done
// because we already know they are not identical. But in the case of
- // non-equality compare, we still need to determine the order.
+ // non-equality compare, we still need to determine the order. We
+ // also know they are both strings.
if (equality) {
Label do_compare;
STATIC_ASSERT(kInternalizedTag != 0);
@@ -7136,12 +7130,8 @@
// Check if the entry name is not a unique name.
__ mov(entity_name, FieldOperand(entity_name, HeapObject::kMapOffset));
- __ test_b(FieldOperand(entity_name, Map::kInstanceTypeOffset),
- kIsInternalizedMask);
- __ j(not_zero, &good);
- __ cmpb(FieldOperand(entity_name, Map::kInstanceTypeOffset),
- static_cast<uint8_t>(SYMBOL_TYPE));
- __ j(not_equal, miss);
+ __ JumpIfNotUniqueName(FieldOperand(entity_name,
Map::kInstanceTypeOffset),
+ miss);
__ bind(&good);
}
@@ -7274,15 +7264,9 @@
// key we are looking for.
// Check if the entry name is not a unique name.
- Label cont;
__ mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
- __ test_b(FieldOperand(scratch, Map::kInstanceTypeOffset),
- kIsInternalizedMask);
- __ j(not_zero, &cont);
- __ cmpb(FieldOperand(scratch, Map::kInstanceTypeOffset),
- static_cast<uint8_t>(SYMBOL_TYPE));
- __ j(not_equal, &maybe_in_dictionary);
- __ bind(&cont);
+ __ JumpIfNotUniqueName(FieldOperand(scratch,
Map::kInstanceTypeOffset),
+ &maybe_in_dictionary);
}
}
=======================================
--- /branches/bleeding_edge/src/ia32/ic-ia32.cc Fri Jun 14 04:21:34 2013
+++ /branches/bleeding_edge/src/ia32/ic-ia32.cc Thu Jun 27 06:39:44 2013
@@ -317,7 +317,8 @@
__ test(hash, Immediate(Name::kContainsCachedArrayIndexMask));
__ j(zero, index_string);
- // Is the string internalized?
+ // Is the string internalized? We already know it's a string so a single
+ // bit test is enough.
STATIC_ASSERT(kInternalizedTag != 0);
__ test_b(FieldOperand(map, Map::kInstanceTypeOffset),
kIsInternalizedMask);
__ j(zero, not_unique);
=======================================
--- /branches/bleeding_edge/src/ia32/macro-assembler-ia32.cc Thu Jun 13
12:16:35 2013
+++ /branches/bleeding_edge/src/ia32/macro-assembler-ia32.cc Thu Jun 27
06:39:44 2013
@@ -2805,6 +2805,17 @@
cmp(scratch1, kFlatAsciiStringTag | (kFlatAsciiStringTag << 3));
j(not_equal, failure);
}
+
+
+void MacroAssembler::JumpIfNotUniqueName(Operand operand,
+ Label* not_unique_name,
+ Label::Distance distance) {
+ STATIC_ASSERT(((SYMBOL_TYPE - 1) & kIsInternalizedMask) ==
kInternalizedTag);
+ cmp(operand, Immediate(kInternalizedTag));
+ j(less, not_unique_name, distance);
+ cmp(operand, Immediate(SYMBOL_TYPE));
+ j(greater, not_unique_name, distance);
+}
void MacroAssembler::PrepareCallCFunction(int num_arguments, Register
scratch) {
=======================================
--- /branches/bleeding_edge/src/ia32/macro-assembler-ia32.h Thu Jun 13
12:16:35 2013
+++ /branches/bleeding_edge/src/ia32/macro-assembler-ia32.h Thu Jun 27
06:39:44 2013
@@ -884,6 +884,15 @@
Register scratch2,
Label*
on_not_flat_ascii_strings);
+ // Checks if the given register or operand is a unique name
+ void JumpIfNotUniqueName(Register reg, Label* not_unique_name,
+ Label::Distance distance = Label::kFar) {
+ JumpIfNotUniqueName(Operand(reg), not_unique_name, distance);
+ }
+
+ void JumpIfNotUniqueName(Operand operand, Label* not_unique_name,
+ Label::Distance distance = Label::kFar);
+
static int SafepointRegisterStackIndex(Register reg) {
return SafepointRegisterStackIndex(reg.code());
}
=======================================
--- /branches/bleeding_edge/src/objects-inl.h Wed Jun 26 09:17:12 2013
+++ /branches/bleeding_edge/src/objects-inl.h Thu Jun 27 06:39:44 2013
@@ -221,12 +221,9 @@
bool Object::IsInternalizedString() {
if (!this->IsHeapObject()) return false;
uint32_t type = HeapObject::cast(this)->map()->instance_type();
- // Because the internalized tag is non-zero and no non-string types have
the
- // internalized bit set we can test for internalized strings with a very
- // simple test operation.
STATIC_ASSERT(kInternalizedTag != 0);
- ASSERT(kNotStringTag + kIsInternalizedMask > LAST_TYPE);
- return (type & kIsInternalizedMask) != 0;
+ return (type & (kIsNotStringMask | kIsInternalizedMask)) ==
+ (kInternalizedTag | kStringTag);
}
@@ -323,7 +320,8 @@
bool StringShape::IsInternalized() {
ASSERT(valid());
STATIC_ASSERT(kInternalizedTag != 0);
- return (type_ & kIsInternalizedMask) != 0;
+ return (type_ & (kIsNotStringMask | kIsInternalizedMask)) ==
+ (kInternalizedTag | kStringTag);
}
@@ -3389,15 +3387,13 @@
int HeapObject::SizeFromMap(Map* map) {
int instance_size = map->instance_size();
if (instance_size != kVariableSizeSentinel) return instance_size;
- // We can ignore the "internalized" bit because it is only set for
strings
- // and thus implies a string type.
- int instance_type =
- static_cast<int>(map->instance_type()) & ~kIsInternalizedMask;
// Only inline the most frequent cases.
+ int instance_type = static_cast<int>(map->instance_type());
if (instance_type == FIXED_ARRAY_TYPE) {
return FixedArray::BodyDescriptor::SizeOf(map, this);
}
- if (instance_type == ASCII_STRING_TYPE) {
+ if (instance_type == ASCII_STRING_TYPE ||
+ instance_type == ASCII_INTERNALIZED_STRING_TYPE) {
return SeqOneByteString::SizeFor(
reinterpret_cast<SeqOneByteString*>(this)->length());
}
@@ -3407,7 +3403,8 @@
if (instance_type == FREE_SPACE_TYPE) {
return reinterpret_cast<FreeSpace*>(this)->size();
}
- if (instance_type == STRING_TYPE) {
+ if (instance_type == STRING_TYPE ||
+ instance_type == INTERNALIZED_STRING_TYPE) {
return SeqTwoByteString::SizeFor(
reinterpret_cast<SeqTwoByteString*>(this)->length());
}
=======================================
--- /branches/bleeding_edge/src/objects.h Thu Jun 27 06:36:15 2013
+++ /branches/bleeding_edge/src/objects.h Thu Jun 27 06:39:44 2013
@@ -575,8 +575,7 @@
const uint32_t kNotStringTag = 0x80;
// Bit 6 indicates that the object is an internalized string (if set) or
not.
-// There are not enough types that the non-string types (with bit 7 set)
can
-// have bit 6 set too.
+// Bit 7 has to be clear as well.
const uint32_t kIsInternalizedMask = 0x40;
const uint32_t kNotInternalizedTag = 0x0;
const uint32_t kInternalizedTag = 0x40;
=======================================
--- /branches/bleeding_edge/src/x64/code-stubs-x64.cc Tue Jun 25 09:31:07
2013
+++ /branches/bleeding_edge/src/x64/code-stubs-x64.cc Thu Jun 27 06:39:44
2013
@@ -3436,11 +3436,10 @@
__ movq(scratch, FieldOperand(object, HeapObject::kMapOffset));
__ movzxbq(scratch,
FieldOperand(scratch, Map::kInstanceTypeOffset));
- // Ensure that no non-strings have the internalized bit set.
- STATIC_ASSERT(LAST_TYPE < kNotStringTag + kIsInternalizedMask);
STATIC_ASSERT(kInternalizedTag != 0);
- __ testb(scratch, Immediate(kIsInternalizedMask));
- __ j(zero, label);
+ __ and_(scratch, Immediate(kIsNotStringMask | kIsInternalizedMask));
+ __ cmpb(scratch, Immediate(kInternalizedTag | kStringTag));
+ __ j(not_equal, label);
}
@@ -5845,9 +5844,13 @@
__ movzxbq(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
__ movzxbq(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
STATIC_ASSERT(kInternalizedTag != 0);
- __ and_(tmp1, tmp2);
- __ testb(tmp1, Immediate(kIsInternalizedMask));
- __ j(zero, &miss, Label::kNear);
+ __ and_(tmp1, Immediate(kIsNotStringMask | kIsInternalizedMask));
+ __ cmpb(tmp1, Immediate(kInternalizedTag | kStringTag));
+ __ j(not_equal, &miss, Label::kNear);
+
+ __ and_(tmp2, Immediate(kIsNotStringMask | kIsInternalizedMask));
+ __ cmpb(tmp2, Immediate(kInternalizedTag | kStringTag));
+ __ j(not_equal, &miss, Label::kNear);
// Internalized strings are compared by identity.
Label done;
@@ -5890,19 +5893,8 @@
__ movzxbq(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
__ movzxbq(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
- Label succeed1;
- __ testb(tmp1, Immediate(kIsInternalizedMask));
- __ j(not_zero, &succeed1, Label::kNear);
- __ cmpb(tmp1, Immediate(static_cast<uint8_t>(SYMBOL_TYPE)));
- __ j(not_equal, &miss, Label::kNear);
- __ bind(&succeed1);
-
- Label succeed2;
- __ testb(tmp2, Immediate(kIsInternalizedMask));
- __ j(not_zero, &succeed2, Label::kNear);
- __ cmpb(tmp2, Immediate(static_cast<uint8_t>(SYMBOL_TYPE)));
- __ j(not_equal, &miss, Label::kNear);
- __ bind(&succeed2);
+ __ JumpIfNotUniqueName(tmp1, &miss, Label::kNear);
+ __ JumpIfNotUniqueName(tmp2, &miss, Label::kNear);
// Unique names are compared by identity.
Label done;
@@ -5964,7 +5956,8 @@
__ bind(¬_same);
// Check that both strings are internalized strings. If they are, we're
done
- // because we already know they are not identical.
+ // because we already know they are not identical. We also know they are
both
+ // strings.
if (equality) {
Label do_compare;
STATIC_ASSERT(kInternalizedTag != 0);
@@ -6120,13 +6113,8 @@
// Check if the entry name is not a unique name.
__ movq(entity_name, FieldOperand(entity_name,
HeapObject::kMapOffset));
- __ testb(FieldOperand(entity_name, Map::kInstanceTypeOffset),
- Immediate(kIsInternalizedMask));
- __ j(not_zero, &good, Label::kNear);
- __ cmpb(FieldOperand(entity_name, Map::kInstanceTypeOffset),
- Immediate(static_cast<uint8_t>(SYMBOL_TYPE)));
- __ j(not_equal, miss);
-
+ __ JumpIfNotUniqueName(FieldOperand(entity_name,
Map::kInstanceTypeOffset),
+ miss);
__ bind(&good);
}
@@ -6252,15 +6240,9 @@
// key we are looking for.
// Check if the entry name is not a unique name.
- Label cont;
__ movq(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
- __ testb(FieldOperand(scratch, Map::kInstanceTypeOffset),
- Immediate(kIsInternalizedMask));
- __ j(not_zero, &cont);
- __ cmpb(FieldOperand(scratch, Map::kInstanceTypeOffset),
- Immediate(static_cast<uint8_t>(SYMBOL_TYPE)));
- __ j(not_equal, &maybe_in_dictionary);
- __ bind(&cont);
+ __ JumpIfNotUniqueName(FieldOperand(scratch,
Map::kInstanceTypeOffset),
+ &maybe_in_dictionary);
}
}
=======================================
--- /branches/bleeding_edge/src/x64/ic-x64.cc Fri Jun 14 04:21:34 2013
+++ /branches/bleeding_edge/src/x64/ic-x64.cc Thu Jun 27 06:39:44 2013
@@ -337,7 +337,8 @@
__ testl(hash, Immediate(Name::kContainsCachedArrayIndexMask));
__ j(zero, index_string); // The value in hash is used at jump target.
- // Is the string internalized?
+ // Is the string internalized? We already know it's a string so a single
+ // bit test is enough.
STATIC_ASSERT(kInternalizedTag != 0);
__ testb(FieldOperand(map, Map::kInstanceTypeOffset),
Immediate(kIsInternalizedMask));
=======================================
--- /branches/bleeding_edge/src/x64/macro-assembler-x64.cc Fri Jun 21
05:57:19 2013
+++ /branches/bleeding_edge/src/x64/macro-assembler-x64.cc Thu Jun 27
06:39:44 2013
@@ -2307,6 +2307,32 @@
j(not_equal, on_fail, near_jump);
}
+
+template<class T>
+static void JumpIfNotUniqueNameHelper(MacroAssembler* masm,
+ T operand_or_register,
+ Label* not_unique_name,
+ Label::Distance distance) {
+ STATIC_ASSERT(((SYMBOL_TYPE - 1) & kIsInternalizedMask) ==
kInternalizedTag);
+ masm->cmpb(operand_or_register, Immediate(kInternalizedTag));
+ masm->j(less, not_unique_name, distance);
+ masm->cmpb(operand_or_register, Immediate(SYMBOL_TYPE));
+ masm->j(greater, not_unique_name, distance);
+}
+
+
+void MacroAssembler::JumpIfNotUniqueName(Operand operand,
+ Label* not_unique_name,
+ Label::Distance distance) {
+ JumpIfNotUniqueNameHelper<Operand>(this, operand, not_unique_name,
distance);
+}
+
+
+void MacroAssembler::JumpIfNotUniqueName(Register reg,
+ Label* not_unique_name,
+ Label::Distance distance) {
+ JumpIfNotUniqueNameHelper<Register>(this, reg, not_unique_name,
distance);
+}
void MacroAssembler::Move(Register dst, Register src) {
=======================================
--- /branches/bleeding_edge/src/x64/macro-assembler-x64.h Thu Jun 13
12:16:35 2013
+++ /branches/bleeding_edge/src/x64/macro-assembler-x64.h Thu Jun 27
06:39:44 2013
@@ -758,6 +758,12 @@
Label* on_fail,
Label::Distance near_jump = Label::kFar);
+ // Checks if the given register or operand is a unique name
+ void JumpIfNotUniqueName(Register reg, Label* not_unique_name,
+ Label::Distance distance = Label::kFar);
+ void JumpIfNotUniqueName(Operand operand, Label* not_unique_name,
+ Label::Distance distance = Label::kFar);
+
//
---------------------------------------------------------------------------
// Macro instructions.
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
