Thumb2 Backend: Thumb2 changes for Deoptimization and Code Aging

src/objects.h

 // Copyright 2012 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 4593 matching lines @@
   static const int kLiteralArrayIndex = 2;
   static const int kOsrAstIdIndex = 3;
   static const int kOsrPcOffsetIndex = 4;
   static const int kFirstDeoptEntryIndex = 5;
 
   // Offsets of deopt entry elements relative to the start of the entry.
   static const int kAstIdRawOffset = 0;
   static const int kTranslationIndexOffset = 1;
   static const int kArgumentsStackHeightOffset = 2;
   static const int kPcOffset = 3;
-  static const int kDeoptEntrySize = 4;
+  static const int kModeOffset = 4;
+  static const int kDeoptEntrySize = 5;
 
   // Simple element accessors.
 #define DEFINE_ELEMENT_ACCESSORS(name, type)      \
   type* name() {                                  \
     return type::cast(get(k##name##Index));       \
   }                                               \
   void Set##name(type* value) {                   \
     set(k##name##Index, value);                   \
   }
 
@@ skipping 11 matching lines @@
     return type::cast(get(IndexForEntry(i) + k##name##Offset));  \
   }                                                              \
   void Set##name(int i, type* value) {                           \
     set(IndexForEntry(i) + k##name##Offset, value);              \
   }
 
   DEFINE_ENTRY_ACCESSORS(AstIdRaw, Smi)
   DEFINE_ENTRY_ACCESSORS(TranslationIndex, Smi)
   DEFINE_ENTRY_ACCESSORS(ArgumentsStackHeight, Smi)
   DEFINE_ENTRY_ACCESSORS(Pc, Smi)
+  DEFINE_ENTRY_ACCESSORS(Mode, Smi)
 
 #undef DEFINE_ENTRY_ACCESSORS
 
   BailoutId AstId(int i) {
     return BailoutId(AstIdRaw(i)->value());
   }
 
   void SetAstId(int i, BailoutId value) {
     SetAstIdRaw(i, Smi::FromInt(value.ToInt()));
   }
@@ skipping 506 matching lines @@
     kCodeAgeCount = kAfterLastCodeAge - 1
   };
 #undef DECLARE_CODE_AGE_ENUM
 
   // Code aging.  Indicates how many full GCs this code has survived without
   // being entered through the prologue.  Used to determine when it is
   // relatively safe to flush this code object and replace it with the lazy
   // compilation stub.
   static void MakeCodeAgeSequenceYoung(byte* sequence);
   void MakeOlder(MarkingParity);
-  static bool IsYoungSequence(byte* sequence);
+  static bool IsYoungSequence(byte* sequence, bool thumb_mode = false);
   bool IsOld();
   int GetAge();
 
   void PrintDeoptLocation(int bailout_id);
   bool CanDeoptAt(Address pc);
 
 #ifdef VERIFY_HEAP
   void VerifyEmbeddedMapsDependency();
 #endif
 
@@ skipping 122 matching lines @@
       TypeField::kMask | CacheHolderField::kMask;
 
  private:
   friend class RelocIterator;
 
   // Code aging
   byte* FindCodeAgeSequence();
   static void GetCodeAgeAndParity(Code* code, Age* age,
                                   MarkingParity* parity);
   static void GetCodeAgeAndParity(byte* sequence, Age* age,
-                                  MarkingParity* parity);
+                                  MarkingParity* parity,
+                                  bool thumb_mode = false);
   static Code* GetCodeAgeStub(Age age, MarkingParity parity);
 
   // Code aging -- platform-specific
   static void PatchPlatformCodeAge(byte* sequence, Age age,
-                                   MarkingParity parity);
+                                   MarkingParity parity,
+                                   bool is_thumb_mode = false);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
 };
 
 
 class CompilationInfo;
 
 // This class describes the layout of dependent codes array of a map. The
 // array is partitioned into several groups of dependent codes. Each group
 // contains codes with the same dependency on the map. The array has the
@@ skipping 4850 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_