Fix compilation warnings/errors seen with newer versions of gcc compiler.

runtime/vm/snapshot.h

 // Copyright (c) 2011, 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_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "vm/allocation.h"
 #include "vm/assert.h"
 #include "vm/bitfield.h"
@@ skipping 41 matching lines @@
 };
 
 
 // Structure capturing the raw snapshot.
 class Snapshot {
  public:
   static const int kHeaderSize = 2 * sizeof(int32_t);
   static const int kLengthIndex = 0;
   static const int kSnapshotFlagIndex = 1;
 
-  static Snapshot* SetupFromBuffer(void* raw_memory);
+  static const Snapshot* SetupFromBuffer(const void* raw_memory);
 
   // Getters.
-  uint8_t* content() { return content_; }
+  const uint8_t* content() const { return content_; }
   int32_t length() const { return length_; }
 
   bool IsPartialSnapshot() const { return full_snapshot_ == 0; }
   bool IsFullSnapshot() const { return full_snapshot_ != 0; }
   int32_t Size() const { return length_ + sizeof(Snapshot); }
   uint8_t* Addr() { return reinterpret_cast<uint8_t*>(this); }
 
   static intptr_t length_offset() { return OFFSET_OF(Snapshot, length_); }
   static intptr_t full_snapshot_offset() {
     return OFFSET_OF(Snapshot, full_snapshot_);
   }
 
  private:
   Snapshot() : length_(0), full_snapshot_(0) {}
 
   int32_t length_;  // Stream length.
   int32_t full_snapshot_;  // Classes are serialized too.
   uint8_t content_[];  // Stream content.
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 
 // Stream for reading various types from a buffer.
 class ReadStream : public ValueObject {
  public:
-  ReadStream(uint8_t* buffer, intptr_t size) : buffer_(buffer),
-                                               current_(buffer),
-                                               end_(buffer + size)  {}
+  ReadStream(const uint8_t* buffer, intptr_t size) : buffer_(buffer),
+                                                     current_(buffer),
+                                                     end_(buffer + size)  {}
 
  private:
   template<typename T>
   T Read() {
     uint8_t b = ReadByte();
     if (b > kMaxSerializedUnsignedValuePerByte) {
       return static_cast<T>(b) - kEndByteMarker;
     }
     T r = 0;
     uint8_t s = 0;
@@ skipping 39 matching lines @@
       return bit_cast<T>(st->Read<int64_t>());
     }
   };
 
   uint8_t ReadByte() {
     ASSERT(current_ < end_);
     return *current_++;
   }
 
  private:
-  uint8_t* buffer_;
-  uint8_t* current_;
-  uint8_t* end_;
+  const uint8_t* buffer_;
+  const uint8_t* current_;
+  const uint8_t* end_;
 
   // SnapshotReader needs access to the private Raw classes.
   friend class SnapshotReader;
   DISALLOW_COPY_AND_ASSIGN(ReadStream);
 };
 
 
 // Stream for writing various types into a buffer.
 class WriteStream : public ValueObject {
  public:
@@ skipping 92 matching lines @@
   // classes.
   friend class MessageWriter;
   friend class SnapshotWriter;
   DISALLOW_COPY_AND_ASSIGN(WriteStream);
 };
 
 
 // Reads a snapshot into objects.
 class SnapshotReader {
  public:
-  SnapshotReader(Snapshot* snapshot, Heap* heap, ObjectStore* object_store)
+  SnapshotReader(const Snapshot* snapshot,
+                 Heap* heap,
+                 ObjectStore* object_store)
       : stream_(snapshot->content(), snapshot->length()),
         classes_serialized_(snapshot->IsFullSnapshot()),
         heap_(heap),
         object_store_(object_store),
         backward_references_() { }
   ~SnapshotReader() { }
 
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
@@ skipping 166 matching lines @@
 
  private:
   SnapshotWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_