Revert of [arm] Share constant pool entries in snapshot.

src/disassembler.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/disassembler.h"
 
 #include <memory>
 
 #include "src/assembler-inl.h"
 #include "src/code-stubs.h"
@@ skipping 56 matching lines @@
 
 static void DumpBuffer(std::ostream* os, StringBuilder* out) {
   (*os) << out->Finalize() << std::endl;
   out->Reset();
 }
 
 
 static const int kOutBufferSize = 2048 + String::kMaxShortPrintLength;
 static const int kRelocInfoPosition = 57;
 
-static void PrintRelocInfo(StringBuilder* out, Isolate* isolate,
-                           const ExternalReferenceEncoder& ref_encoder,
-                           std::ostream* os, RelocInfo* relocinfo,
-                           bool first_reloc_info = true) {
-  // Indent the printing of the reloc info.
-  if (first_reloc_info) {
-    // The first reloc info is printed after the disassembled instruction.
-    out->AddPadding(' ', kRelocInfoPosition - out->position());
-  } else {
-    // Additional reloc infos are printed on separate lines.
-    DumpBuffer(os, out);
-    out->AddPadding(' ', kRelocInfoPosition);
-  }
-
-  RelocInfo::Mode rmode = relocinfo->rmode();
-  if (rmode == RelocInfo::DEOPT_SCRIPT_OFFSET) {
-    out->AddFormatted("    ;; debug: deopt position, script offset '%d'",
-                      static_cast<int>(relocinfo->data()));
-  } else if (rmode == RelocInfo::DEOPT_INLINING_ID) {
-    out->AddFormatted("    ;; debug: deopt position, inlining id '%d'",
-                      static_cast<int>(relocinfo->data()));
-  } else if (rmode == RelocInfo::DEOPT_REASON) {
-    DeoptimizeReason reason = static_cast<DeoptimizeReason>(relocinfo->data());
-    out->AddFormatted("    ;; debug: deopt reason '%s'",
-                      DeoptimizeReasonToString(reason));
-  } else if (rmode == RelocInfo::DEOPT_ID) {
-    out->AddFormatted("    ;; debug: deopt index %d",
-                      static_cast<int>(relocinfo->data()));
-  } else if (rmode == RelocInfo::EMBEDDED_OBJECT) {
-    HeapStringAllocator allocator;
-    StringStream accumulator(&allocator);
-    relocinfo->target_object()->ShortPrint(&accumulator);
-    std::unique_ptr<char[]> obj_name = accumulator.ToCString();
-    out->AddFormatted("    ;; object: %s", obj_name.get());
-  } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
-    const char* reference_name = ref_encoder.NameOfAddress(
-        isolate, relocinfo->target_external_reference());
-    out->AddFormatted("    ;; external reference (%s)", reference_name);
-  } else if (RelocInfo::IsCodeTarget(rmode)) {
-    out->AddFormatted("    ;; code:");
-    Code* code = Code::GetCodeFromTargetAddress(relocinfo->target_address());
-    Code::Kind kind = code->kind();
-    if (code->is_inline_cache_stub()) {
-      out->AddFormatted(" %s", Code::Kind2String(kind));
-      if (kind == Code::BINARY_OP_IC || kind == Code::TO_BOOLEAN_IC ||
-          kind == Code::COMPARE_IC) {
-        InlineCacheState ic_state = IC::StateFromCode(code);
-        out->AddFormatted(" %s", Code::ICState2String(ic_state));
-      }
-    } else if (kind == Code::STUB || kind == Code::HANDLER) {
-      // Get the STUB key and extract major and minor key.
-      uint32_t key = code->stub_key();
-      uint32_t minor_key = CodeStub::MinorKeyFromKey(key);
-      CodeStub::Major major_key = CodeStub::GetMajorKey(code);
-      DCHECK(major_key == CodeStub::MajorKeyFromKey(key));
-      out->AddFormatted(" %s, %s, ", Code::Kind2String(kind),
-                        CodeStub::MajorName(major_key));
-      out->AddFormatted("minor: %d", minor_key);
-    } else {
-      out->AddFormatted(" %s", Code::Kind2String(kind));
-    }
-    if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
-      out->AddFormatted(" (id = %d)", static_cast<int>(relocinfo->data()));
-    }
-  } else if (RelocInfo::IsRuntimeEntry(rmode) &&
-             isolate->deoptimizer_data() != nullptr) {
-    // A runtime entry reloinfo might be a deoptimization bailout->
-    Address addr = relocinfo->target_address();
-    int id =
-        Deoptimizer::GetDeoptimizationId(isolate, addr, Deoptimizer::EAGER);
-    if (id == Deoptimizer::kNotDeoptimizationEntry) {
-      id = Deoptimizer::GetDeoptimizationId(isolate, addr, Deoptimizer::LAZY);
-      if (id == Deoptimizer::kNotDeoptimizationEntry) {
-        id = Deoptimizer::GetDeoptimizationId(isolate, addr, Deoptimizer::SOFT);
-        if (id == Deoptimizer::kNotDeoptimizationEntry) {
-          out->AddFormatted("    ;; %s", RelocInfo::RelocModeName(rmode));
-        } else {
-          out->AddFormatted("    ;; soft deoptimization bailout %d", id);
-        }
-      } else {
-        out->AddFormatted("    ;; lazy deoptimization bailout %d", id);
-      }
-    } else {
-      out->AddFormatted("    ;; deoptimization bailout %d", id);
-    }
-  } else {
-    out->AddFormatted("    ;; %s", RelocInfo::RelocModeName(rmode));
-  }
-}
-
 static int DecodeIt(Isolate* isolate, std::ostream* os,
                     const V8NameConverter& converter, byte* begin, byte* end) {
   SealHandleScope shs(isolate);
   DisallowHeapAllocation no_alloc;
   ExternalReferenceEncoder ref_encoder(isolate);
 
   v8::internal::EmbeddedVector<char, 128> decode_buffer;
   v8::internal::EmbeddedVector<char, kOutBufferSize> out_buffer;
   StringBuilder out(out_buffer.start(), out_buffer.length());
   byte* pc = begin;
@@ skipping 68 matching lines @@
                      prev_pc - begin);
 
     // Instruction.
     out.AddFormatted("%s", decode_buffer.start());
 
     // Print all the reloc info for this instruction which are not comments.
     for (int i = 0; i < pcs.length(); i++) {
       // Put together the reloc info
       RelocInfo relocinfo(pcs[i], rmodes[i], datas[i], converter.code());
 
-      bool first_reloc_info = (i == 0);
-      PrintRelocInfo(&out, isolate, ref_encoder, os, &relocinfo,
-                     first_reloc_info);
-    }
+      // Indent the printing of the reloc info.
+      if (i == 0) {
+        // The first reloc info is printed after the disassembled instruction.
+        out.AddPadding(' ', kRelocInfoPosition - out.position());
+      } else {
+        // Additional reloc infos are printed on separate lines.
+        DumpBuffer(os, &out);
+        out.AddPadding(' ', kRelocInfoPosition);
+      }
 
-    // If this is a constant pool load and we haven't found any RelocInfo
-    // already, check if we can find some RelocInfo for the target address in
-    // the constant pool.
-    if (pcs.is_empty() && converter.code() != nullptr) {
-      RelocInfo dummy_rinfo(prev_pc, RelocInfo::NONE32, 0, nullptr);
-      if (dummy_rinfo.IsInConstantPool()) {
-        byte* constant_pool_entry_address =
-            dummy_rinfo.constant_pool_entry_address();
-        RelocIterator* it = new RelocIterator(converter.code());
-        while (!it->done()) {
-          if (it->rinfo()->IsInConstantPool() &&
-              (it->rinfo()->constant_pool_entry_address() ==
-               constant_pool_entry_address)) {
-            PrintRelocInfo(&out, isolate, ref_encoder, os, it->rinfo());
-            break;
+      RelocInfo::Mode rmode = relocinfo.rmode();
+      if (rmode == RelocInfo::DEOPT_SCRIPT_OFFSET) {
+        out.AddFormatted("    ;; debug: deopt position, script offset '%d'",
+                         static_cast<int>(relocinfo.data()));
+      } else if (rmode == RelocInfo::DEOPT_INLINING_ID) {
+        out.AddFormatted("    ;; debug: deopt position, inlining id '%d'",
+                         static_cast<int>(relocinfo.data()));
+      } else if (rmode == RelocInfo::DEOPT_REASON) {
+        DeoptimizeReason reason =
+            static_cast<DeoptimizeReason>(relocinfo.data());
+        out.AddFormatted("    ;; debug: deopt reason '%s'",
+                         DeoptimizeReasonToString(reason));
+      } else if (rmode == RelocInfo::DEOPT_ID) {
+        out.AddFormatted("    ;; debug: deopt index %d",
+                         static_cast<int>(relocinfo.data()));
+      } else if (rmode == RelocInfo::EMBEDDED_OBJECT) {
+        HeapStringAllocator allocator;
+        StringStream accumulator(&allocator);
+        relocinfo.target_object()->ShortPrint(&accumulator);
+        std::unique_ptr<char[]> obj_name = accumulator.ToCString();
+        out.AddFormatted("    ;; object: %s", obj_name.get());
+      } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
+        const char* reference_name = ref_encoder.NameOfAddress(
+            isolate, relocinfo.target_external_reference());
+        out.AddFormatted("    ;; external reference (%s)", reference_name);
+      } else if (RelocInfo::IsCodeTarget(rmode)) {
+        out.AddFormatted("    ;; code:");
+        Code* code = Code::GetCodeFromTargetAddress(relocinfo.target_address());
+        Code::Kind kind = code->kind();
+        if (code->is_inline_cache_stub()) {
+          out.AddFormatted(" %s", Code::Kind2String(kind));
+          if (kind == Code::BINARY_OP_IC || kind == Code::TO_BOOLEAN_IC ||
+              kind == Code::COMPARE_IC) {
+            InlineCacheState ic_state = IC::StateFromCode(code);
+            out.AddFormatted(" %s", Code::ICState2String(ic_state));
           }
-          it->next();
+        } else if (kind == Code::STUB || kind == Code::HANDLER) {
+          // Get the STUB key and extract major and minor key.
+          uint32_t key = code->stub_key();
+          uint32_t minor_key = CodeStub::MinorKeyFromKey(key);
+          CodeStub::Major major_key = CodeStub::GetMajorKey(code);
+          DCHECK(major_key == CodeStub::MajorKeyFromKey(key));
+          out.AddFormatted(" %s, %s, ", Code::Kind2String(kind),
+                           CodeStub::MajorName(major_key));
+          out.AddFormatted("minor: %d", minor_key);
+        } else {
+          out.AddFormatted(" %s", Code::Kind2String(kind));
         }
+        if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
+          out.AddFormatted(" (id = %d)", static_cast<int>(relocinfo.data()));
+        }
+      } else if (RelocInfo::IsRuntimeEntry(rmode) &&
+                 isolate->deoptimizer_data() != NULL) {
+        // A runtime entry reloinfo might be a deoptimization bailout.
+        Address addr = relocinfo.target_address();
+        int id = Deoptimizer::GetDeoptimizationId(isolate,
+                                                  addr,
+                                                  Deoptimizer::EAGER);
+        if (id == Deoptimizer::kNotDeoptimizationEntry) {
+          id = Deoptimizer::GetDeoptimizationId(isolate,
+                                                addr,
+                                                Deoptimizer::LAZY);
+          if (id == Deoptimizer::kNotDeoptimizationEntry) {
+            id = Deoptimizer::GetDeoptimizationId(isolate,
+                                                  addr,
+                                                  Deoptimizer::SOFT);
+            if (id == Deoptimizer::kNotDeoptimizationEntry) {
+              out.AddFormatted("    ;; %s", RelocInfo::RelocModeName(rmode));
+            } else {
+              out.AddFormatted("    ;; soft deoptimization bailout %d", id);
+            }
+          } else {
+            out.AddFormatted("    ;; lazy deoptimization bailout %d", id);
+          }
+        } else {
+          out.AddFormatted("    ;; deoptimization bailout %d", id);
+        }
+      } else {
+        out.AddFormatted("    ;; %s", RelocInfo::RelocModeName(rmode));
       }
     }
-
     DumpBuffer(os, &out);
   }
 
   // Emit comments following the last instruction (if any).
   if (it != NULL) {
     for ( ; !it->done(); it->next()) {
       if (RelocInfo::IsComment(it->rinfo()->rmode())) {
         out.AddFormatted("                  %s",
                          reinterpret_cast<const char*>(it->rinfo()->data()));
         DumpBuffer(os, &out);
@@ skipping 16 matching lines @@
 
 int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
                          byte* end, Code* code) {
   return 0;
 }
 
 #endif  // ENABLE_DISASSEMBLER
 
 }  // namespace internal
 }  // namespace v8