Finishes removing intptr_t from raw object fields.

runtime/vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 2994 matching lines @@
   }
   RawArray* object_pool() const { return raw_ptr()->object_pool_; }
   static intptr_t object_pool_offset() {
     return OFFSET_OF(RawInstructions, object_pool_);
   }
 
   uword EntryPoint() const {
     return reinterpret_cast<uword>(raw_ptr()) + HeaderSize();
   }
 
-  static const intptr_t kMaxElements = (kIntptrMax -
+  static const intptr_t kMaxElements = (kMaxInt32 -
                                         (sizeof(RawInstructions) +
                                          sizeof(RawObject) +
                                          (2 * OS::kMaxPreferredCodeAlignment)));
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawInstructions) ==
            OFFSET_OF_RETURNED_VALUE(RawInstructions, data));
     return 0;
   }
 
@@ skipping 45 matching lines @@
   RawString* GetName(intptr_t var_index) const;
 
   void SetVar(intptr_t var_index,
               const String& name,
               RawLocalVarDescriptors::VarInfo* info) const;
 
   void GetInfo(intptr_t var_index, RawLocalVarDescriptors::VarInfo* info) const;
 
   static const intptr_t kBytesPerElement =
       sizeof(RawLocalVarDescriptors::VarInfo);
-  static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
+  static const intptr_t kMaxElements = RawLocalVarDescriptors::kMaxIndex;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawLocalVarDescriptors) ==
         OFFSET_OF_RETURNED_VALUE(RawLocalVarDescriptors, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawLocalVarDescriptors) + (len * kBytesPerElement));
@@ skipping 24 matching lines @@
     rec->set_token_pos(static_cast<int32_t>(token_pos),
         RecordSizeInBytes() == RawPcDescriptors::kCompressedRecSize);
     ASSERT(Utils::IsInt(16, try_index));
     rec->set_try_index(try_index);
     ASSERT(rec->try_index() == try_index);
     ASSERT(rec->token_pos() == token_pos);
   }
 
   static const intptr_t kMaxBytesPerElement =
       sizeof(RawPcDescriptors::PcDescriptorRec);
-  static const intptr_t kMaxElements = kSmiMax / kMaxBytesPerElement;
+  static const intptr_t kMaxElements = kSmi32Max / kMaxBytesPerElement;

[siva, 2014/09/09 16:47:24]

Does this need to be kSmi32Max why not just kMaxInt32 ?

[zra, 2014/09/09 17:42:38]

Done.

 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawPcDescriptors) ==
            OFFSET_OF_RETURNED_VALUE(RawPcDescriptors, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len, intptr_t record_size_in_bytes) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawPcDescriptors) + (len * record_size_in_bytes));
@@ skipping 107 matching lines @@
   static const intptr_t kNoMaximum = -1;
   static const intptr_t kNoMinimum = -1;
 
   bool IsObject(intptr_t index) const {
     ASSERT(InRange(index));
     return GetBit(index);
   }
 
   intptr_t Length() const { return raw_ptr()->length_; }
 
-  uword PC() const { return raw_ptr()->pc_; }
-  void SetPC(uword value) const { raw_ptr()->pc_ = value; }
+  uint32_t PcOffset() const { return raw_ptr()->pc_offset_; }
+  void SetPcOffset(uint32_t value) const {
+    ASSERT(value <= kMaxUint32);
+    raw_ptr()->pc_offset_ = value;
+  }
 
   intptr_t RegisterBitCount() const { return raw_ptr()->register_bit_count_; }
   void SetRegisterBitCount(intptr_t register_bit_count) const {
+    ASSERT(register_bit_count < kMaxInt32);
     raw_ptr()->register_bit_count_ = register_bit_count;
   }
 
   static const intptr_t kMaxLengthInBytes = kSmiMax;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawStackmap) == OFFSET_OF_RETURNED_VALUE(RawStackmap, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t length) {
@@ skipping 388 matching lines @@
 };
 
 
 class Code : public Object {
  public:
   RawInstructions* instructions() const { return raw_ptr()->instructions_; }
   static intptr_t instructions_offset() {
     return OFFSET_OF(RawCode, instructions_);
   }
   intptr_t pointer_offsets_length() const {
-    return raw_ptr()->pointer_offsets_length_;
+    return PtrOffBits::decode(raw_ptr()->state_bits_);
   }
 
   bool is_optimized() const {
     return OptimizedBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_optimized(bool value) const;
   bool is_alive() const {
     return AliveBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_alive(bool value) const;
@@ skipping 35 matching lines @@
 
   RawArray* object_table() const {
     return raw_ptr()->object_table_;
   }
   void set_object_table(const Array& array) const;
 
   RawArray* stackmaps() const {
     return raw_ptr()->stackmaps_;
   }
   void set_stackmaps(const Array& maps) const;
-  RawStackmap* GetStackmap(uword pc, Array* stackmaps, Stackmap* map) const;
+  RawStackmap* GetStackmap(
+      uint32_t pc_offset, Array* stackmaps, Stackmap* map) const;
 
   enum {
     kSCallTableOffsetEntry = 0,
     kSCallTableFunctionEntry = 1,
     kSCallTableCodeEntry = 2,
     kSCallTableEntryLength = 3,
   };
 
   void set_static_calls_target_table(const Array& value) const;
   RawArray* static_calls_target_table() const {
@@ skipping 153 matching lines @@
   intptr_t lazy_deopt_pc_offset() const {
     return raw_ptr()->lazy_deopt_pc_offset_;
   }
   void set_lazy_deopt_pc_offset(intptr_t pc) const {
     raw_ptr()->lazy_deopt_pc_offset_ = pc;
   }
 
  private:
   void set_state_bits(intptr_t bits) const;
 
+  friend class RawObject;  // For RawObject::SizeFromClass().
   friend class RawCode;
   enum {
     kOptimizedBit = 0,
     kAliveBit = 1,
+    kPtrOffBit = 2,
+    kPtrOffSize = 30,
   };
 
   class OptimizedBit : public BitField<bool, kOptimizedBit, 1> {};
   class AliveBit : public BitField<bool, kAliveBit, 1> {};
+  class PtrOffBits : public BitField<intptr_t, kPtrOffBit, kPtrOffSize> {};
 
   // An object finder visitor interface.
   class FindRawCodeVisitor : public FindObjectVisitor {
    public:
     explicit FindRawCodeVisitor(uword pc)
         : FindObjectVisitor(Isolate::Current()), pc_(pc) { }
     virtual ~FindRawCodeVisitor() { }
 
     virtual uword filter_addr() const { return pc_; }
 
@@ skipping 10 matching lines @@
 
   void set_compile_timestamp(int64_t timestamp) const {
     raw_ptr()->compile_timestamp_ = timestamp;
   }
 
   void set_instructions(RawInstructions* instructions) {
     // RawInstructions are never allocated in New space and hence a
     // store buffer update is not needed here.
     raw_ptr()->instructions_ = instructions;
   }
+
   void set_pointer_offsets_length(intptr_t value) {
-    ASSERT(value >= 0);
-    raw_ptr()->pointer_offsets_length_ = value;
+    // The number of fixups is limited to 1-billion.
+    ASSERT(Utils::IsUint(30, value));
+    set_state_bits(PtrOffBits::update(value, raw_ptr()->state_bits_));
   }
   int32_t* PointerOffsetAddrAt(int index) const {
     ASSERT(index >= 0);
     ASSERT(index < pointer_offsets_length());
     // TODO(iposva): Unit test is missing for this functionality.
     return &raw_ptr()->data()[index];
   }
   void SetPointerOffsetAt(int index, int32_t offset_in_instructions) {
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
@@ skipping 3147 matching lines @@
 
 // Internal JavaScript regular expression object.
 class JSRegExp : public Instance {
  public:
   // Meaning of RegExType:
   // kUninitialized: the type of th regexp has not been initialized yet.
   // kSimple: A simple pattern to match against, using string indexOf operation.
   // kComplex: A complex pattern to match.
   enum RegExType {
     kUnitialized = 0,
-    kSimple,
-    kComplex,
+    kSimple = 1,
+    kComplex = 2,
   };
 
   // Flags are passed to a regex object as follows:
   // 'i': ignore case, 'g': do global matches, 'm': pattern is multi line.
   enum Flags {
     kNone = 0,
     kGlobal = 1,
     kIgnoreCase = 2,
     kMultiLine = 4,
   };
 
-  bool is_initialized() const { return (raw_ptr()->type_ != kUnitialized); }
-  bool is_simple() const { return (raw_ptr()->type_ == kSimple); }
-  bool is_complex() const { return (raw_ptr()->type_ == kComplex); }
+  enum {
+    kTypePos = 0,
+    kTypeSize = 2,
+    kFlagsPos = 2,
+    kFlagsSize = 4,
+  };
 
-  bool is_global() const { return (raw_ptr()->flags_ & kGlobal); }
-  bool is_ignore_case() const { return (raw_ptr()->flags_ & kIgnoreCase); }
-  bool is_multi_line() const { return (raw_ptr()->flags_ & kMultiLine); }
+  class TypeBits : public BitField<RegExType, kTypePos, kTypeSize> {};
+  class FlagsBits : public BitField<intptr_t, kFlagsPos, kFlagsSize> {};
+
+  bool is_initialized() const { return (type() != kUnitialized); }
+  bool is_simple() const { return (type() == kSimple); }
+  bool is_complex() const { return (type() == kComplex); }
+
+  bool is_global() const { return (flags() & kGlobal); }
+  bool is_ignore_case() const { return (flags() & kIgnoreCase); }
+  bool is_multi_line() const { return (flags() & kMultiLine); }
 
   RawString* pattern() const { return raw_ptr()->pattern_; }
   RawSmi* num_bracket_expressions() const {
     return raw_ptr()->num_bracket_expressions_;
   }
 
   void set_pattern(const String& pattern) const;
   void set_num_bracket_expressions(intptr_t value) const;
-  void set_is_global() const { raw_ptr()->flags_ |= kGlobal; }
-  void set_is_ignore_case() const { raw_ptr()->flags_ |= kIgnoreCase; }
-  void set_is_multi_line() const { raw_ptr()->flags_ |= kMultiLine; }
-  void set_is_simple() const { raw_ptr()->type_ = kSimple; }
-  void set_is_complex() const { raw_ptr()->type_ = kComplex; }
+  void set_is_global() const { set_flags(flags() | kGlobal); }
+  void set_is_ignore_case() const { set_flags(flags() | kIgnoreCase); }
+  void set_is_multi_line() const { set_flags(flags() | kMultiLine); }
+  void set_is_simple() const { set_type(kSimple); }
+  void set_is_complex() const { set_type(kComplex); }
 
   void* GetDataStartAddress() const;
   static RawJSRegExp* FromDataStartAddress(void* data);
   const char* Flags() const;
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
 
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawJSRegExp) == OFFSET_OF_RETURNED_VALUE(RawJSRegExp, data));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawJSRegExp) + (len * kBytesPerElement));
   }
 
   static RawJSRegExp* New(intptr_t length, Heap::Space space = Heap::kNew);
 
  private:
-  void set_type(RegExType type) const { raw_ptr()->type_ = type; }
-  void set_flags(intptr_t value) const { raw_ptr()->flags_ = value; }
+  void set_type(RegExType type) const {
+    raw_ptr()->type_flags_ = TypeBits::update(type, raw_ptr()->type_flags_);
+  }
+  void set_flags(intptr_t value) const {
+    raw_ptr()->type_flags_ = FlagsBits::update(value, raw_ptr()->type_flags_);
+  }
+
+  RegExType type() const {
+    return TypeBits::decode(raw_ptr()->type_flags_);
+  }
+  intptr_t flags() const {
+    return FlagsBits::decode(raw_ptr()->type_flags_);
+  }
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->data_length_ = Smi::New(value);
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
   friend class Class;
 };
@@ skipping 242 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_