Write barrier audit: const raw_ptr()

runtime/vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/atomic.h"
 #include "vm/globals.h"
@@ skipping 198 matching lines @@
 
 #define RAW_OBJECT_IMPLEMENTATION(object)                                      \
  private:  /* NOLINT */                                                        \
   VISITOR_SUPPORT(object)                                                      \
   friend class object;                                                         \
   friend class RawObject;                                                      \
   friend class Heap;                                                           \
   DISALLOW_ALLOCATION();                                                       \
   DISALLOW_IMPLICIT_CONSTRUCTORS(Raw##object)
 
+// TODO(koda): Make ptr() return const*, like Object::raw_ptr().
 #define RAW_HEAP_OBJECT_IMPLEMENTATION(object)                                 \
   private:                                                                     \
     RAW_OBJECT_IMPLEMENTATION(object);                                         \
     Raw##object* ptr() const {                                                 \
       ASSERT(IsHeapObject());                                                  \
       return reinterpret_cast<Raw##object*>(                                   \
           reinterpret_cast<uword>(this) - kHeapObjectTag);                     \
     }                                                                          \
     SNAPSHOT_WRITER_SUPPORT()                                                  \
     HEAP_PROFILER_SUPPORT()                                                    \
@@ skipping 222 matching lines @@
 
   class RememberedBit : public BitField<bool, kRememberedBit, 1> {};
 
   class CanonicalObjectTag : public BitField<bool, kCanonicalBit, 1> {};
 
   class CreatedFromSnapshotTag : public BitField<bool, kFromSnapshotBit, 1> {};
 
   class ReservedBits : public
       BitField<intptr_t, kReservedTagPos, kReservedTagSize> {};  // NOLINT
 
+  // TODO(koda): Return const*, like Object::raw_ptr().
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
   intptr_t SizeFromClass() const;
 
   intptr_t GetClassId() const {
     uword tags = ptr()->tags_;
@@ skipping 111 matching lines @@
     return reinterpret_cast<RawObject**>(&ptr()->instantiations_);
   }
   // The instantiations_ array remains empty for instantiated type arguments.
   RawArray* instantiations_;  // Array of paired canonical vectors:
                               // Even index: instantiator.
                               // Odd index: instantiated (without bound error).
   // Instantiations leading to bound errors do not get cached.
   RawSmi* length_;
 
   // Variable length data follows here.
+  RawAbstractType* const* types() const {
+    OPEN_ARRAY_START(RawAbstractType*, RawAbstractType*);
+  }
   RawAbstractType** types() {
     OPEN_ARRAY_START(RawAbstractType*, RawAbstractType*);
   }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types()[length - 1]);
   }
 
   friend class SnapshotReader;
 };
 
@@ skipping 287 matching lines @@
   // Alive: If true, the embedded object pointers will be visited during GC.
   int32_t state_bits_;
 
   // PC offsets for code patching.
   int32_t entry_patch_pc_offset_;
   int32_t patch_code_pc_offset_;
   int32_t lazy_deopt_pc_offset_;
 
   // Variable length data follows here.
   int32_t* data() { OPEN_ARRAY_START(int32_t, int32_t); }
+  const int32_t* data() const { OPEN_ARRAY_START(int32_t, int32_t); }
 
   friend class StackFrame;
   friend class MarkingVisitor;
   friend class Function;
 };
 
 
 class RawInstructions : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instructions);
 
@@ skipping 95 matching lines @@
   RAW_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors);
 
   static const intptr_t kFullRecSize;
   static const intptr_t kCompressedRecSize;
 
   int32_t record_size_in_bytes_;
   int32_t length_;  // Number of descriptors.
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, intptr_t); }
+  const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, intptr_t); }
 
   friend class Object;
 };
 
 
 // Stackmap is an immutable representation of the layout of the stack at a
 // PC. The stack map representation consists of a bit map which marks each
 // live object index starting from the base of the frame.
 //
 // The Stackmap also consists of a link to the code object corresponding to
 // the frame which the stack map is describing.  The bit map representation
 // is optimized for dense and small bit maps, without any upper bound.
 class RawStackmap : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Stackmap);
 
   // Regarding changing this to a bitfield: ARM64 requires register_bit_count_
   // to be as large as 96, meaning 7 bits, leaving 25 bits for the length, or
   // as large as ~33 million entries. If that is sufficient, then these two
   // fields can be merged into a BitField.
   int32_t length_;  // Length of payload, in bits.
   int32_t register_bit_count_;  // Live register bits, included in length_.
 
   // Offset from code entry point corresponding to this stack map
   // representation.
   uint32_t pc_offset_;
 
   // Variable length data follows here (bitmap of the stack layout).
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
+  const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
 };
 
 
 class RawLocalVarDescriptors : public RawObject {
  public:
   enum VarInfoKind {
     kStackVar = 1,
     kContextVar,
     kContextLevel,
     kSavedEntryContext,
@@ skipping 79 matching lines @@
   RAW_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers);
 
   // Number of exception handler entries.
   int32_t num_entries_;
 
   // Array with [num_entries_] entries. Each entry is an array of all handled
   // exception types.
   RawArray* handled_types_data_;
 
   // Exception handler info of length [num_entries_].
+  const HandlerInfo* data() const { OPEN_ARRAY_START(HandlerInfo, intptr_t); }
   HandlerInfo* data() { OPEN_ARRAY_START(HandlerInfo, intptr_t); }
 
   friend class Object;
 };
 
 
 // Contains an array of deoptimization commands, e.g., move a specific register
 // into a specific slot of unoptimized frame.
 class RawDeoptInfo : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(DeoptInfo);
 
   RawSmi* length_;  // Number of deoptimization commands
 
   // Variable length data follows here.
   intptr_t* data() { OPEN_ARRAY_START(intptr_t, intptr_t); }
+  const intptr_t* data() const { OPEN_ARRAY_START(intptr_t, intptr_t); }
 };
 
 
 class RawContext : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Context);
 
   int32_t num_variables_;
   Isolate* isolate_;
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->parent_); }
   RawContext* parent_;
 
   // Variable length data follows here.
   RawInstance** data() { OPEN_ARRAY_START(RawInstance*, RawInstance*); }
+  RawInstance* const* data() const {
+      OPEN_ARRAY_START(RawInstance*, RawInstance*);
+  }
   RawObject** to(intptr_t num_vars) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[num_vars - 1]);
   }
 
   friend class SnapshotReader;
 };
 
 
 class RawContextScope : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ContextScope);
@@ skipping 308 matching lines @@
 
   friend class Library;
 };
 
 
 class RawOneByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(OneByteString);
 
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
+  const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
 
   friend class ApiMessageReader;
   friend class SnapshotReader;
 };
 
 
 class RawTwoByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TwoByteString);
 
   // Variable length data follows here.
   uint16_t* data() { OPEN_ARRAY_START(uint16_t, uint16_t); }
+  const uint16_t* data() const { OPEN_ARRAY_START(uint16_t, uint16_t); }
 
   friend class SnapshotReader;
 };
 
 
 template<typename T>
 class ExternalStringData {
  public:
   ExternalStringData(const T* data, void* peer, Dart_PeerFinalizer callback) :
       data_(data), peer_(peer), callback_(callback) {
@@ skipping 42 matching lines @@
 class RawArray : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Array);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawSmi* length_;
   // Variable length data follows here.
   RawObject** data() { OPEN_ARRAY_START(RawObject*, RawObject*); }
+  RawObject* const* data() const { OPEN_ARRAY_START(RawObject*, RawObject*); }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[length - 1]);
   }
 
   friend class RawCode;
   friend class RawImmutableArray;
   friend class SnapshotReader;
   friend class GrowableObjectArray;
   friend class LinkedHashMap;
   friend class Object;
@@ skipping 96 matching lines @@
 
 
 class RawTypedData : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TypedData);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   // Variable length data follows here.
   uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
+  const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 
   friend class Api;
   friend class Object;
   friend class Instance;
   friend class SnapshotReader;
 };
 
 
 class RawExternalTypedData : public RawInstance {
@@ skipping 352 matching lines @@
   COMPILE_ASSERT(kExternalTypedDataInt8ArrayCid ==
                  kTypedDataInt8ArrayViewCid + 15);
   COMPILE_ASSERT(kByteBufferCid == kExternalTypedDataInt8ArrayCid + 14);
   COMPILE_ASSERT(kNullCid == kByteBufferCid + 1);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_