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

src/arm/macro-assembler-arm.h

Index: src/arm/macro-assembler-arm.h
===================================================================
--- src/arm/macro-assembler-arm.h	(revision 10578)
+++ src/arm/macro-assembler-arm.h	(working copy)
@@ -806,8 +806,11 @@
   // Compare an object's map with the specified map and its transitioned
   // elements maps if mode is ALLOW_ELEMENT_TRANSITION_MAPS. Condition flags are
   // set with result of map compare. If multiple map compares are required, the
-  // compare sequences branches to early_success.
+  // compare sequences branches to early_success.  The map_register and the
+  // scratch register can be the same register, but in that case the map will
+  // not be available afterwards in the map_register.
   void CompareMap(Register obj,
+                  Register map_register,
                   Register scratch,
                   Handle<Map> map,
                   Label* early_success,
@@ -818,6 +821,7 @@
   // heap object). If mode is ALLOW_ELEMENT_TRANSITION_MAPS, then also match
   // against maps that are ElementsKind transition maps of the specified map.
   void CheckMap(Register obj,
+                Register map_register,
                 Register scratch,
                 Handle<Map> map,
                 Label* fail,
@@ -847,6 +851,12 @@
   void CompareRoot(Register obj, Heap::RootListIndex index);
 
 
+  // As CompareRoot, above, but only works for roots that are maps.  May be more
+  // efficient.
+  void CompareMapRoot(
+      Register obj, Register scratch, Heap::RootListIndex index);
+
+
   // Load and check the instance type of an object for being a string.
   // Loads the type into the second argument register.
   // Returns a condition that will be enabled if the object was a string.
@@ -1286,6 +1296,18 @@
                           Register bitmap_reg,
                           Register mask_reg);
 
+  bool CanDoEfficientMapComparison(Map* map);
+
+  void EfficientMapComparisonPrepare(Register obj, Register scratch);
+  void EfficientMapComparison(Register prepared_map, Map* map);
+
+  void CompareMaps(Register possible_map,
+                   Register scratch,
+                   Map* map1,  // May not be NULL.
+                   Map* map2,  // May be NULL.
+                   Map* map3,  // May be NULL.
+                   Label* early_success);
+
   // Helper for throwing exceptions.  Compute a handler address and jump to
   // it.  See the implementation for register usage.
   void JumpToHandlerEntry();