Support weak heap references in the ConstantPool to support IsWeakObjectInOptimizedCode objects.

src/arm/assembler-arm.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 590 matching lines @@
   Register rs() const { return rs_; }
   ShiftOp shift_op() const { return shift_op_; }
 
  private:
   Register rm_;
   Register rs_;
   ShiftOp shift_op_;
   int shift_imm_;  // valid if rm_ != no_reg && rs_ == no_reg
   int32_t imm32_;  // valid if rm_ == no_reg
   RelocInfo::Mode rmode_;
+  bool weak_in_optimized_code_;
 
   friend class Assembler;
 };
 
 
 // Class MemOperand represents a memory operand in load and store instructions
 class MemOperand BASE_EMBEDDED {
  public:
   // [rn +/- offset]      Offset/NegOffset
   // [rn +/- offset]!     PreIndex/NegPreIndex
@@ skipping 85 matching lines @@
 };
 
 
 // Class used to build a constant pool.
 class ConstantPoolBuilder BASE_EMBEDDED {
  public:
   explicit ConstantPoolBuilder();
   void AddEntry(Assembler* assm, const RelocInfo& rinfo);
   void Relocate(int pc_delta);
   bool IsEmpty();
-  MaybeObject* Allocate(Heap* heap);
+  MaybeObject* Allocate(Heap* heap, bool has_weak_pointers);
   void Populate(Assembler* assm, ConstantPoolArray* constant_pool);
 
   inline int count_of_64bit() const { return count_of_64bit_; }
   inline int count_of_code_ptr() const { return count_of_code_ptr_; }
   inline int count_of_heap_ptr() const { return count_of_heap_ptr_; }
+  inline int count_of_weak_ptr() const { return count_of_weak_ptr_; }
   inline int count_of_32bit() const { return count_of_32bit_; }
 
  private:
   bool Is64BitEntry(RelocInfo::Mode rmode);
   bool Is32BitEntry(RelocInfo::Mode rmode);
   bool IsCodePtrEntry(RelocInfo::Mode rmode);
   bool IsHeapPtrEntry(RelocInfo::Mode rmode);
 
   std::vector<RelocInfo> entries_;
   std::vector<int> merged_indexes_;
   int count_of_64bit_;
   int count_of_code_ptr_;
   int count_of_heap_ptr_;
+  int count_of_weak_ptr_;
   int count_of_32bit_;
 };
 
 
 extern const Instr kMovLrPc;
 extern const Instr kLdrPCMask;
 extern const Instr kLdrPCPattern;
 extern const Instr kLdrPpMask;
 extern const Instr kLdrPpPattern;
 extern const Instr kBlxRegMask;
@@ skipping 745 matching lines @@
   static const int kMaxNumPending64RelocInfo = kMaxDistToFPPool/kInstrSize;
 
   // Postpone the generation of the constant pool for the specified number of
   // instructions.
   void BlockConstPoolFor(int instructions);
 
   // Check if is time to emit a constant pool.
   void CheckConstPool(bool force_emit, bool require_jump);
 
   // Allocate a constant pool of the correct size for the generated code.
-  MaybeObject* AllocateConstantPool(Heap* heap);
+  MaybeObject* AllocateConstantPool(Heap* heap, bool has_weak_pointers);
 
   // Generate the constant pool for the generated code.
   void PopulateConstantPool(ConstantPoolArray* constant_pool);
 
   bool can_use_constant_pool() const {
     return is_constant_pool_available() && !constant_pool_full_;
   }
 
   void set_constant_pool_full() {
     constant_pool_full_ = true;
@@ skipping 177 matching lines @@
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_ARM_H_