ARM: Use ubfx and movw instructions to avoid a PC-relative load on

src/spaces.cc

 // 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:
 //
 //     * 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 321 matching lines @@
     ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
     bool result = VirtualMemory::ReleaseRegion(base, size);
     USE(result);
     ASSERT(result);
   }
 }
 
 
 Address MemoryAllocator::ReserveAlignedMemory(size_t size,
                                               size_t alignment,
-                                              VirtualMemory* controller) {
-  VirtualMemory reservation(size, alignment);
+                                              VirtualMemory* controller,
+                                              intptr_t preferred_placement) {
+  VirtualMemory reservation(size, alignment, preferred_placement);
 
   if (!reservation.IsReserved()) return NULL;
   size_ += reservation.size();
   Address base = RoundUp(static_cast<Address>(reservation.address()),
                          alignment);
   controller->TakeControl(&reservation);
   return base;
 }
 
 
 Address MemoryAllocator::AllocateAlignedMemory(size_t size,
                                                size_t alignment,
                                                Executability executable,
-                                               VirtualMemory* controller) {
+                                               VirtualMemory* controller,
+                                               intptr_t preferred_placement) {
   VirtualMemory reservation;
-  Address base = ReserveAlignedMemory(size, alignment, &reservation);
+  Address base = ReserveAlignedMemory(
+      size, alignment, &reservation, preferred_placement);
   if (base == NULL) return NULL;
   if (!reservation.Commit(base,
                           size,
                           executable == EXECUTABLE)) {
     return NULL;
   }
   controller->TakeControl(&reservation);
   return base;
 }
 
 
+Map* Page::MapFromIntraPageOffset(int32_t offset) {
+  Heap* heap = HEAP;
+  MapSpace* space = heap->map_space();
+  Page* page = space->anchor()->next_page();
+  while (page != space->anchor()) {
+    uintptr_t page_number =
+        reinterpret_cast<uintptr_t>(page) >> kPageSizeBits;
+    // We can't use this method for the odd pages, only for the single even
+    // page.
+    if ((page_number & 1) == 0) break;
+    page = page->next_page();
+  }
+  Address start_of_map =
+    reinterpret_cast<Address>(page) + offset;
+  if (Map::kSize != (1 << Map::kMapSizeBits)) {
+    start_of_map = page->RoundUpToObjectAlignment(start_of_map);
+  }
+  Map* map = Map::cast(HeapObject::FromAddress(start_of_map));
+  return map;
+}
+
+
 void Page::InitializeAsAnchor(PagedSpace* owner) {
   set_owner(owner);
   set_prev_page(this);
   set_next_page(this);
 }
 
 
 NewSpacePage* NewSpacePage::Initialize(Heap* heap,
                                        Address start,
                                        SemiSpace* semi_space) {
@@ skipping 71 matching lines @@
     heap_->decrement_scan_on_scavenge_pages();
     ClearFlag(SCAN_ON_SCAVENGE);
   }
   next_chunk_->prev_chunk_ = prev_chunk_;
   prev_chunk_->next_chunk_ = next_chunk_;
   prev_chunk_ = NULL;
   next_chunk_ = NULL;
 }
 
 
+// Inverts the order of bits in a word.
+static uintptr_t InvertBits(uintptr_t x) {
+  uintptr_t answer = 0;
+  uintptr_t mask = 1;
+  uintptr_t shift = 31;
+  for (int i = 0; i < 16; i++) {
+    answer |= (x & mask) << shift;
+    mask <<= 1;
+    shift -= 2;
+  }
+  shift = 1;
+  for (int i = 0; i < 16; i++) {
+    answer |= (x & mask) >> shift;
+    mask <<= 1;
+    shift += 2;
+  }
+  return answer;
+}
+
+
 MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
                                             Executability executable,
                                             Space* owner) {
   size_t chunk_size = MemoryChunk::kObjectStartOffset + body_size;
   Heap* heap = isolate_->heap();
   Address base = NULL;
   VirtualMemory reservation;
   if (executable == EXECUTABLE) {
     // Check executable memory limit.
     if (size_executable_ + chunk_size > capacity_executable_) {
@@ skipping 15 matching lines @@
       size_executable_ += chunk_size;
     } else {
       base = AllocateAlignedMemory(chunk_size,
                                    MemoryChunk::kAlignment,
                                    executable,
                                    &reservation);
       if (base == NULL) return NULL;
       // Update executable memory size.
       size_executable_ += reservation.size();
     }
+#if defined(V8_TARGET_ARCH_ARM)
+  } else if (owner->identity() == MAP_SPACE) {
+    // First map page, try to allocate at a good address for map comparisons on
+    // ARM.
+    uintptr_t place = 1;
+    bool even = true;
+    if (reinterpret_cast<MapSpace*>(owner)->anchor()->next_page() !=
+        reinterpret_cast<MapSpace*>(owner)->anchor()) {
+      // Not the first page.  We must allocate at an odd address.
+      place = 1 << (kBitsPerPointer - kPageSizeBits - 1);
+      even = false;
+    }
+    while (true) {
+      base = AllocateAlignedMemory(chunk_size,
+                                   MemoryChunk::kAlignment,
+                                   executable,
+                                   &reservation,
+                                   InvertBits(place));
+      if (base == NULL) return NULL;
+      uintptr_t base_pointer = reinterpret_cast<uintptr_t>(base);
+      // If the evenness of the page is as we hoped.
+      if ((((base_pointer >> kPageSizeBits) & 1) == 0) == even) break;
+      // We were given an address we did not want.  Return it immediately.
+      FreeMemory(&reservation, NOT_EXECUTABLE);
+      place++;
+    }
+#endif
   } else {
     base = AllocateAlignedMemory(chunk_size,
                                  MemoryChunk::kAlignment,
                                  executable,
                                  &reservation);
 
     if (base == NULL) return NULL;
   }
 
 #ifdef DEBUG
@@ skipping 2167 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal