Finishes removing intptr_t from raw object fields.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 10660 matching lines @@
                                       Stackmap::InstanceSize(length),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
   // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
-  result.SetPC(pc_offset);
+  result.SetPcOffset(pc_offset);
   for (intptr_t i = 0; i < length; ++i) {
     result.SetBit(i, bmap->Get(i));
   }
   result.SetRegisterBitCount(register_bit_count);
   return result.raw();
 }
 
 
 const char* Stackmap::ToCString() const {
   if (IsNull()) {
     return "{null}";
   } else {
     const char* kFormat = "%#" Px ": ";
-    intptr_t fixed_length = OS::SNPrint(NULL, 0, kFormat, PC()) + 1;
+    intptr_t fixed_length = OS::SNPrint(NULL, 0, kFormat, PcOffset()) + 1;
     Isolate* isolate = Isolate::Current();
     // Guard against integer overflow in the computation of alloc_size.
     //
     // TODO(kmillikin): We could just truncate the string if someone
     // tries to print a 2 billion plus entry stackmap.
     if (Length() > (kIntptrMax - fixed_length)) {
       FATAL1("Length() is unexpectedly large (%" Pd ")", Length());
     }
     intptr_t alloc_size = fixed_length + Length();
     char* chars = isolate->current_zone()->Alloc<char>(alloc_size);
-    intptr_t index = OS::SNPrint(chars, alloc_size, kFormat, PC());
+    intptr_t index = OS::SNPrint(chars, alloc_size, kFormat, PcOffset());
     for (intptr_t i = 0; i < Length(); i++) {
       chars[index++] = IsObject(i) ? '1' : '0';
     }
     chars[index] = '\0';
     return chars;
   }
 }
 
 
 void Stackmap::PrintJSONImpl(JSONStream* stream, bool ref) const {
@@ skipping 50 matching lines @@
       UNREACHABLE();
       return "Unknown";
   }
 }
 
 
 static int PrintVarInfo(char* buffer, int len,
                         intptr_t i,
                         const String& var_name,
                         const RawLocalVarDescriptors::VarInfo& info) {
-  if (info.kind == RawLocalVarDescriptors::kContextLevel) {
+  const int8_t kind = info.kind();
+  const int32_t index = info.index();
+  if (kind == RawLocalVarDescriptors::kContextLevel) {
     return OS::SNPrint(buffer, len,
-                       "%2" Pd " %-13s level=%-3" Pd " scope=%-3d"
-                       " begin=%-3" Pd " end=%" Pd "\n",
+                       "%2" Pd " %-13s level=%-3d scope=%-3d"
+                       " begin=%-3d end=%d\n",
                        i,
-                       VarKindString(info.kind),
-                       info.index,
+                       VarKindString(kind),
+                       index,
                        info.scope_id,
                        info.begin_pos,
                        info.end_pos);
-  } else if (info.kind == RawLocalVarDescriptors::kContextVar) {
+  } else if (kind == RawLocalVarDescriptors::kContextVar) {
     return OS::SNPrint(buffer, len,
-                       "%2" Pd " %-13s level=%-3d index=%-3" Pd ""
-                       " begin=%-3" Pd " end=%-3" Pd " name=%s\n",
+                       "%2" Pd " %-13s level=%-3d index=%-3d"
+                       " begin=%-3d end=%-3d name=%s\n",
                        i,
-                       VarKindString(info.kind),
+                       VarKindString(kind),
                        info.scope_id,
-                       info.index,
+                       index,
                        info.begin_pos,
                        info.end_pos,
                        var_name.ToCString());
   } else {
     return OS::SNPrint(buffer, len,
-                       "%2" Pd " %-13s scope=%-3d index=%-3" Pd ""
-                       " begin=%-3" Pd " end=%-3" Pd " name=%s\n",
+                       "%2" Pd " %-13s scope=%-3d index=%-3d"
+                       " begin=%-3d end=%-3d name=%s\n",
                        i,
-                       VarKindString(info.kind),
+                       VarKindString(kind),
                        info.scope_id,
-                       info.index,
+                       index,
                        info.begin_pos,
                        info.end_pos,
                        var_name.ToCString());
   }
 }
 
 
 const char* LocalVarDescriptors::ToCString() const {
   if (IsNull()) {
     return "LocalVarDescriptors(NULL)";
@@ skipping 30 matching lines @@
 void LocalVarDescriptors::PrintJSONImpl(JSONStream* stream,
                                         bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
   ASSERT(Object::var_descriptors_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
-    FATAL1("Fatal error in LocalVarDescriptors::New: "
-           "invalid num_variables %" Pd "\n", num_variables);
+    FATAL2("Fatal error in LocalVarDescriptors::New: "
+           "invalid num_variables %" Pd ". Maximum is: %d\n",
+           num_variables, RawLocalVarDescriptors::kMaxIndex);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
     RawObject* raw = Object::Allocate(LocalVarDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->length_ = num_variables;
@@ skipping 1466 matching lines @@
       ? EntryPoint() + patch_code_pc_offset() : 0;
 }
 
 
 uword Code::GetLazyDeoptPc() const {
   return (lazy_deopt_pc_offset() != kInvalidPc)
       ? EntryPoint() + lazy_deopt_pc_offset() : 0;
 }
 
 
-RawStackmap* Code::GetStackmap(uword pc, Array* maps, Stackmap* map) const {
+RawStackmap* Code::GetStackmap(
+    uint32_t pc_offset, Array* maps, Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
   // should not in turn start a GC.
   NoGCScope no_gc;
   if (stackmaps() == Array::null()) {
     // No stack maps are present in the code object which means this
     // frame relies on tagged pointers.
     return Stackmap::null();
   }
   // A stack map is present in the code object, use the stack map to visit
   // frame slots which are marked as having objects.
   *maps = stackmaps();
   *map = Stackmap::null();
   for (intptr_t i = 0; i < maps->Length(); i++) {
     *map ^= maps->At(i);
     ASSERT(!map->IsNull());
-    if (map->PC() == pc) {
+    if (map->PcOffset() == pc_offset) {
       return map->raw();  // We found a stack map for this frame.
     }
   }
   // If the code has stackmaps, it must have them for all safepoints.
   UNREACHABLE();
   return Stackmap::null();
 }
 
 
 RawContext* Context::New(intptr_t num_variables, Heap::Space space) {
@@ skipping 6974 matching lines @@
 
 RawJSRegExp* JSRegExp::FromDataStartAddress(void* data) {
   JSRegExp& regexp = JSRegExp::Handle();
   intptr_t addr = reinterpret_cast<intptr_t>(data) - sizeof(RawJSRegExp);
   regexp ^= RawObject::FromAddr(addr);
   return regexp.raw();
 }
 
 
 const char* JSRegExp::Flags() const {
-  switch (raw_ptr()->flags_) {
+  switch (flags()) {
     case kGlobal | kIgnoreCase | kMultiLine :
     case kIgnoreCase | kMultiLine :
       return "im";
     case kGlobal | kIgnoreCase :
     case kIgnoreCase:
       return "i";
     case kGlobal | kMultiLine :
     case kMultiLine:
       return "m";
     default:
@@ skipping 250 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart