Attach pre work

Author: HemangGadhavi

lldb/include/lldb/Core/ModuleSpec.h

@@ -16,7 +16,8 @@
 #include "lldb/Utility/Iterable.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/UUID.h"
-
+#include "lldb/Utility/LLDBLog.h"                                               
+#include "lldb/Utility/Log.h" 
 #include "llvm/Support/Chrono.h"
 
 #include <mutex>
@@ -47,6 +48,7 @@ class ModuleSpec {
     llvm::SmallString<256> path_with_object;
     file_spec.GetPath(path_with_object);
     if (strstr(path_with_object.c_str(), "(") != nullptr) {
+        LLDB_LOGF(GetLog(LLDBLog::Object), "ModuleSpec : %d %s",__LINE__,path_with_object.c_str());
       char *part;
       char *str = (char *)path_with_object.c_str();
       part = strtok(str, "()");
@@ -57,7 +59,10 @@ class ModuleSpec {
       m_object_name = ConstString(part);
       m_file = FileSpec(file_name);
       m_object_size = FileSystem::Instance().GetByteSize(m_file);
+        LLDB_LOGF(GetLog(LLDBLog::Object), "ModuleSpec file & obj : %d %s %s",__LINE__,file_spec.GetFilename().AsCString(),m_object_name.AsCString());
+        LLDB_LOGF(GetLog(LLDBLog::Object), "ModuleSpec FULL path : %d %s ",__LINE__,file_spec.GetPath().c_str());
     } else {
+        LLDB_LOGF(GetLog(LLDBLog::Object), "ModuleSpec : %d %s",__LINE__,file_spec.GetFilename().AsCString());
       m_file = file_spec;
       m_object_size = FileSystem::Instance().GetByteSize(file_spec);
     }

lldb/source/Core/Module.cpp

@@ -1535,31 +1535,40 @@ bool Module::SetLoadAddressByType(Target &target, lldb::addr_t value,
 bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
   const UUID &uuid = module_ref.GetUUID();
 
+Log *log(GetLog(LLDBLog::Object | LLDBLog::Modules)); 
   if (uuid.IsValid()) {
     // If the UUID matches, then nothing more needs to match...
     return (uuid == GetUUID());
   }
-
+LLDB_LOGF(log,"MatchesModuleSpec %d",__LINE__);
   const FileSpec &file_spec = module_ref.GetFileSpec();
   if (!FileSpec::Match(file_spec, m_file) &&
       !FileSpec::Match(file_spec, m_platform_file))
     return false;
 
+LLDB_LOGF(log,"MatchesModuleSpec %d",__LINE__);
   const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
   if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec()))
     return false;
 
+LLDB_LOGF(log,"MatchesModuleSpec %d",__LINE__);
   const ArchSpec &arch = module_ref.GetArchitecture();
   if (arch.IsValid()) {
     if (!m_arch.IsCompatibleMatch(arch))
       return false;
   }
-
+  
+LLDB_LOGF(log,"MatchesModuleSpec %d",__LINE__);
   ConstString object_name = module_ref.GetObjectName();
+    LLDB_LOGF(log,"MatchesModuleSpec object_name %s",GetObjectName().AsCString());
+    LLDB_LOGF(log,"MatchesModuleSpec module_ref %s", module_ref.GetObjectName().AsCString());
+    LLDB_LOGF(log,"MatchesModuleSpec O Get des: %d",GetObjectOffset());
+    LLDB_LOGF(log,"MatchesModuleSpec m Get des: %d", module_ref.GetObjectOffset());
   if (object_name) {
     if (object_name != GetObjectName())
       return false;
   }
+    LLDB_LOGF(log,"MatchesModuleSpec return true ");
   return true;
 }
 

lldb/source/Core/ModuleList.cpp

@@ -251,19 +251,42 @@ void ModuleList::Append(const ModuleSP &module_sp, bool notify) {
 void ModuleList::ReplaceEquivalent(
     const ModuleSP &module_sp,
     llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules) {
+Log *log(GetLog(LLDBLog::Object | LLDBLog::Modules));
+    LLDB_LOGF(log,"ReplaceEquivalent module_sp %s",module_sp->GetObjectName().AsCString());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 
+    //llvm::SmallString<256> path_with_object;
+
+    LLDB_LOGF(log," Before ReplaceEquivalent module_sp dis %s",module_sp->GetFileSpec().GetPath().c_str());
+   
+    llvm::SmallString<128> path;  
+    module_sp->GetFileSpec().GetPath(path);
+    llvm::SmallString<128> obj_name ;
+    obj_name = module_sp->GetObjectName().AsCString();
+
+    llvm::SmallString<256> full_path;
+    full_path = llvm::Twine(path + llvm::Twine("(") + llvm::Twine(obj_name) + llvm::Twine(")")).str();
+    //std::string full_path = module_sp->GetFileSpec().GetPath().c_str() + "("
+    //    +  module_sp->GetObjectName().AsCString() + ")";
+
+    //module_sp->GetFileSpec().SetPath(full_path);
+
+
+    LLDB_LOGF(log,"After ReplaceEquivalent module_sp dis %s",module_sp->GetFileSpec().GetPath().c_str());
     // First remove any equivalent modules. Equivalent modules are modules
     // whose path, platform path and architecture match.
     ModuleSpec equivalent_module_spec(module_sp->GetFileSpec(),
                                       module_sp->GetArchitecture());
+        LLDB_LOGF(log,"ReplaceEquivalent equivalent.module_sp %s",equivalent_module_spec.GetObjectName().AsCString());
     equivalent_module_spec.GetPlatformFileSpec() =
         module_sp->GetPlatformFileSpec();
 
     size_t idx = 0;
     while (idx < m_modules.size()) {
+        LLDB_LOGF(log,"ReplaceEquivalent index : %d",idx);
       ModuleSP test_module_sp(m_modules[idx]);
+    LLDB_LOGF(log,"ReplaceEquivalent test_module_sp : %s",test_module_sp->GetObjectName().AsCString());
       if (test_module_sp->MatchesModuleSpec(equivalent_module_spec)) {
         if (old_modules)
           old_modules->push_back(test_module_sp);
@@ -795,6 +818,7 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
       shared_module_list.m_modules_mutex);
   char path[PATH_MAX];
 
+          Log *log = GetLog(LLDBLog::Modules);
   Status error;
 
   module_sp.reset();
@@ -810,21 +834,22 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
   // function is actively working on it by doing an extra lock on the global
   // mutex list.
   if (!always_create) {
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
     ModuleList matching_module_list;
     shared_module_list.FindModules(module_spec, matching_module_list);
     const size_t num_matching_modules = matching_module_list.GetSize();
 
+      LLDB_LOGF(log,"GetSharedModule %d %d",__LINE__,num_matching_modules);
     if (num_matching_modules > 0) {
       for (size_t module_idx = 0; module_idx < num_matching_modules;
            ++module_idx) {
         module_sp = matching_module_list.GetModuleAtIndex(module_idx);
 
         // Make sure the file for the module hasn't been modified
         if (module_sp->FileHasChanged()) {
-          if (old_modules)
+          if (old_modules) 
             old_modules->push_back(module_sp);
-
-          Log *log = GetLog(LLDBLog::Modules);
+          
           if (log != nullptr)
             LLDB_LOGF(
                 log, "%p '%s' module changed: removing from global module list",
@@ -850,9 +875,11 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
   // valid file path with an architecture that might not be in that file. By
   // getting the object file we can guarantee that the architecture matches
   if (module_sp->GetObjectFile()) {
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
     // If we get in here we got the correct arch, now we just need to verify
     // the UUID if one was given
     if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
       module_sp.reset();
     } else {
       if (module_sp->GetObjectFile() &&
@@ -863,7 +890,10 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
         if (did_create_ptr) {
           *did_create_ptr = true;
         }
-
+      if(module_sp)
+          LLDB_LOGF(log," module File Name: %s",module_sp->GetFileSpec().GetFilename().AsCString());
+      if(old_modules)
+            LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
         shared_module_list.ReplaceEquivalent(module_sp, old_modules);
         return error;
       }
@@ -901,6 +931,7 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
             if (did_create_ptr)
               *did_create_ptr = true;
 
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
             shared_module_list.ReplaceEquivalent(module_sp, old_modules);
             return Status();
           }
@@ -969,13 +1000,15 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
     if (!matching_module_list.IsEmpty()) {
       module_sp = matching_module_list.GetModuleAtIndex(0);
 
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
       // If we didn't have a UUID in mind when looking for the object file,
       // then we should make sure the modification time hasn't changed!
       if (platform_module_spec.GetUUIDPtr() == nullptr) {
         auto file_spec_mod_time = FileSystem::Instance().GetModificationTime(
             located_binary_modulespec.GetFileSpec());
         if (file_spec_mod_time != llvm::sys::TimePoint<>()) {
           if (file_spec_mod_time != module_sp->GetModificationTime()) {
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
             if (old_modules)
               old_modules->push_back(module_sp);
             shared_module_list.Remove(module_sp);
@@ -986,6 +1019,7 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
     }
 
     if (!module_sp) {
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
       module_sp = std::make_shared<Module>(platform_module_spec);
       // Make sure there are a module and an object file since we can specify a
       // valid file path with an architecture that might not be in that file.
@@ -999,6 +1033,7 @@ ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp,
           if (did_create_ptr)
             *did_create_ptr = true;
 
+      LLDB_LOGF(log,"GetSharedModule %d",__LINE__);
           shared_module_list.ReplaceEquivalent(module_sp, old_modules);
         }
       } else {

lldb/source/Core/Section.cpp

@@ -14,6 +14,8 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/VMRange.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/Log.h"
 
 #include <cinttypes>
 #include <limits>
@@ -259,9 +261,16 @@ bool Section::ResolveContainedAddress(addr_t offset, Address &so_addr,
   }
   so_addr.SetOffset(offset);
   so_addr.SetSection(const_cast<Section *>(this)->shared_from_this());
-
-  // Ensure that there are no orphaned (i.e., moduleless) sections.
-  assert(GetModule().get());
+    Log *log = GetLog(LLDBLog::DynamicLoader);
+    //LLDB_LOGF(log,"Section::ResolveContainedAddress %s",GetModule().GetName());
+  
+    //llvm::Module *module = GetModule();
+    lldb::ModuleSP module = GetModule();
+    //LLDB_LOGF(log,"Section::ResolveContainedAddress %s",module->GetSpecificationDescription().c_str());
+    if(module.get() == NULL)
+        LLDB_LOGF(log,"Section::issue with"); 
+    // Ensure that there are no orphaned (i.e., moduleless) sections.
+  // assert(GetModule().get());
   return true;
 }
 

lldb/source/Plugins/DynamicLoader/AIX-DYLD/DynamicLoaderAIXDYLD.cpp

@@ -26,6 +26,7 @@
 #include <iostream>
 #include <fstream>
 #endif
+#include "/LLDB/hemang/lldb-for-aix/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h"
 
 /*#include "llvm/ADT/Triple.h"
 */
@@ -89,7 +90,10 @@ void DynamicLoaderAIXDYLD::OnLoadModule(lldb::ModuleSP module_sp,
 }
 
 void DynamicLoaderAIXDYLD::OnUnloadModule(lldb::addr_t module_addr) {
-  Address resolved_addr;
+    Log *log = GetLog(LLDBLog::DynamicLoader);                                    
+  LLDB_LOGF(log, "DynamicLoaderAIXDYLD::%s()", __FUNCTION__); 
+
+    Address resolved_addr;
   if (!m_process->GetTarget().ResolveLoadAddress(module_addr, resolved_addr))
     return;
 
@@ -150,7 +154,7 @@ void DynamicLoaderAIXDYLD::ResolveExecutableModule(
   ProcessInstanceInfo process_info;
   if (!m_process->GetProcessInfo(process_info)) {
     LLDB_LOGF(log,
-              "DynamicLoaderPOSIXDYLD::%s - failed to get process info for "
+              "DynamicLoaderAIXDYLD::%s - failed to get process info for "
               "pid %" PRIu64,
               __FUNCTION__, m_process->GetID());
     return;
@@ -201,15 +205,16 @@ void DynamicLoaderAIXDYLD::ResolveExecutableModule(
           true);
 
   LLDB_LOGF(
-      log, "DynamicLoaderPOSIXDYLD::%s - got executable by pid %" PRIu64 ": %s",
+      log, "DynamicLoaderAIXDYLD::%s - got executable by pid %" PRIu64 ": %s",
       __FUNCTION__, m_process->GetID(),
       process_info.GetExecutableFile().GetPath().c_str());
 
   ModuleSpec module_spec(process_info.GetExecutableFile(),
                          process_info.GetArchitecture());
+
   if (module_sp && module_sp->MatchesModuleSpec(module_spec))
     return;
-
+ LLDB_LOGF(log,"DynamicLoaderAIXDYLD::%s",__FUNCTION__);
   const auto executable_search_paths(Target::GetDefaultExecutableSearchPaths());
   auto error = platform_sp->ResolveExecutable(
       module_spec, module_sp,
@@ -222,21 +227,34 @@ void DynamicLoaderAIXDYLD::ResolveExecutableModule(
               "DynamicLoaderPOSIXDYLD::%s - failed to resolve executable "
               "with module spec \"%s\": %s",
               __FUNCTION__, stream.GetData(), error.AsCString());
+    
     return;
   }
 
   target.SetExecutableModule(module_sp, eLoadDependentsNo);
 }
 
 void DynamicLoaderAIXDYLD::DidAttach() {
-  Log *log = GetLog(LLDBLog::DynamicLoader);
+    Log *log = GetLog(LLDBLog::DynamicLoader);
   LLDB_LOGF(log, "DynamicLoaderAIXDYLD::%s()", __FUNCTION__);
 
   ModuleSP executable = GetTargetExecutable();
   ResolveExecutableModule(executable);
 
+  Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
+  if (exe_mod) {
+      exe_mod->GetPlatformFileSpec();
+      LLDB_LOGF(log, "DynamicLoaderAIXDYLD::%s exe module executable path set",
+              __FUNCTION__);
+  } else {
+      LLDB_LOGF(log,
+              "DynamicLoaderAIXDYLD::%s cannot cache exe module path: null "
+              "executable module pointer",
+              __FUNCTION__);
+  }
+
   if (!executable.get())
-    return;
+      return;
   LLDB_LOGF(log, "DynamicLoaderAIXDYLD::%s()", __FUNCTION__);
 
   // Try to fetch the load address of the file from the process, since there
@@ -245,6 +263,7 @@ void DynamicLoaderAIXDYLD::DidAttach() {
   if (load_addr == LLDB_INVALID_ADDRESS)
     return;
 
+  LLDB_LOGF(log,"DidAttach load_addr 0x%p",load_addr);
   // Request the process base address.
   lldb::addr_t image_base = m_process->GetImageInfoAddress();
   if (image_base == load_addr)
@@ -253,13 +272,25 @@ void DynamicLoaderAIXDYLD::DidAttach() {
   // Rebase the process's modules if there is a mismatch.
   UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
 
+/*
+  DYLDRendezvous m_rendezvous(m_process);
+  if (!m_rendezvous.Resolve()) {
+    LLDB_LOGF(log,
+              "DynamicLoaderPOSIXDYLD::%s unable to resolve POSIX DYLD "
+              "rendezvous address",
+              __FUNCTION__);
+    return;
+  } */
+
+
   ModuleList module_list;
   module_list.Append(executable);
   m_process->GetTarget().ModulesDidLoad(module_list);
   auto error = m_process->LoadModules();
   LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
 
 #if defined(_AIX)
+   LLDB_LOGF(log, "DynamicLoaderAIXDYLD::%s() 289", __FUNCTION__);
   // Get struct ld_xinfo (FIXME)
   struct ld_xinfo ldinfo[64];
   Status status = m_process->GetLDXINFO(&(ldinfo[0]));
@@ -281,8 +312,10 @@ void DynamicLoaderAIXDYLD::DidAttach() {
       } else {
         sprintf(pathWithMember, "%s", pathName);
       }
+       LLDB_LOGF(log, "DynamicLoaderAIXDYLD1::%s(), %s", __FUNCTION__,pathWithMember);
       FileSpec file(pathWithMember);
       ModuleSpec module_spec(file, m_process->GetTarget().GetArchitecture());
+      LLDB_LOGF(log,"After dis %s",module_spec.GetFileSpec().GetPath().c_str());
       if (ModuleSP module_sp = m_process->GetTarget().GetOrCreateModule(module_spec, true /* notify */)) {
         UpdateLoadedSectionsByType(module_sp, LLDB_INVALID_ADDRESS, (lldb::addr_t)ptr->ldinfo_textorg, false, 1);
         UpdateLoadedSectionsByType(module_sp, LLDB_INVALID_ADDRESS, (lldb::addr_t)ptr->ldinfo_dataorg, false, 2);
@@ -309,6 +342,7 @@ void DynamicLoaderAIXDYLD::DidLaunch() {
     return;
 
   lldb::addr_t load_addr = GetLoadAddress(executable);
+  LLDB_LOGF(log,"DidLaunch load_addr 0x%p",load_addr);
   if (load_addr != LLDB_INVALID_ADDRESS) {
     // Update the loaded sections so that the breakpoints can be resolved.
     UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);

lldb/source/Plugins/ObjectFile/XCOFF/ObjectFileXCOFF.cpp

@@ -354,15 +354,14 @@ bool ObjectFileXCOFF::SetLoadAddress(Target &target, lldb::addr_t value,
 
 bool ObjectFileXCOFF::SetLoadAddressByType(Target &target, lldb::addr_t value,
                                    bool value_is_offset, int type_id) {
-  bool changed = false;
+    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.