fix gdbjit

src/gdb-jit.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef ENABLE_GDB_JIT_INTERFACE
 #include "v8.h"
 #include "gdb-jit.h"
 
 #include "bootstrapper.h"
 #include "compiler.h"
+#include "frames-inl.h"
 #include "global-handles.h"
 #include "messages.h"
 #include "platform.h"
 #include "natives.h"
 #include "scopeinfo.h"
+#include "scopes.h"
 
 namespace v8 {
 namespace internal {
 
 #ifdef __APPLE__
 #define __MACH_O
 class MachO;
 class MachOSection;
 typedef MachO DebugObject;
 typedef MachOSection DebugSection;
 #else
 #define __ELF
 class ELF;
 class ELFSection;
 typedef ELF DebugObject;
 typedef ELFSection DebugSection;
 #endif
 
 class Writer BASE_EMBEDDED {
  public:
-  explicit Writer(DebugObject* debug_object)
-      : debug_object_(debug_object),
+  Writer(DebugObject* debug_object, Zone* zone)
+      : zone_(zone),
+        debug_object_(debug_object),
         position_(0),
         capacity_(1024),
         buffer_(reinterpret_cast<byte*>(malloc(capacity_))) {
   }
 
   ~Writer() {
     free(buffer_);
   }
 
   uintptr_t position() const {
     return position_;
   }
 
+  Zone* zone() {
+    return zone_;
+  }
+
   template<typename T>
   class Slot {
    public:
     Slot(Writer* w, uintptr_t offset) : w_(w), offset_(offset) { }
 
     T* operator-> () {
       return w_->RawSlotAt<T>(offset_);
     }
 
     void set(const T& value) {
@@ skipping 88 matching lines @@
 
  private:
   template<typename T> friend class Slot;
 
   template<typename T>
   T* RawSlotAt(uintptr_t offset) {
     ASSERT(offset < capacity_ && offset + sizeof(T) <= capacity_);
     return reinterpret_cast<T*>(&buffer_[offset]);
   }
 
+  Zone* zone_;
   DebugObject* debug_object_;
   uintptr_t position_;
   uintptr_t capacity_;
   byte* buffer_;
 };
 
 class StringTable;
 
 template<typename THeader>
 class DebugSectionBase : public ZoneObject {
  public:
   virtual ~DebugSectionBase() { }
 
-  virtual void WriteBody(Writer::Slot<THeader> header, Writer* writer) {
+  virtual void WriteHeadersAndBody(Writer::Slot<THeader> header,
+                                   Writer* writer) {
     uintptr_t start = writer->position();
     if (WriteBody(writer)) {
       uintptr_t end = writer->position();
       header->offset = start;
 #if defined(__MACH_O)
       header->addr = 0;
 #endif
       header->size = end - start;
     }
   }
@@ skipping 125 matching lines @@
     INDEX_ABSOLUTE = 0xfff1
   };
 
   ELFSection(const char* name, Type type, uintptr_t align)
       : name_(name), type_(type), align_(align) { }
 
   virtual ~ELFSection() { }
 
   void PopulateHeader(Writer::Slot<Header> header, StringTable* strtab);
 
-  virtual void WriteBody(Writer::Slot<Header> header, Writer* w) {
+  virtual void WriteHeadersAndBody(Writer::Slot<Header> header, Writer* w) {
     uintptr_t start = w->position();
     if (WriteBody(w)) {
       uintptr_t end = w->position();
       header->offset = start;
       header->size = end - start;
     }
   }
 
   virtual bool WriteBody(Writer* w) {
     return false;
@@ skipping 103 matching lines @@
     offset_ = writer_->position();
 
     // First entry in the string table should be an empty string.
     WriteString("");
   }
 
   void DetachWriter() {
     writer_ = NULL;
   }
 
-  virtual void WriteBody(Writer::Slot<Header> header, Writer* w) {
+  virtual void WriteHeadersAndBody(Writer::Slot<Header> header, Writer* w) {
     ASSERT(writer_ == NULL);
     header->offset = offset_;
     header->size = size_;
   }
 
  private:
   void WriteString(const char* str) {
     uintptr_t written = 0;
     do {
       writer_->Write(*str);
@@ skipping 15 matching lines @@
   header->type = type_;
   header->alignment = align_;
   PopulateHeader(header);
 }
 #endif  // defined(__ELF)
 
 
 #if defined(__MACH_O)
 class MachO BASE_EMBEDDED {
  public:
-  MachO() : sections_(6) { }
+  explicit MachO(Zone* zone) : sections_(6, zone) { }
 
-  uint32_t AddSection(MachOSection* section) {
-    sections_.Add(section);
+  uint32_t AddSection(MachOSection* section, Zone* zone) {
+    sections_.Add(section, zone);
     return sections_.length() - 1;
   }
 
   void Write(Writer* w, uintptr_t code_start, uintptr_t code_size) {
     Writer::Slot<MachOHeader> header = WriteHeader(w);
     uintptr_t load_command_start = w->position();
     Writer::Slot<MachOSegmentCommand> cmd = WriteSegmentCommand(w,
                                                                 code_start,
                                                                 code_size);
     WriteSections(w, cmd, header, load_command_start);
@@ skipping 91 matching lines @@
   void WriteSections(Writer* w,
                      Writer::Slot<MachOSegmentCommand> cmd,
                      Writer::Slot<MachOHeader> header,
                      uintptr_t load_command_start) {
     Writer::Slot<MachOSection::Header> headers =
         w->CreateSlotsHere<MachOSection::Header>(sections_.length());
     cmd->fileoff = w->position();
     header->sizeofcmds = w->position() - load_command_start;
     for (int section = 0; section < sections_.length(); ++section) {
       sections_[section]->PopulateHeader(headers.at(section));
-      sections_[section]->WriteBody(headers.at(section), w);
+      sections_[section]->WriteHeadersAndBody(headers.at(section), w);
     }
     cmd->filesize = w->position() - (uintptr_t)cmd->fileoff;
   }
 
 
   ZoneList<MachOSection*> sections_;
 };
 #endif  // defined(__MACH_O)
 
 
 #if defined(__ELF)
 class ELF BASE_EMBEDDED {
  public:
-  ELF() : sections_(6) {
-    sections_.Add(new ELFSection("", ELFSection::TYPE_NULL, 0));
-    sections_.Add(new StringTable(".shstrtab"));
+  explicit ELF(Zone* zone) : sections_(6, zone) {
+    sections_.Add(new(zone) ELFSection("", ELFSection::TYPE_NULL, 0), zone);
+    sections_.Add(new(zone) StringTable(".shstrtab"), zone);
   }
 
   void Write(Writer* w) {
     WriteHeader(w);
     WriteSectionTable(w);
     WriteSections(w);
   }
 
   ELFSection* SectionAt(uint32_t index) {
     return sections_[index];
   }
 
-  uint32_t AddSection(ELFSection* section) {
-    sections_.Add(section);
+  uint32_t AddSection(ELFSection* section, Zone* zone) {
+    sections_.Add(section, zone);
     section->set_index(sections_.length() - 1);
     return sections_.length() - 1;
   }
 
  private:
   struct ELFHeader {
     uint8_t ident[16];
     uint16_t type;
     uint16_t machine;
     uint32_t version;
@@ skipping 73 matching lines @@
     return sizeof(ELFHeader) + sizeof(ELFSection::Header) * section_index;
   }
 
   void WriteSections(Writer* w) {
     Writer::Slot<ELFSection::Header> headers =
         w->SlotAt<ELFSection::Header>(sizeof(ELFHeader));
 
     for (int i = 0, length = sections_.length();
          i < length;
          i++) {
-      sections_[i]->WriteBody(headers.at(i), w);
+      sections_[i]->WriteHeadersAndBody(headers.at(i), w);
     }
   }
 
   ZoneList<ELFSection*> sections_;
 };
 
 
 class ELFSymbol BASE_EMBEDDED {
  public:
   enum Type {
@@ skipping 94 matching lines @@
   uintptr_t value;
   uintptr_t size;
   uint8_t info;
   uint8_t other;
   uint16_t section;
 };
 
 
 class ELFSymbolTable : public ELFSection {
  public:
-  explicit ELFSymbolTable(const char* name)
+  explicit ELFSymbolTable(const char* name, Zone* zone)
       : ELFSection(name, TYPE_SYMTAB, sizeof(uintptr_t)),
-        locals_(1),
-        globals_(1) {
+        locals_(1, zone),
+        globals_(1, zone) {
   }
 
-  virtual void WriteBody(Writer::Slot<Header> header, Writer* w) {
+  virtual void WriteHeadersAndBody(Writer::Slot<Header> header, Writer* w) {
     w->Align(header->alignment);
     int total_symbols = locals_.length() + globals_.length() + 1;
     header->offset = w->position();
 
     Writer::Slot<ELFSymbol::SerializedLayout> symbols =
         w->CreateSlotsHere<ELFSymbol::SerializedLayout>(total_symbols);
 
     header->size = w->position() - header->offset;
 
     // String table for this symbol table should follow it in the section table.
     StringTable* strtab =
         static_cast<StringTable*>(w->debug_object()->SectionAt(index() + 1));
     strtab->AttachWriter(w);
     symbols.at(0).set(ELFSymbol::SerializedLayout(0,
                                                   0,
                                                   0,
                                                   ELFSymbol::BIND_LOCAL,
                                                   ELFSymbol::TYPE_NOTYPE,
                                                   0));
     WriteSymbolsList(&locals_, symbols.at(1), strtab);
     WriteSymbolsList(&globals_, symbols.at(locals_.length() + 1), strtab);
     strtab->DetachWriter();
   }
 
-  void Add(const ELFSymbol& symbol) {
+  void Add(const ELFSymbol& symbol, Zone* zone) {
     if (symbol.binding() == ELFSymbol::BIND_LOCAL) {
-      locals_.Add(symbol);
+      locals_.Add(symbol, zone);
     } else {
-      globals_.Add(symbol);
+      globals_.Add(symbol, zone);
     }
   }
 
  protected:
   virtual void PopulateHeader(Writer::Slot<Header> header) {
     ELFSection::PopulateHeader(header);
     // We are assuming that string table will follow symbol table.
     header->link = index() + 1;
     header->info = locals_.length() + 1;
     header->entry_size = sizeof(ELFSymbol::SerializedLayout);
@@ skipping 110 matching lines @@
   GDBJITInterface::CodeTag tag_;
   CompilationInfo* info_;
 #ifdef V8_TARGET_ARCH_X64
   uintptr_t stack_state_start_addresses_[STACK_STATE_MAX];
 #endif
 };
 
 #if defined(__ELF)
 static void CreateSymbolsTable(CodeDescription* desc,
                                ELF* elf,
-                               int text_section_index) {
-  ELFSymbolTable* symtab = new ELFSymbolTable(".symtab");
-  StringTable* strtab = new StringTable(".strtab");
+                               int text_section_index,
+                               Zone* zone) {
+  ELFSymbolTable* symtab = new(zone) ELFSymbolTable(".symtab", zone);
+  StringTable* strtab = new(zone) StringTable(".strtab");
 
   // Symbol table should be followed by the linked string table.
-  elf->AddSection(symtab);
-  elf->AddSection(strtab);
+  elf->AddSection(symtab, zone);
+  elf->AddSection(strtab, zone);
 
   symtab->Add(ELFSymbol("V8 Code",
                         0,
                         0,
                         ELFSymbol::BIND_LOCAL,
                         ELFSymbol::TYPE_FILE,
-                        ELFSection::INDEX_ABSOLUTE));
+                        ELFSection::INDEX_ABSOLUTE),
+              zone);
 
   symtab->Add(ELFSymbol(desc->name(),
                         0,
                         desc->CodeSize(),
                         ELFSymbol::BIND_GLOBAL,
                         ELFSymbol::TYPE_FUNC,
-                        text_section_index));
+                        text_section_index),
+              zone);
 }
 #endif  // defined(__ELF)
 
 
 class DebugInfoSection : public DebugSection {
  public:
   explicit DebugInfoSection(CodeDescription* desc)
 #if defined(__ELF)
       : ELFSection(".debug_info", TYPE_PROGBITS, 1),
 #else
@@ skipping 36 matching lines @@
     w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
     w->Write<uint32_t>(0);
 
     uint32_t ty_offset = static_cast<uint32_t>(w->position() - cu_start);
     w->WriteULEB128(3);
     w->Write<uint8_t>(kPointerSize);
     w->WriteString("v8value");
 
     if (desc_->IsInfoAvailable()) {
       CompilationInfo* info = desc_->info();
-      ScopeInfo<FreeStoreAllocationPolicy> scope_info(info->scope());
+      Scope* scope = info->scope();
       w->WriteULEB128(2);
       w->WriteString(desc_->name());
       w->Write<intptr_t>(desc_->CodeStart());
       w->Write<intptr_t>(desc_->CodeStart() + desc_->CodeSize());
       Writer::Slot<uint32_t> fb_block_size = w->CreateSlotHere<uint32_t>();
       uintptr_t fb_block_start = w->position();
 #if defined(V8_TARGET_ARCH_IA32)
       w->Write<uint8_t>(DW_OP_reg5);  // The frame pointer's here on ia32
 #elif defined(V8_TARGET_ARCH_X64)
       w->Write<uint8_t>(DW_OP_reg6);  // and here on x64.
 #else
 #error Unsupported target architecture.
 #endif
       fb_block_size.set(static_cast<uint32_t>(w->position() - fb_block_start));
 
-      int params = scope_info.number_of_parameters();
-      int slots = scope_info.number_of_stack_slots();
-      int context_slots = scope_info.number_of_context_slots();
+      ZoneList<Variable*> stack_locals(0, w->zone());
+      ZoneList<Variable*> context_locals(0, w->zone());
+      scope->CollectStackAndContextLocals(&stack_locals, &context_locals);
+
+      int params = scope->num_parameters();
+      int slots = scope->num_stack_slots();
+      int context_slots = scope->num_heap_slots();
       // The real slot ID is internal_slots + context_slot_id.
       int internal_slots = Context::MIN_CONTEXT_SLOTS;
-      int locals = scope_info.LocalCount();
+      int locals = stack_locals.length();
       int current_abbreviation = 4;
 
       for (int param = 0; param < params; ++param) {
         w->WriteULEB128(current_abbreviation++);
         w->WriteString(
-            *scope_info.ParameterName(param)->ToCString(DISALLOW_NULLS));
+            *scope->parameter(param)->name()->ToCString(DISALLOW_NULLS));
         w->Write<uint32_t>(ty_offset);
         Writer::Slot<uint32_t> block_size = w->CreateSlotHere<uint32_t>();
         uintptr_t block_start = w->position();
         w->Write<uint8_t>(DW_OP_fbreg);
         w->WriteSLEB128(
           JavaScriptFrameConstants::kLastParameterOffset +
               kPointerSize * (params - param - 1));
         block_size.set(static_cast<uint32_t>(w->position() - block_start));
       }
 
@@ skipping 27 matching lines @@
            ++context_slot) {
         w->WriteULEB128(current_abbreviation++);
         builder.Reset();
         builder.AddFormatted("context_slot%d", context_slot + internal_slots);
         w->WriteString(builder.Finalize());
       }
 
       for (int local = 0; local < locals; ++local) {
         w->WriteULEB128(current_abbreviation++);
         w->WriteString(
-            *scope_info.LocalName(local)->ToCString(DISALLOW_NULLS));
+            *stack_locals[local]->name()->ToCString(DISALLOW_NULLS));
         w->Write<uint32_t>(ty_offset);
         Writer::Slot<uint32_t> block_size = w->CreateSlotHere<uint32_t>();
         uintptr_t block_start = w->position();
         w->Write<uint8_t>(DW_OP_fbreg);
         w->WriteSLEB128(
           JavaScriptFrameConstants::kLocal0Offset -
               kPointerSize * local);
         block_size.set(static_cast<uint32_t>(w->position() - block_start));
       }
 
@@ skipping 116 matching lines @@
     w->WriteULEB128(DW_FORM_ADDR);
     w->WriteULEB128(DW_AT_HIGH_PC);
     w->WriteULEB128(DW_FORM_ADDR);
     w->WriteULEB128(DW_AT_STMT_LIST);
     w->WriteULEB128(DW_FORM_DATA4);
     w->WriteULEB128(0);
     w->WriteULEB128(0);
 
     if (extra_info) {
       CompilationInfo* info = desc_->info();
-      ScopeInfo<FreeStoreAllocationPolicy> scope_info(info->scope());
-      int params = scope_info.number_of_parameters();
-      int slots = scope_info.number_of_stack_slots();
-      int context_slots = scope_info.number_of_context_slots();
+      Scope* scope = info->scope();
+
+      ZoneList<Variable*> stack_locals(0, w->zone());
+      ZoneList<Variable*> context_locals(0, w->zone());
+      scope->CollectStackAndContextLocals(&stack_locals, &context_locals);
+
+      int params = scope->num_parameters();
+      int slots = scope->num_stack_slots();
+      int context_slots = scope->num_heap_slots();
       // The real slot ID is internal_slots + context_slot_id.
       int internal_slots = Context::MIN_CONTEXT_SLOTS;
-      int locals = scope_info.LocalCount();
+      int locals = stack_locals.length();
       int total_children =
           params + slots + context_slots + internal_slots + locals + 2;
 
       // The extra duplication below seems to be necessary to keep
       // gdb from getting upset on OSX.
       w->WriteULEB128(current_abbreviation++);  // Abbreviation code.
       w->WriteULEB128(DW_TAG_SUBPROGRAM);
       w->Write<uint8_t>(
           total_children != 0 ? DW_CHILDREN_YES : DW_CHILDREN_NO);
       w->WriteULEB128(DW_AT_NAME);
@@ skipping 84 matching lines @@
     DW_LNS_NEGATE_STMT = 6
   };
 
   // DWARF2 standard, figure 35.
   enum DWARF2ExtendedOpcode {
     DW_LNE_END_SEQUENCE = 1,
     DW_LNE_SET_ADDRESS = 2,
     DW_LNE_DEFINE_FILE = 3
   };
 
-  bool WriteBody(Writer* w) {
+  virtual bool WriteBody(Writer* w) {
     // Write prologue.
     Writer::Slot<uint32_t> total_length = w->CreateSlotHere<uint32_t>();
     uintptr_t start = w->position();
 
     // Used for special opcodes
     const int8_t line_base = 1;
     const uint8_t line_range = 7;
     const int8_t max_line_incr = (line_base + line_range - 1);
     const uint8_t opcode_base = DW_LNS_NEGATE_STMT + 1;
 
@@ skipping 340 matching lines @@
 
 bool UnwindInfoSection::WriteBody(Writer* w) {
   uint32_t cie_position = WriteCIE(w);
   WriteFDE(w, cie_position);
   return true;
 }
 
 
 #endif  // V8_TARGET_ARCH_X64
 
-static void CreateDWARFSections(CodeDescription* desc, DebugObject* obj) {
+static void CreateDWARFSections(CodeDescription* desc,
+                                DebugObject* obj,
+                                Zone* zone) {
   if (desc->IsLineInfoAvailable()) {
-    obj->AddSection(new DebugInfoSection(desc));
-    obj->AddSection(new DebugAbbrevSection(desc));
-    obj->AddSection(new DebugLineSection(desc));
+    obj->AddSection(new(zone) DebugInfoSection(desc), zone);
+    obj->AddSection(new(zone) DebugAbbrevSection(desc), zone);
+    obj->AddSection(new(zone) DebugLineSection(desc), zone);
   }
 #ifdef V8_TARGET_ARCH_X64
-  obj->AddSection(new UnwindInfoSection(desc));
+  obj->AddSection(new(zone) UnwindInfoSection(desc), zone);
 #endif
 }
 
 
 // -------------------------------------------------------------------
 // Binary GDB JIT Interface as described in
 //   http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html
 extern "C" {
   typedef enum {
     JIT_NOACTION = 0,
@@ skipping 97 matching lines @@
   if (entry->next_ != NULL) {
     entry->next_->prev_ = entry->prev_;
   }
 
   __jit_debug_descriptor.relevant_entry_ = entry;
   __jit_debug_descriptor.action_flag_ = JIT_UNREGISTER_FN;
   __jit_debug_register_code();
 }
 
 
-static JITCodeEntry* CreateELFObject(CodeDescription* desc) {
-  ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
+static JITCodeEntry* CreateELFObject(CodeDescription* desc, Zone* zone) {
 #ifdef __MACH_O
-  MachO mach_o;
-  Writer w(&mach_o);
+  MachO mach_o(zone);
+  Writer w(&mach_o, zone);
 
-  mach_o.AddSection(new MachOTextSection(kCodeAlignment,
-                                         desc->CodeStart(),
-                                         desc->CodeSize()));
+  MachOTextSection* section = new(zone) MachOTextSection(kCodeAlignment,
+                                                          desc->CodeStart(),
+                                                          desc->CodeSize());
+  mach_o.AddSection(section, zone);
 
-  CreateDWARFSections(desc, &mach_o);
+  CreateDWARFSections(desc, &mach_o, zone);
 
   mach_o.Write(&w, desc->CodeStart(), desc->CodeSize());
 #else
-  ELF elf;
-  Writer w(&elf);
+  ELF elf(zone);
+  Writer w(&elf, zone);
 
-  int text_section_index = elf.AddSection(
-      new FullHeaderELFSection(".text",
-                               ELFSection::TYPE_NOBITS,
-                               kCodeAlignment,
-                               desc->CodeStart(),
-                               0,
-                               desc->CodeSize(),
-                               ELFSection::FLAG_ALLOC | ELFSection::FLAG_EXEC));
+  FullHeaderELFSection* section =
+    new(zone) FullHeaderELFSection(".text",
+                                   ELFSection::TYPE_NOBITS,
+                                   kCodeAlignment,
+                                   desc->CodeStart(),
+                                   0,
+                                   desc->CodeSize(),
+                                   ELFSection::FLAG_ALLOC |
+                                   ELFSection::FLAG_EXEC);
+  int text_section_index = elf.AddSection(section, zone);
 
-  CreateSymbolsTable(desc, &elf, text_section_index);
+  CreateSymbolsTable(desc, &elf, text_section_index, zone);
 
-  CreateDWARFSections(desc, &elf);
+  CreateDWARFSections(desc, &elf, zone);
 
   elf.Write(&w);
 #endif
 
   return CreateCodeEntry(w.buffer(), w.position());
 }
 
 
 static bool SameCodeObjects(void* key1, void* key2) {
   return key1 == key2;
@@ skipping 114 matching lines @@
                             lineinfo,
                             tag,
                             info);
 
   if (!FLAG_gdbjit_full && !code_desc.IsLineInfoAvailable()) {
     delete lineinfo;
     GetEntries()->Remove(code, HashForCodeObject(code));
     return;
   }
 
+  Zone* zone = Isolate::Current()->runtime_zone();

[noordhuis, 2012/08/17 01:28:39]

I suspect that it's better to create a new zone and tie it to the life cycle of
the JITCodeEntry but I'm not sure what the best approach is. Simply new and
delete it?

+  ZoneScope zone_scope(zone, DELETE_ON_EXIT);
+
   AddUnwindInfo(&code_desc);
-  JITCodeEntry* entry = CreateELFObject(&code_desc);
+  JITCodeEntry* entry = CreateELFObject(&code_desc, zone);
   ASSERT(!IsLineInfoTagged(entry));
 
   delete lineinfo;
   e->value = entry;
 
   const char* name_hint = NULL;
   bool should_dump = false;
   if (FLAG_gdbjit_dump) {
     if (strlen(FLAG_gdbjit_dump_filter) == 0) {
       name_hint = name;
@@ skipping 68 matching lines @@
   ScopedLock lock(mutex.Pointer());
   ASSERT(!IsLineInfoTagged(line_info));
   HashMap::Entry* e = GetEntries()->Lookup(code, HashForCodeObject(code), true);
   ASSERT(e->value == NULL);
   e->value = TagLineInfo(line_info);
 }
 
 
 } }  // namespace v8::internal
 #endif