Merge bleeding_edge revision (5922, 5934] to isolates branch....

src/deoptimizer.h

 // Copyright 2010 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 290 matching lines @@
                    JSFunction* function);
 
   void* operator new(size_t size, uint32_t frame_size) {
     return malloc(size + frame_size);
   }
 
   void operator delete(void* description) {
     free(description);
   }
 
-  uint32_t GetFrameSize() const { return frame_size_; }
+  intptr_t GetFrameSize() const { return frame_size_; }
 
   JSFunction* GetFunction() const { return function_; }
 
   unsigned GetOffsetFromSlotIndex(Deoptimizer* deoptimizer, int slot_index);
 
-  uint32_t GetFrameSlot(unsigned offset) {
+  intptr_t GetFrameSlot(unsigned offset) {
     return *GetFrameSlotPointer(offset);
   }
 
   double GetDoubleFrameSlot(unsigned offset) {
     return *reinterpret_cast<double*>(GetFrameSlotPointer(offset));
   }
 
-  void SetFrameSlot(unsigned offset, uint32_t value) {
+  void SetFrameSlot(unsigned offset, intptr_t value) {
     *GetFrameSlotPointer(offset) = value;
   }
 
-  uint32_t GetRegister(unsigned n) const {
+  intptr_t GetRegister(unsigned n) const {
     ASSERT(n < ARRAY_SIZE(registers_));
     return registers_[n];
   }
 
   double GetDoubleRegister(unsigned n) const {
     ASSERT(n < ARRAY_SIZE(double_registers_));
     return double_registers_[n];
   }
 
-  void SetRegister(unsigned n, uint32_t value) {
+  void SetRegister(unsigned n, intptr_t value) {
     ASSERT(n < ARRAY_SIZE(registers_));
     registers_[n] = value;
   }
 
   void SetDoubleRegister(unsigned n, double value) {
     ASSERT(n < ARRAY_SIZE(double_registers_));
     double_registers_[n] = value;
   }
 
-  uint32_t GetTop() const { return top_; }
-  void SetTop(uint32_t top) { top_ = top; }
+  intptr_t GetTop() const { return top_; }
+  void SetTop(intptr_t top) { top_ = top; }
 
-  uint32_t GetPc() const { return pc_; }
-  void SetPc(uint32_t pc) { pc_ = pc; }
+  intptr_t GetPc() const { return pc_; }
+  void SetPc(intptr_t pc) { pc_ = pc; }
 
-  uint32_t GetFp() const { return fp_; }
-  void SetFp(uint32_t fp) { fp_ = fp; }
+  intptr_t GetFp() const { return fp_; }
+  void SetFp(intptr_t fp) { fp_ = fp; }
 
   Smi* GetState() const { return state_; }
   void SetState(Smi* state) { state_ = state; }
 
-  void SetContinuation(uint32_t pc) { continuation_ = pc; }
+  void SetContinuation(intptr_t pc) { continuation_ = pc; }
 
   static int registers_offset() {
     return OFFSET_OF(FrameDescription, registers_);
   }
 
   static int double_registers_offset() {
     return OFFSET_OF(FrameDescription, double_registers_);
   }
 
   static int frame_size_offset() {
@@ skipping 12 matching lines @@
     return OFFSET_OF(FrameDescription, continuation_);
   }
 
   static int frame_content_offset() {
     return sizeof(FrameDescription);
   }
 
  private:
   static const uint32_t kZapUint32 = 0xbeeddead;
 
-  uint32_t frame_size_;  // Number of bytes.
+  uintptr_t frame_size_;  // Number of bytes.
   JSFunction* function_;
-  uint32_t registers_[Register::kNumRegisters];
+  intptr_t registers_[Register::kNumRegisters];
   double double_registers_[DoubleRegister::kNumAllocatableRegisters];
-  uint32_t top_;
-  uint32_t pc_;
-  uint32_t fp_;
+  intptr_t top_;
+  intptr_t pc_;
+  intptr_t fp_;
   Smi* state_;
 
   // Continuation is the PC where the execution continues after
   // deoptimizing.
-  uint32_t continuation_;
+  intptr_t continuation_;
 
-  uint32_t* GetFrameSlotPointer(unsigned offset) {
+  intptr_t* GetFrameSlotPointer(unsigned offset) {
     ASSERT(offset < frame_size_);
-    return reinterpret_cast<uint32_t*>(
+    return reinterpret_cast<intptr_t*>(
         reinterpret_cast<Address>(this) + frame_content_offset() + offset);
   }
 };
 
 
 class TranslationBuffer BASE_EMBEDDED {
  public:
   TranslationBuffer() : contents_(256) { }
 
   int CurrentIndex() const { return contents_.length(); }
@@ skipping 97 matching lines @@
   Handle<Code> code_;
 
   // Next pointer for linked list.
   DeoptimizingCodeListNode* next_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_