Add runtime and native entry tags

runtime/vm/tags.cc

 // Copyright (c) 2014, 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/tags.h"
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
+#include "vm/native_entry.h"
 
 namespace dart {
 
 const char* VMTag::TagName(uword tag) {
+  if (IsNativeEntryTag(tag)) {
+    const char* native_reverse_lookup = NativeEntry::ReverseLookup(tag);
+    if (native_reverse_lookup != NULL) {
+      return native_reverse_lookup;
+    }
+    return "Unknown native entry";
+  } else if (IsRuntimeEntryTag(tag)) {
+    const char* runtime_entry_name = RuntimeEntryTagName(tag);
+    ASSERT(runtime_entry_name != NULL);
+    return runtime_entry_name;
+  }
   ASSERT(tag != kInvalidTagId);
   ASSERT(tag < kNumVMTags);
   const TagEntry& entry = entries_[tag];
   ASSERT(entry.id == tag);
   return entry.name;
 }
 
 
+bool VMTag::IsNativeEntryTag(uword tag) {
+  ASSERT(tag != kInvalidTagId);
+  ASSERT(tag != kNumVMTags);
+  return (tag > kNumVMTags) && !IsRuntimeEntryTag(tag);
+}
+
+#define DECLARE_RUNTIME_ENTRY_POINT(name)                                      \
+  extern void DRT_##name(NativeArguments arguments);
+RUNTIME_ENTRY_TAG_LIST(DECLARE_RUNTIME_ENTRY_POINT);
+#undef DECLARE_RUNTIME_ENTRY_POINT
+
+#define REGISTER_RUNTIME_ENTRY(name)                                           \
+  { ""#name, reinterpret_cast<uword>(&DRT_##name) },
+
+static struct RuntimeEntries {
+  const char* name;
+  uword entry;
+} RuntimeTagEntries[] = {
+  RUNTIME_ENTRY_TAG_LIST(REGISTER_RUNTIME_ENTRY)
+};
+
+
+bool VMTag::IsRuntimeEntryTag(uword id) {
+  int num_entries = sizeof(RuntimeTagEntries) / sizeof(struct RuntimeEntries);
+  for (int i = 0; i < num_entries; i++) {
+    if (RuntimeTagEntries[i].entry == id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
+const char* VMTag::RuntimeEntryTagName(uword id) {
+  int num_entries = sizeof(RuntimeTagEntries) / sizeof(struct RuntimeEntries);
+  for (int i = 0; i < num_entries; i++) {
+    if (RuntimeTagEntries[i].entry == id) {
+      return RuntimeTagEntries[i].name;
+    }
+  }
+  return NULL;
+}
+
+
 VMTag::TagEntry VMTag::entries_[] = {
   { "InvalidTag", kInvalidTagId, },
 #define DEFINE_VM_TAG_ENTRY(tag)                                               \
   { ""#tag, k##tag##TagId },
   VM_TAG_LIST(DEFINE_VM_TAG_ENTRY)
 #undef DEFINE_VM_TAG_ENTRY
   { "kNumVMTags", kNumVMTags },
 };
 
 
@@ skipping 12 matching lines @@
 
 
 VMTagCounters::VMTagCounters() {
   for (intptr_t i = 0; i < VMTag::kNumVMTags; i++) {
     counters_[i] = 0;
   }
 }
 
 
 void VMTagCounters::Increment(uword tag) {
+  if (VMTag::IsRuntimeEntryTag(tag)) {
+    counters_[VMTag::kRuntimeTagId]++;
+    return;
+  } else if (tag > VMTag::kNumVMTags) {
+    // Assume native entry.
+    counters_[VMTag::kNativeTagId]++;
+    return;
+  }
   ASSERT(tag != VMTag::kInvalidTagId);
   ASSERT(tag < VMTag::kNumVMTags);
   counters_[tag]++;
 }
 
 
 int64_t VMTagCounters::count(uword tag) {
   ASSERT(tag != VMTag::kInvalidTagId);
   ASSERT(tag < VMTag::kNumVMTags);
   return counters_[tag];
 }
 
 
 void VMTagCounters::PrintToJSONObject(JSONObject* obj) {
   {
     JSONArray arr(obj, "names");
     for (intptr_t i = 1; i < VMTag::kNumVMTags; i++) {
       arr.AddValue(VMTag::TagName(i));
     }
   }
   {
     JSONArray arr(obj, "counters");
     for (intptr_t i = 1; i < VMTag::kNumVMTags; i++) {
       arr.AddValue64(counters_[i]);
     }
   }
 }
 
 }  // namespace dart