A64: Synchronize with r15814.

src/a64/macro-assembler-a64.cc

 // 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
@@ skipping 974 matching lines @@
                                       JSObject::kElementsOffset));
   Cmp(current_object, empty_fixed_array_value);
   B(ne, call_runtime);
 
   Ldr(current_object, FieldMemOperand(map, Map::kPrototypeOffset));
   Cmp(current_object, null_value);
   B(ne, &next);
 }
 
 
-void MacroAssembler::TestJSArrayForAllocationSiteInfo(Register receiver,
+void MacroAssembler::TestJSArrayForAllocationMemento(Register receiver,
                                                       Register scratch1,
                                                       Register scratch2) {
-  Label no_info_available;
+  Label no_memento_available;
   ExternalReference new_space_start =
       ExternalReference::new_space_start(isolate());
   ExternalReference new_space_allocation_top =
       ExternalReference::new_space_allocation_top_address(isolate());
 
   Add(scratch1, receiver,
-      JSArray::kSize + AllocationSiteInfo::kSize - kHeapObjectTag);
+      JSArray::kSize + AllocationMemento::kSize - kHeapObjectTag);
   Cmp(scratch1, Operand(new_space_start));
-  B(lt, &no_info_available);
+  B(lt, &no_memento_available);
 
   Mov(scratch2, Operand(new_space_allocation_top));
   Ldr(scratch2, MemOperand(scratch2));
   Cmp(scratch1, scratch2);
-  B(gt, &no_info_available);
+  B(gt, &no_memento_available);
 
-  Ldr(scratch1, MemOperand(scratch1, -AllocationSiteInfo::kSize));
+  Ldr(scratch1, MemOperand(scratch1, -AllocationMemento::kSize));
   Cmp(scratch1,
-      Operand(Handle<Map>(isolate()->heap()->allocation_site_info_map())));
+      Operand(Handle<Map>(isolate()->heap()->allocation_memento_map())));
 
-  Bind(&no_info_available);
+  Bind(&no_memento_available);
 }
 
 
 void MacroAssembler::JumpToHandlerEntry(Register exception,
                                         Register object,
                                         Register state,
                                         Register scratch1,
                                         Register scratch2) {
   // Handler expects argument in x0.
   ASSERT(exception.Is(x0));
@@ skipping 1104 matching lines @@
   And(scratch2, second, kFlatAsciiStringMask);
   Cmp(scratch1, kFlatAsciiStringTag);
   Ccmp(scratch2, kFlatAsciiStringTag, NoFlag, eq);
   B(ne, failure);
 }
 
 
 void MacroAssembler::JumpIfInstanceTypeIsNotSequentialAscii(Register type,
                                                             Register scratch,
                                                             Label* failure) {
-  static const int kFlatAsciiStringMask =
+  const int kFlatAsciiStringMask =
       kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask;
-  static const int kFlatAsciiStringTag = ASCII_STRING_TYPE;
+  const int kFlatAsciiStringTag =
+      kStringTag | kOneByteStringTag | kSeqStringTag;
   And(scratch, type, kFlatAsciiStringMask);
   Cmp(scratch, kFlatAsciiStringTag);
   B(ne, failure);
 }
 
 
 void MacroAssembler::JumpIfBothInstanceTypesAreNotSequentialAscii(
     Register first,
     Register second,
     Register scratch1,
     Register scratch2,
     Label* failure) {
   ASSERT(!AreAliased(first, second, scratch1, scratch2));
-  static const int kFlatAsciiStringMask =
+  const int kFlatAsciiStringMask =
       kIsNotStringMask | kStringEncodingMask | kStringRepresentationMask;
-  static const int kFlatAsciiStringTag = ASCII_STRING_TYPE;
+  const int kFlatAsciiStringTag =
+      kStringTag | kOneByteStringTag | kSeqStringTag;
   And(scratch1, first, kFlatAsciiStringMask);
   And(scratch2, second, kFlatAsciiStringMask);
   Cmp(scratch1, kFlatAsciiStringTag);
   Ccmp(scratch2, kFlatAsciiStringTag, NoFlag, eq);
   B(ne, failure);
 }
 
 
 void MacroAssembler::JumpIfNotUniqueName(Register type,
                                          Label* not_unique_name) {
-  STATIC_ASSERT(((SYMBOL_TYPE - 1) & kIsInternalizedMask) == kInternalizedTag);
-  // if ((type < kInternalizedTag) || (type > SYMBOL_TYPE)) {
-  //   goto not_unique_name;
+  STATIC_ASSERT((kInternalizedTag == 0) && (kStringTag == 0));
+  // if ((type is string && type is internalized) || type == SYMBOL_TYPE) {
+  //   continue
+  // } else {
+  //   goto not_unique_name
   // }
-  Cmp(type, kInternalizedTag);
-  Ccmp(type, SYMBOL_TYPE, NVFlag, ge);
-  B(gt, not_unique_name);
+  Tst(type, kIsNotStringMask | kIsNotInternalizedMask);
+  Ccmp(type, SYMBOL_TYPE, ZFlag, ne);
+  B(ne, not_unique_name);
 }
 
 
 void MacroAssembler::GenerateNumberUnaryOperation(Token::Value op,
                                                   InvokeFlag flag) {
   Runtime::FunctionId fid;
   switch (op) {
     case Token::ADD:
       // A unary add on a number (or SMI) does nothing.
       if (flag == JUMP_FUNCTION) {
@@ skipping 2515 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64