Get rid of ast node ids.

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/bigint_operations.h"
@@ skipping 6521 matching lines @@
 PcDescriptors::Kind PcDescriptors::DescriptorKind(intptr_t index) const {
   return static_cast<PcDescriptors::Kind>(*(EntryAddr(index, kKindEntry)));
 }
 
 
 void PcDescriptors::SetKind(intptr_t index, PcDescriptors::Kind value) const {
   *(EntryAddr(index, kKindEntry)) = value;
 }
 
 
-intptr_t PcDescriptors::NodeId(intptr_t index) const {
-  return Smi::Value(*SmiAddr(index, kNodeIdEntry));
+intptr_t PcDescriptors::DeoptId(intptr_t index) const {
+  return Smi::Value(*SmiAddr(index, kDeoptIdEntry));
 }
 
 
-void PcDescriptors::SetNodeId(intptr_t index, intptr_t value) const {
-  *SmiAddr(index, kNodeIdEntry) = Smi::New(value);
+void PcDescriptors::SetDeoptId(intptr_t index, intptr_t value) const {
+  *SmiAddr(index, kDeoptIdEntry) = Smi::New(value);
 }
 
 
-intptr_t PcDescriptors::TokenIndex(intptr_t index) const {
-  return Smi::Value(*SmiAddr(index, kTokenIndexEntry));
+intptr_t PcDescriptors::TokenPos(intptr_t index) const {
+  return Smi::Value(*SmiAddr(index, kTokenPosEntry));
 }
 
 
-void PcDescriptors::SetTokenIndex(intptr_t index, intptr_t value) const {
-  *SmiAddr(index, kTokenIndexEntry) = Smi::New(value);
+void PcDescriptors::SetTokenPos(intptr_t index, intptr_t value) const {
+  *SmiAddr(index, kTokenPosEntry) = Smi::New(value);
 }
 
 
 intptr_t PcDescriptors::TryIndex(intptr_t index) const {
   ASSERT(DescriptorKind(index) != kDeoptIndex);
   return *(EntryAddr(index, kTryIndexEntry));
 }
 
 
 intptr_t PcDescriptors::DeoptIndex(intptr_t index) const {
@@ skipping 48 matching lines @@
     return "No pc descriptors\n";
   }
   const char* kFormat =
       "0x%" PRIxPTR "\t%s\t%" PRIdPTR "\t%" PRIdPTR "\t%" PRIdPTR "\n";
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   for (intptr_t i = 0; i < Length(); i++) {
     const intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
         DeoptIndex(i) : TryIndex(i);
     len += OS::SNPrint(NULL, 0, kFormat,
-        PC(i), KindAsStr(i), NodeId(i), TokenIndex(i), multi_purpose_index);
+        PC(i), KindAsStr(i), DeoptId(i), TokenPos(i), multi_purpose_index);
   }
   // Allocate the buffer.
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     const intptr_t multi_purpose_index = DescriptorKind(i) == kDeoptIndex ?
         DeoptIndex(i) : TryIndex(i);
     index += OS::SNPrint((buffer + index), (len - index), kFormat,
-        PC(i), KindAsStr(i), NodeId(i), TokenIndex(i), multi_purpose_index);
+        PC(i), KindAsStr(i), DeoptId(i), TokenPos(i), multi_purpose_index);
   }
   return buffer;
 }
 
 
 // Verify assumptions (in debug mode only).
-// - No two deopt descriptors have the same node id (deoptimization).
-// - No two ic-call descriptors have the same node id (type feedback).
+// - No two deopt descriptors have the same deoptimization id.
+// - No two ic-call descriptors have the same deoptimization id (type feedback).
 // - No two descriptors of same kind have the same PC.
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 void PcDescriptors::Verify(bool check_ids) const {
 #if defined(DEBUG)
   // TODO(srdjan): Implement a more efficient way to check, currently drop
   // the check for too large number of descriptors.
   if (Length() > 3000) {
     if (FLAG_trace_compiler) {
       OS::Print("Not checking pc decriptors, length %d\n", Length());
     }
     return;
   }
   for (intptr_t i = 0; i < Length(); i++) {
     uword pc = PC(i);
     PcDescriptors::Kind kind = DescriptorKind(i);
-    // 'node_id' is set for kDeopt and kIcCall and must be unique for one kind.
-    intptr_t node_id = AstNode::kNoId;
+    // 'deopt_id' is set for kDeopt and kIcCall and must be unique for one kind.
+    intptr_t deopt_id = Isolate::kNoDeoptId;
     if (check_ids) {
       if ((DescriptorKind(i) == PcDescriptors::kDeopt) ||
           (DescriptorKind(i) == PcDescriptors::kIcCall)) {
-        node_id = NodeId(i);
+        deopt_id = DeoptId(i);
       }
     }
     for (intptr_t k = i + 1; k < Length(); k++) {
       if (kind == DescriptorKind(k)) {
-        if (node_id != AstNode::kNoId) {
-          ASSERT(NodeId(k) != node_id);
+        if (deopt_id != Isolate::kNoDeoptId) {
+          ASSERT(DeoptId(k) != deopt_id);
         }
         ASSERT(pc != PC(k));
       }
     }
   }
 #endif  // DEBUG
 }
 
 
 void Stackmap::SetCode(const Code& code) const {
@@ skipping 506 matching lines @@
   }
   return Code::null();
 }
 
 
 intptr_t Code::GetTokenIndexOfPC(uword pc) const {
   intptr_t token_pos = -1;
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.PC(i) == pc) {
-      token_pos = descriptors.TokenIndex(i);
+      token_pos = descriptors.TokenPos(i);
       break;
     }
   }
   return token_pos;
 }
 
 
-uword Code::GetDeoptPcAtNodeId(intptr_t node_id) const {
+uword Code::GetDeoptPcAtDeoptId(intptr_t deopt_id) const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if ((descriptors.NodeId(i) == node_id) &&
+    if ((descriptors.DeoptId(i) == deopt_id) &&
         (descriptors.DescriptorKind(i) == PcDescriptors::kDeopt)) {
       return descriptors.PC(i);
     }
   }
   return 0;
 }
 
 
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:0x%d";
@@ skipping 31 matching lines @@
     GrowableArray<intptr_t>* node_ids,
     const GrowableObjectArray& ic_data_objs) const {
   ASSERT(node_ids != NULL);
   ASSERT(!ic_data_objs.IsNull());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(this->pc_descriptors());
   ICData& ic_data_obj = ICData::Handle();
   intptr_t max_id = -1;
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.DescriptorKind(i) == PcDescriptors::kIcCall) {
-      intptr_t node_id = descriptors.NodeId(i);
-      if (node_id > max_id) {
-        max_id = node_id;
+      intptr_t deopt_id = descriptors.DeoptId(i);
+      if (deopt_id > max_id) {
+        max_id = deopt_id;
       }
-      node_ids->Add(node_id);
+      node_ids->Add(deopt_id);
       ic_data_obj = CodePatcher::GetInstanceCallIcDataAt(descriptors.PC(i));
       ic_data_objs.Add(ic_data_obj);
     }
   }
   return max_id;
 }
 
 
 RawStackmap* Code::GetStackmap(uword pc, Array* maps, Stackmap* map) const {
   // This code is used during iterating frames during a GC and hence it
@@ skipping 152 matching lines @@
 void ICData::set_function(const Function& value) const {
   StorePointer(&raw_ptr()->function_, value.raw());
 }
 
 
 void ICData::set_target_name(const String& value) const {
   StorePointer(&raw_ptr()->target_name_, value.raw());
 }
 
 
-void ICData::set_id(intptr_t value) const {
-  raw_ptr()->id_ = value;
+void ICData::set_deopt_id(intptr_t value) const {
+  raw_ptr()->deopt_id_ = value;
 }
 
 
 void ICData::set_num_args_tested(intptr_t value) const {
   raw_ptr()->num_args_tested_ = value;
 }
 
 
 void ICData::set_ic_data(const Array& value) const {
   StorePointer(&raw_ptr()->ic_data_, value.raw());
@@ skipping 131 matching lines @@
 
 
 RawICData* ICData::AsUnaryClassChecks() const {
   ASSERT(!IsNull());
   ASSERT(num_args_tested() > 0);
   if (num_args_tested() == 1) return raw();
   const intptr_t kNumArgsTested = 1;
   ICData& result = ICData::Handle(ICData::New(
       Function::Handle(function()),
       String::Handle(target_name()),
-      id(),
+      deopt_id(),
       kNumArgsTested));
   for (intptr_t i = 0; i < NumberOfChecks(); i++) {
     const intptr_t class_id = GetReceiverClassIdAt(i);
     intptr_t duplicate_class_id = -1;
     for (intptr_t k = 0; k < result.NumberOfChecks(); k++) {
       if (class_id == result.GetReceiverClassIdAt(k)) {
         duplicate_class_id = k;
         break;
       }
     }
     if (duplicate_class_id >= 0) {
       ASSERT(result.GetTargetAt(duplicate_class_id) == GetTargetAt(i));
     } else {
       // This will make sure that Smi is first if it exists.
       result.AddReceiverCheck(class_id,
                               Function::Handle(GetTargetAt(i)));
     }
   }
   return result.raw();
 }
 
 
 RawICData* ICData::New(const Function& function,
                        const String& target_name,
-                       intptr_t id,
+                       intptr_t deopt_id,
                        intptr_t num_args_tested) {
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested > 0);
   ICData& result = ICData::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
     RawObject* raw = Object::Allocate(ICData::kInstanceKind,
                                       ICData::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_function(function);
   result.set_target_name(target_name);
-  result.set_id(id);
+  result.set_deopt_id(deopt_id);
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   result.WriteSentinel();
   return result.raw();
 }
 
@@ skipping 3402 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart