Patch for the Merge conflict of xcoff first merge with llvm

Lakshmi-Surekha · Lakshmi-Surekha · commit 7609ad339bfa · 2024-11-14T13:23:59.000-06:00
diff --git a/lldb/source/Plugins/ObjectFile/XCOFF/ObjectFileXCOFF.cpp b/lldb/source/Plugins/ObjectFile/XCOFF/ObjectFileXCOFF.cpp
@@ -188,7 +188,258 @@ bool ObjectFileXCOFF::ParseHeader() {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     m_sect_headers.clear();
-    lldb::offs
+    lldb::offset_t offset = 0;
+
+    if (ParseXCOFFHeader(m_data, &offset, m_xcoff_header)) {
+      m_data.SetAddressByteSize(GetAddressByteSize());
+      if (m_xcoff_header.auxhdrsize > 0)
+        ParseXCOFFOptionalHeader(m_data, &offset);
+      ParseSectionHeaders(offset);
+    }
+    return true;
+  }
+
+  return false;
+}
+
+bool ObjectFileXCOFF::ParseXCOFFHeader(lldb_private::DataExtractor &data,
+                                       lldb::offset_t *offset_ptr,
+                                       xcoff_header_t &xcoff_header) {
+  //FIXME: data.ValidOffsetForDataOfSize
+  xcoff_header.magic = data.GetU16(offset_ptr);
+  xcoff_header.nsects = data.GetU16(offset_ptr);
+  xcoff_header.modtime = data.GetU32(offset_ptr);
+  xcoff_header.symoff = data.GetU64(offset_ptr);
+  xcoff_header.auxhdrsize = data.GetU16(offset_ptr);
+  xcoff_header.flags = data.GetU16(offset_ptr);
+  xcoff_header.nsyms = data.GetU32(offset_ptr);
+  return true;
+}
+
+bool ObjectFileXCOFF::ParseXCOFFOptionalHeader(lldb_private::DataExtractor &data,
+                                               lldb::offset_t *offset_ptr) {
+  lldb::offset_t init_offset = *offset_ptr;
+  //FIXME: data.ValidOffsetForDataOfSize
+  m_xcoff_aux_header.AuxMagic = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.Version = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.ReservedForDebugger = data.GetU32(offset_ptr);
+  m_xcoff_aux_header.TextStartAddr = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.DataStartAddr = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.TOCAnchorAddr = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.SecNumOfEntryPoint = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.SecNumOfText = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.SecNumOfData = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.SecNumOfTOC = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.SecNumOfLoader = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.SecNumOfBSS = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.MaxAlignOfText = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.MaxAlignOfData = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.ModuleType = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.CpuFlag = data.GetU8(offset_ptr);
+  m_xcoff_aux_header.CpuType = data.GetU8(offset_ptr);
+  m_xcoff_aux_header.TextPageSize = data.GetU8(offset_ptr);
+  m_xcoff_aux_header.DataPageSize = data.GetU8(offset_ptr);
+  m_xcoff_aux_header.StackPageSize = data.GetU8(offset_ptr);
+  m_xcoff_aux_header.FlagAndTDataAlignment = data.GetU8(offset_ptr);
+  m_xcoff_aux_header.TextSize = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.InitDataSize = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.BssDataSize = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.EntryPointAddr = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.MaxStackSize = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.MaxDataSize = data.GetU64(offset_ptr);
+  m_xcoff_aux_header.SecNumOfTData = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.SecNumOfTBSS = data.GetU16(offset_ptr);
+  m_xcoff_aux_header.XCOFF64Flag = data.GetU16(offset_ptr);
+  lldb::offset_t last_offset = *offset_ptr;
+  if ((last_offset - init_offset) < m_xcoff_header.auxhdrsize)
+    *offset_ptr += (m_xcoff_header.auxhdrsize - (last_offset - init_offset));
+  return true;
+}
+
+bool ObjectFileXCOFF::ParseSectionHeaders(
+    uint32_t section_header_data_offset) {
+  const uint32_t nsects = m_xcoff_header.nsects;
+  m_sect_headers.clear();
+
+  if (nsects > 0) {
+    const size_t section_header_byte_size = nsects * m_binary->getSectionHeaderSize();
+    lldb_private::DataExtractor section_header_data =
+        ReadImageData(section_header_data_offset, section_header_byte_size);
+
+    lldb::offset_t offset = 0;
+    //FIXME: section_header_data.ValidOffsetForDataOfSize
+    m_sect_headers.resize(nsects);
+
+    for (uint32_t idx = 0; idx < nsects; ++idx) {
+      const void *name_data = section_header_data.GetData(&offset, 8);
+      if (name_data) {
+        memcpy(m_sect_headers[idx].name, name_data, 8);
+        m_sect_headers[idx].phyaddr = section_header_data.GetU64(&offset);
+        m_sect_headers[idx].vmaddr = section_header_data.GetU64(&offset);
+        m_sect_headers[idx].size = section_header_data.GetU64(&offset);
+        m_sect_headers[idx].offset = section_header_data.GetU64(&offset);
+        m_sect_headers[idx].reloff = section_header_data.GetU64(&offset);
+        m_sect_headers[idx].lineoff = section_header_data.GetU64(&offset);
+        m_sect_headers[idx].nreloc = section_header_data.GetU32(&offset);
+        m_sect_headers[idx].nline = section_header_data.GetU32(&offset);
+        m_sect_headers[idx].flags = section_header_data.GetU32(&offset);
+        offset += 4;
+      } else {
+        offset += (m_binary->getSectionHeaderSize() - 8);
+      }
+    }
+  }
+
+  return !m_sect_headers.empty();
+}
+
+lldb_private::DataExtractor ObjectFileXCOFF::ReadImageData(uint32_t offset, size_t size) {
+  if (!size)
+    return {};
+
+  if (m_data.ValidOffsetForDataOfSize(offset, size))
+    return lldb_private::DataExtractor(m_data, offset, size);
+
+  assert(0);
+  ProcessSP process_sp(m_process_wp.lock());
+  lldb_private::DataExtractor data;
+  if (process_sp) {
+    auto data_up = std::make_unique<DataBufferHeap>(size, 0);
+    Status readmem_error;
+    size_t bytes_read =
+        process_sp->ReadMemory(offset, data_up->GetBytes(),
+                               data_up->GetByteSize(), readmem_error);
+    if (bytes_read == size) {
+      DataBufferSP buffer_sp(data_up.release());
+      data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
+    }
+  }
+  return data;
+}
+
+bool ObjectFileXCOFF::SetLoadAddress(Target &target, lldb::addr_t value,
+                                   bool value_is_offset) {
+  bool changed = false;
+  ModuleSP module_sp = GetModule();
+  if (module_sp) {
+    size_t num_loaded_sections = 0;
+    SectionList *section_list = GetSectionList();
+    if (section_list) {
+      const size_t num_sections = section_list->GetSize();
+      size_t sect_idx = 0;
+
+      for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
+        // Iterate through the object file sections to find all of the sections
+        // that have SHF_ALLOC in their flag bits.
+        SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
+        if (section_sp && !section_sp->IsThreadSpecific()) {
+          bool use_offset = false;
+          if (strcmp(section_sp->GetName().AsCString(), ".text") == 0 ||
+              strcmp(section_sp->GetName().AsCString(), ".data") == 0 ||
+              strcmp(section_sp->GetName().AsCString(), ".bss") == 0)
+            use_offset = true;
+
+          if (target.GetSectionLoadList().SetSectionLoadAddress(
+                  section_sp, (use_offset ?
+                  (section_sp->GetFileOffset() + value) : (section_sp->GetFileAddress() + value))))
+            ++num_loaded_sections;
+        }
+      }
+      changed = num_loaded_sections > 0;
+    }
+  }
+  return changed;
+}
+
+bool ObjectFileXCOFF::SetLoadAddressByType(Target &target, lldb::addr_t value,
+                                   bool value_is_offset, int type_id) {
+  bool changed = false;
+  ModuleSP module_sp = GetModule();
+  if (module_sp) {
+    size_t num_loaded_sections = 0;
+    SectionList *section_list = GetSectionList();
+    if (section_list) {
+      const size_t num_sections = section_list->GetSize();
+      size_t sect_idx = 0;
+
+      for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
+        // Iterate through the object file sections to find all of the sections
+        // that have SHF_ALLOC in their flag bits.
+        SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
+        if (type_id == 1 && section_sp && strcmp(section_sp->GetName().AsCString(), ".text") == 0) {
+          if (!section_sp->IsThreadSpecific()) {
+            if (target.GetSectionLoadList().SetSectionLoadAddress(
+                    section_sp, section_sp->GetFileOffset() + value))
+              ++num_loaded_sections;
+          }
+        } else if (type_id == 2 && section_sp && strcmp(section_sp->GetName().AsCString(), ".data") == 0) {
+          if (!section_sp->IsThreadSpecific()) {
+            if (target.GetSectionLoadList().SetSectionLoadAddress(
+                    section_sp, section_sp->GetFileAddress() + value))
+              ++num_loaded_sections;
+          }
+        }
+      }
+      changed = num_loaded_sections > 0;
+    }
+  }
+  return changed;
+}
+
+ByteOrder ObjectFileXCOFF::GetByteOrder() const {
+  return eByteOrderBig;
+}
+
+bool ObjectFileXCOFF::IsExecutable() const {
+  return true;
+}
+
+uint32_t ObjectFileXCOFF::GetAddressByteSize() const {
+  if (m_xcoff_header.magic == XCOFF::XCOFF64)
+    return 8;
+  else if (m_xcoff_header.magic == XCOFF::XCOFF32)
+    return 4;
+  return 4;
+}
+
+AddressClass ObjectFileXCOFF::GetAddressClass(addr_t file_addr) {
+  return AddressClass::eUnknown;
+}
+
+lldb::SymbolType ObjectFileXCOFF::MapSymbolType(llvm::object::SymbolRef::Type sym_type) {
+  if (sym_type == llvm::object::SymbolRef::ST_Function)
+    return lldb::eSymbolTypeCode;
+  else if (sym_type == llvm::object::SymbolRef::ST_Data)
+    return lldb::eSymbolTypeData;
+  return lldb::eSymbolTypeInvalid;
+}
+
+void ObjectFileXCOFF::ParseSymtab(Symtab &lldb_symtab) {
+  SectionList *sect_list = GetSectionList();
+  const uint32_t num_syms = m_xcoff_header.nsyms;
+  uint32_t sidx = 0;
+  if (num_syms > 0 && m_xcoff_header.symoff > 0) {
+    const uint32_t symbol_size = XCOFF::SymbolTableEntrySize;
+    const size_t symbol_data_size = num_syms * symbol_size;
+    lldb_private::DataExtractor symtab_data =
+        ReadImageData(m_xcoff_header.symoff, symbol_data_size);
+
+    lldb::offset_t offset = 0;
+    std::string symbol_name;
+    Symbol *symbols = lldb_symtab.Resize(num_syms);
+    llvm::object::symbol_iterator SI = m_binary->symbol_begin();
+    for (uint32_t i = 0; i < num_syms; ++i, ++SI) {
+      xcoff_symbol_t symbol;
+      const uint32_t symbol_offset = offset;
+      symbol.value = symtab_data.GetU64(&offset);
+      symbol.offset = symtab_data.GetU32(&offset);
+      Expected<StringRef> symbol_name_or_err = m_binary->getStringTableEntry(symbol.offset);
+      if (!symbol_name_or_err) {
+        consumeError(symbol_name_or_err.takeError());
+        return;
+      }
+      StringRef symbol_name_str = symbol_name_or_err.get();
+      symbol_name.assign(symbol_name_str.data());
       symbol.sect = symtab_data.GetU16(&offset);
       symbol.type = symtab_data.GetU16(&offset);
       symbol.storage = symtab_data.GetU8(&offset);
