Rename the VM internal class ByteArray to ByteVector.

runtime/vm/debuginfo_linux.cc

 // Copyright (c) 2011, 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/debuginfo.h"
 
 #include "vm/gdbjit_linux.h"
 #include "vm/os.h"
 #include "vm/utils.h"
 #include "vm/thread.h"
@@ skipping 34 matching lines @@
 
   // Add symbol information for a region (includes the start and end symbol),
   // does not add the actual code.
   void AddCodeRegion(const char* name, uword pc, intptr_t size);
 
   // Add specified symbol information, does not add the actual code.
   int AddFunction(const char* name, uword pc, intptr_t size);
 
   // Write out all the Elf information using the specified handle.
   bool WriteToFile(File* handle);
-  bool WriteToMemory(ByteArray* region);
+  bool WriteToMemory(ByteVector* region);
 
   // Register this generated section with GDB using the JIT interface.
   static void RegisterSectionWithGDB(const char* name,
                                      uword entry_point,
                                      intptr_t size);
 
   // Unregister all generated section from GDB.
   static void UnregisterAllSectionsWithGDB();
 
  private:
   // ELF helpers
-  typedef int (*OutputWriter)(void* handle, const ByteArray& section);
+  typedef int (*OutputWriter)(void* handle, const ByteVector& section);
   typedef void (*OutputPadder)(void* handle, int padding_size);
 
-  int AddString(ByteArray* buf, const char* str);
+  int AddString(ByteVector* buf, const char* str);
   int AddSectionName(const char* str);
   int AddName(const char* str);
   void AddELFHeader(int shoff);
   void AddSectionHeader(int section, int offset);
-  int PadSection(ByteArray* section, int offset, int alignment);
+  int PadSection(ByteVector* section, int offset, int alignment);
   bool WriteOutput(void* handle, OutputWriter writer, OutputPadder padder);
 
   uword text_vma_;  // text section vma
   intptr_t text_size_;  // text section size
   int text_padding_;  // padding preceding text section
 
   static const int kNumSections = 5;  // we generate 5 sections
   int section_name_[kNumSections];  // array of section name indices
-  ByteArray section_buf_[kNumSections];  // array of section buffers
-  ByteArray header_;  // ELF header buffer
-  ByteArray sheaders_;  // section header table buffer
-  ByteArray lineprog_;  // line statement program, part of '.debug_line' section
+  ByteVector section_buf_[kNumSections];  // array of section buffers
+  ByteVector header_;  // ELF header buffer
+  ByteVector sheaders_;  // section header table buffer
+  ByteVector lineprog_;  // line statement program, part of .debug_line section
 
   // current state of the DWARF line info generator
   uintptr_t cur_addr_;  // current pc
   int map_offset_;
   uword map_begin_;
   uword map_end_;
 
   Mutex lock_;
 };
 
@@ skipping 74 matching lines @@
 
 
 // Convenience function aligning an integer.
 static inline uintptr_t Align(uintptr_t x, intptr_t size) {
   // size is a power of 2
   ASSERT((size & (size-1)) == 0);
   return (x + (size-1)) & ~(size-1);
 }
 
 
-// Convenience function writing a single byte to a ByteArray.
-static inline void WriteByte(ByteArray* buf, uint8_t byte) {
+// Convenience function writing a single byte to a ByteVector.
+static inline void WriteByte(ByteVector* buf, uint8_t byte) {
   buf->Add(byte);
 }
 
 
-// Convenience function writing an unsigned native word to a ByteArray.
+// Convenience function writing an unsigned native word to a ByteVector.
 // The word is 32-bit wide in 32-bit mode and 64-bit wide in 64-bit mode.
-static inline void WriteWord(ByteArray* buf, uword word) {
+static inline void WriteWord(ByteVector* buf, uword word) {
   uint8_t* p = reinterpret_cast<uint8_t*>(&word);
   for (size_t i = 0; i < sizeof(word); i++) {
     buf->Add(p[i]);
   }
 }
 
-static inline void WriteInt(ByteArray* buf, int word) {
+static inline void WriteInt(ByteVector* buf, int word) {
   uint8_t* p = reinterpret_cast<uint8_t*>(&word);
   for (size_t i = 0; i < sizeof(word); i++) {
     buf->Add(p[i]);
   }
 }
 
-static inline void WriteShort(ByteArray* buf, uint16_t word) {
+static inline void WriteShort(ByteVector* buf, uint16_t word) {
   uint8_t* p = reinterpret_cast<uint8_t*>(&word);
   for (size_t i = 0; i < sizeof(word); i++) {
     buf->Add(p[i]);
   }
 }
 
-static inline void WriteString(ByteArray* buf, const char* str) {
+static inline void WriteString(ByteVector* buf, const char* str) {
   for (size_t i = 0; i < strlen(str); i++) {
     buf->Add(static_cast<uint8_t>(str[i]));
   }
 }
 
-static inline void Write(ByteArray* buf, const void* mem, int length) {
+static inline void Write(ByteVector* buf, const void* mem, int length) {
   const uint8_t* p = reinterpret_cast<const uint8_t*>(mem);
   for (int i = 0; i < length; i++) {
     buf->Add(p[i]);
   }
 }
 
 
 // Write given section to file and return written size.
-static int WriteSectionToFile(void* handle, const ByteArray& section) {
+static int WriteSectionToFile(void* handle, const ByteVector& section) {
 #if 0
   File* fp = reinterpret_cast<File*>(handle);
   int size = section.size();
   fp->WriteFully(section.data(), size);
   return size;
 #else
   return 0;
 #endif
 }
 
 
 // Pad output file to specified padding size.
 static void PadFile(void* handle, int padding_size) {
 #if 0
   File* fp = reinterpret_cast<File*>(handle);
   for (int i = 0; i < padding_size; i++) {
     fp->WriteFully("", 1);
   }
 #endif
 }
 
 
 // Write given section to specified memory region and return written size.
-static int WriteSectionToMemory(void* handle, const ByteArray& section) {
-  ByteArray* buffer = reinterpret_cast<ByteArray*>(handle);
+static int WriteSectionToMemory(void* handle, const ByteVector& section) {
+  ByteVector* buffer = reinterpret_cast<ByteVector*>(handle);
   int size = section.size();
   for (int i = 0; i < size; i++) {
     buffer->Add(static_cast<uint8_t>(section.data()[i]));
   }
   return size;
 }
 
 
 // Pad memory to specified padding size.
 static void PadMemory(void* handle, int padding_size) {
-  ByteArray* buffer = reinterpret_cast<ByteArray*>(handle);
+  ByteVector* buffer = reinterpret_cast<ByteVector*>(handle);
   for (int i = 0; i < padding_size; i++) {
     buffer->Add(static_cast<uint8_t>(0));
   }
 }
 
 
 // Constructor
 ElfGen::ElfGen()
     : text_vma_(0), text_size_(0), text_padding_(0), map_offset_(0), lock_() {
   for (int i = 0; i < kNumSections; i++) {
     ASSERT(section_attr[i].shndx == i);  // Verify layout of sections.
     section_name_[i] = AddSectionName(section_attr[i].name);
   }
   // Section header string table always starts with an empty string, which is
   // the name of the kUndef section.
   ASSERT((section_attr[0].name[0] == '\0') && (section_name_[0] == 0));
 
   // String table always starts with an empty string.
   AddName("");
   ASSERT(section_buf_[kStrtab].size() == 1);
 
   // Symbol at index 0 in symtab is always STN_UNDEF (all zero):
-  ByteArray* symtab = &section_buf_[kSymtab];
+  ByteVector* symtab = &section_buf_[kSymtab];
   while (symtab->size() < kSymbolSize) {
     WriteInt(symtab, 0);
   }
   ASSERT(symtab->size() == kSymbolSize);
 }
 
 
 // Destructor
 ElfGen::~ElfGen() {
 }
@@ skipping 24 matching lines @@
   MutexLocker ml(&lock_);
   AddFunction(name, pc, size);
   char end_name[256];
   OS::SNPrint(end_name, sizeof(end_name), "%s_end", name);
   AddFunction(end_name, pc + size, 0);
 }
 
 
 int ElfGen::AddFunction(const char* name, uword pc, intptr_t size) {
   ASSERT(text_vma_ != 0);  // code must have been added
-  ByteArray* symtab = &section_buf_[kSymtab];
+  ByteVector* symtab = &section_buf_[kSymtab];
   const int beg = symtab->size();
   WriteInt(symtab, AddName(name));  // st_name
 #if defined(TARGET_ARCH_X64)
   WriteShort(symtab, (kSTB_LOCAL << 4) + kSTT_FUNC);  // st_info + (st_other<<8)
   WriteShort(symtab, kText);  // st_shndx
 #endif
   WriteWord(symtab, pc);  // st_value
   WriteWord(symtab, size);  // st_size
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
   // st_info + (st_other<<8)
   WriteShort(symtab, (kSTB_EXPORTED << 4) + kSTT_FUNC);
   WriteShort(symtab, kText);  // st_shndx
 #endif
   ASSERT(symtab->size() - beg == kSymbolSize);
   return beg / kSymbolSize;  // symbol index in symtab
 }
 
 
 bool ElfGen::WriteToFile(File* handle) {
   return WriteOutput(handle, WriteSectionToFile, PadFile);
 }
 
 
-bool ElfGen::WriteToMemory(ByteArray* region) {
+bool ElfGen::WriteToMemory(ByteVector* region) {
   return WriteOutput(region, WriteSectionToMemory, PadMemory);
 }
 
 
-int ElfGen::AddString(ByteArray* buf, const char* str) {
+int ElfGen::AddString(ByteVector* buf, const char* str) {
   const int str_index = buf->size();
   WriteString(buf, str);
   WriteByte(buf, 0);  // terminating '\0'
   return str_index;
 }
 
 
 int ElfGen::AddSectionName(const char* str) {
   return AddString(&section_buf_[kShStrtab], str);
 }
@@ skipping 53 matching lines @@
   WriteInt(&sheaders_, 0);
   WriteWord(&sheaders_, section_attr[section].sh_addralign);
   WriteWord(&sheaders_, section_attr[section].sh_entsize);
   ASSERT(sheaders_.size() == kSectionHeaderEntrySize * (section + 1));
 }
 
 
 // Pads the given section with zero bytes for the given aligment, assuming the
 // section starts at given file offset; returns file offset after padded
 // section.
-int ElfGen::PadSection(ByteArray* section, int offset, int alignment) {
+int ElfGen::PadSection(ByteVector* section, int offset, int alignment) {
   offset += section->size();
   int aligned_offset = Align(offset, alignment);
   while (offset++ < aligned_offset) {
     WriteByte(section, 0);  // one byte padding.
   }
   return aligned_offset;
 }
 
 
 bool ElfGen::WriteOutput(void* handle,
@@ skipping 59 matching lines @@
   elf_gen->AddCode(pc, size);
 }
 
 
 void DebugInfo::AddCodeRegion(const char* name, uword pc, intptr_t size) {
   ElfGen* elf_gen = reinterpret_cast<ElfGen*>(handle_);
   elf_gen->AddCodeRegion(name, pc, size);
 }
 
 
-bool DebugInfo::WriteToMemory(ByteArray* region) {
+bool DebugInfo::WriteToMemory(ByteVector* region) {
   ElfGen* elf_gen = reinterpret_cast<ElfGen*>(handle_);
   return elf_gen->WriteToMemory(region);
 }
 
 
 DebugInfo* DebugInfo::NewGenerator() {
   return new DebugInfo();
 }
 
 
 void DebugInfo::RegisterSection(const char* name,
                                 uword entry_point,
                                 intptr_t size) {
   ElfGen* elf_section = new ElfGen();
   ASSERT(elf_section != NULL);
   elf_section->AddCode(entry_point, size);
   elf_section->AddCodeRegion(name, entry_point, size);
 
-  ByteArray* dynamic_region = new ByteArray();
+  ByteVector* dynamic_region = new ByteVector();
   ASSERT(dynamic_region != NULL);
 
   elf_section->WriteToMemory(dynamic_region);
 
   ::addDynamicSection(reinterpret_cast<const char*>(dynamic_region->data()),
                       dynamic_region->size());
   dynamic_region->set_data(NULL);
   delete dynamic_region;
   delete elf_section;
 }
 
 
 void DebugInfo::UnregisterAllSections() {
   ::deleteDynamicSections();
 }
 
 }  // namespace dart