Make profiler work without Instructions -> Code pointer

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 1753 matching lines @@
 
 RawString* Object::DictionaryName() const {
   return String::null();
 }
 
 
 void Object::InitializeObject(uword address,
                               intptr_t class_id,
                               intptr_t size,
                               bool is_vm_object) {
-  const uword break_instruction_value = Assembler::GetBreakInstructionFiller();
-  const uword null_value = reinterpret_cast<uword>(null_);
-  const bool is_instructions = class_id == kInstructionsCid;
-  uword initial_value =
-      is_instructions ? break_instruction_value : null_value;
+  uword initial_value = (class_id == kInstructionsCid)
+      ? Assembler::GetBreakInstructionFiller() : reinterpret_cast<uword>(null_);
   uword cur = address;
   uword end = address + size;
-  if (is_instructions) {
-    // Fill the header with null. The remainder of the Instructions object will
-    // be filled with the break_instruction_value.
-    uword header_end = address + Instructions::HeaderSize();
-    while (cur < header_end) {
-      *reinterpret_cast<uword*>(cur) = null_value;
-      cur += kWordSize;
-    }
-  }
   while (cur < end) {
     *reinterpret_cast<uword*>(cur) = initial_value;
     cur += kWordSize;
   }
   uword tags = 0;
   ASSERT(class_id != kIllegalCid);
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   tags = RawObject::VMHeapObjectTag::update(is_vm_object, tags);
   reinterpret_cast<RawObject*>(address)->tags_ = tags;
@@ skipping 11530 matching lines @@
   intptr_t pointer_offset_count = assembler->CountPointerOffsets();
   Code& code = Code::ZoneHandle(Code::New(pointer_offset_count));
 #ifdef TARGET_ARCH_IA32
   assembler->set_code_object(code);
 #endif
   Instructions& instrs =
       Instructions::ZoneHandle(Instructions::New(assembler->CodeSize()));
   INC_STAT(Thread::Current(), total_instr_size, assembler->CodeSize());
   INC_STAT(Thread::Current(), total_code_size, assembler->CodeSize());
 
-  instrs.set_code(code.raw());
   // Copy the instructions into the instruction area and apply all fixups.
   // Embedded pointers are still in handles at this point.
   MemoryRegion region(reinterpret_cast<void*>(instrs.EntryPoint()),
                       instrs.size());
   assembler->FinalizeInstructions(region);
   VerifiedMemory::Accept(region.start(), region.size());
   CPU::FlushICache(instrs.EntryPoint(), instrs.size());
 
   code.set_compile_timestamp(OS::GetCurrentTimeMicros());
   CodeObservers::NotifyAll(name,
@@ skipping 60 matching lines @@
   if (CodeObservers::AreActive()) {
     return FinalizeCode(function.ToLibNamePrefixedQualifiedCString(),
                         assembler,
                         optimized);
   } else {
     return FinalizeCode("", assembler);
   }
 }
 
 
-// Check if object matches find condition.
-bool Code::FindRawCodeVisitor::FindObject(RawObject* raw_obj) const {
-  uword tags = raw_obj->ptr()->tags_;
-  if (RawObject::ClassIdTag::decode(tags) == kInstructionsCid) {
-    RawInstructions* raw_insts = reinterpret_cast<RawInstructions*>(raw_obj);
-    return RawInstructions::ContainsPC(raw_insts, pc_);
-  }
-  return false;
-}
-
-
 bool Code::SlowFindRawCodeVisitor::FindObject(RawObject* raw_obj) const {
   return RawCode::ContainsPC(raw_obj, pc_);
 }
 
 
 RawCode* Code::LookupCodeInIsolate(Isolate* isolate, uword pc) {
   ASSERT((isolate == Isolate::Current()) || (isolate == Dart::vm_isolate()));
   if (isolate->heap() == NULL) {
     return Code::null();
   }
   NoSafepointScope no_safepoint;
-  // TODO(johnmccutchan): Make lookup without a back pointer faster and use for
-  // both cases.
-  if (Dart::IsRunningPrecompiledCode()) {
-    SlowFindRawCodeVisitor visitor(pc);
-    RawObject* needle = isolate->heap()->FindOldObject(&visitor);
-    if (needle != Code::null()) {
-      return static_cast<RawCode*>(needle);
-    }
-    return Code::null();
-  } else {
-    FindRawCodeVisitor visitor(pc);
-    RawInstructions* instr;
-    instr = isolate->heap()->FindObjectInCodeSpace(&visitor);
-    if (instr != Instructions::null()) {
-      return Instructions::Handle(instr).code();
-    }
-    return Code::null();
+  SlowFindRawCodeVisitor visitor(pc);
+  RawObject* needle = isolate->heap()->FindOldObject(&visitor);
+  if (needle != Code::null()) {
+    return static_cast<RawCode*>(needle);
   }
+  return Code::null();
 }
 
 
 RawCode* Code::LookupCode(uword pc) {
   return LookupCodeInIsolate(Isolate::Current(), pc);
 }
 
 
 RawCode* Code::LookupCodeInVmIsolate(uword pc) {
   return LookupCodeInIsolate(Dart::vm_isolate(), pc);
@@ skipping 8462 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart