- Fix a lot of warnings generated by -Wshorten-64-to-32

runtime/vm/snapshot.cc

 // 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.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 118 matching lines @@
   ASSERT(kHeaderSize == sizeof(Snapshot));
   ASSERT(kLengthIndex == length_offset());
   ASSERT((kSnapshotFlagIndex * sizeof(int64_t)) == kind_offset());
   ASSERT((kHeapObjectTag & kInlined));
   // The kWatchedBit and kMarkBit are only set during GC operations. This
   // allows the two low bits in the header to be used for snapshotting.
   ASSERT(kObjectId ==
          ((1 << RawObject::kWatchedBit) | (1 << RawObject::kMarkBit)));
   ASSERT((kObjectAlignmentMask & kObjectId) == kObjectId);
   const Snapshot* snapshot = reinterpret_cast<const Snapshot*>(raw_memory);
+  // If the raw length is negative or greater than what the local machine can
+  // handle, then signal an error.
+  if ((snapshot->length_ < 0) || (snapshot->length_ > kIntptrMax)) {
+    return NULL;
+  }
   return snapshot;
 }
 
 
 RawSmi* BaseReader::ReadAsSmi() {
   intptr_t value = ReadIntptrValue();
   ASSERT((value & kSmiTagMask) == kSmiTag);
   return reinterpret_cast<RawSmi*>(value);
 }
 
@@ skipping 70 matching lines @@
   ASSERT(!cls.IsNull());
   return cls.raw();
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == kSmiTag) {
     return NewInteger(value);
   }
-  return ReadObjectImpl(value);
+  ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
+  return ReadObjectImpl(static_cast<intptr_t>(value));
 }
 
 
 intptr_t SnapshotReader::NextAvailableObjectId() const {
   return backward_references_.length() + kMaxPredefinedObjectIds;
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value) {
-  ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
       return ReadIndexedObject(SerializedHeaderData::decode(header_value));
     }
     ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
     intptr_t object_id = SerializedHeaderData::decode(header_value);
     if (object_id == kOmittedObjectId) {
       object_id = NextAvailableObjectId();
     }
     return ReadInlinedObject(object_id);
   }
 }
 
 
 RawObject* SnapshotReader::ReadObjectRef() {
   int64_t header_value = Read<int64_t>();
   if ((header_value & kSmiTagMask) == kSmiTag) {
     return NewInteger(header_value);
   }
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
-  if (IsVMIsolateObject(header_value)) {
-    return ReadVMIsolateObject(header_value);
-  } else if (SerializedHeaderTag::decode(header_value) == kObjectId) {
-    return ReadIndexedObject(SerializedHeaderData::decode(header_value));
+  intptr_t value = static_cast<intptr_t>(header_value);
+  if (IsVMIsolateObject(value)) {
+    return ReadVMIsolateObject(value);
+  } else if (SerializedHeaderTag::decode(value) == kObjectId) {
+    return ReadIndexedObject(SerializedHeaderData::decode(value));
   }
-  ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
-  intptr_t object_id = SerializedHeaderData::decode(header_value);
+  ASSERT(SerializedHeaderTag::decode(value) == kInlined);
+  intptr_t object_id = SerializedHeaderData::decode(value);
   if (object_id == kOmittedObjectId) {
     object_id = NextAvailableObjectId();
   }
   ASSERT(GetBackRef(object_id) == NULL);
 
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
@@ skipping 419 matching lines @@
 
 
 RawUnhandledException* SnapshotReader::NewUnhandledException() {
   ALLOC_NEW_OBJECT(UnhandledException, Object::unhandled_exception_class());
 }
 
 
 RawObject* SnapshotReader::NewInteger(int64_t value) {
   ASSERT((value & kSmiTagMask) == kSmiTag);
   value = value >> kSmiTagShift;
-  if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
-    return Smi::New(value);
+  if (Smi::IsValid(value)) {
+    return Smi::New(static_cast<intptr_t>(value));
   }
   if (kind_ == Snapshot::kFull) {
     return NewMint(value);
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawStacktrace* SnapshotReader::NewStacktrace() {
   ALLOC_NEW_OBJECT(Stacktrace, object_store()->stacktrace_class());
@@ skipping 914 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart