[LLDB] Add API to set section as ignored.

Summary:
This API can be used by custom JIT to set section section as ignored.
For example for code cache.
This will force resolveAddress to use JITLoader.

Test Plan: ninja check-lldb

Rollback Plan:

Reviewers: gclayton, jpporto, #lldb_team

Reviewed By: gclayton

Differential Revision: https://phabricator.intern.facebook.com/D77954663

Tasks: T230278908

Author: Alexander Yermolovich

lldb/include/lldb/API/SBSection.h

@@ -88,6 +88,12 @@ class LLDB_API SBSection {
 
   bool GetDescription(lldb::SBStream &description);
 
+  /// Ignore this section when resolving addresses. Some JIT solutions
+  /// will create a large section in the main binary that will get code JIT'ed
+  /// into. Address lookups need to ignore this section and resolve the
+  /// address in another module that gets loaded.
+  void SetIsIgnored(bool ignore);
+
 private:
   friend class SBAddress;
   friend class SBModule;

lldb/include/lldb/Core/Section.h

@@ -266,6 +266,18 @@ class Section : public std::enable_shared_from_this<Section>,
 
   void SetIsRelocated(bool b) { m_relocated = b; }
 
+  /// Check if this section is ignored for address resolution.
+  /// \return
+  ///     Returns \b true if this section is ignored for address resolution, and
+  ///     falls back to JIT Loader resolution.
+  bool IsIgnored() const { return m_ignore; }
+
+  /// Ignore this section when resolving addresses. Some JIT solutions
+  /// will create a large section in the main binary that will get code JIT'ed
+  /// into. Address lookups need to ignore this section and resolve the
+  /// address in another module that gets loaded.
+  void SetIsIgnored(bool b) { m_ignore = b; }
+
   /// Returns true if this section contains debug information. Symbol tables
   /// are not considered debug information since some symbols might contain
   /// debug information (STABS, COFF) but not all symbols do, so to keep this
@@ -300,7 +312,9 @@ class Section : public std::enable_shared_from_this<Section>,
       m_readable : 1,          // If this section has read permissions
       m_writable : 1,          // If this section has write permissions
       m_executable : 1,        // If this section has executable permissions
-      m_relocated : 1;         // If this section has had relocations applied
+      m_relocated : 1,         // If this section has had relocations applied
+      m_ignore : 1;            // If this section is ignored for address
+                               // resolution.
   uint32_t m_target_byte_size; // Some architectures have non-8-bit byte size.
                                // This is specified as
                                // as a multiple number of a host bytes

lldb/source/API/SBSection.cpp

@@ -261,3 +261,11 @@ bool SBSection::GetDescription(SBStream &description) {
 
   return true;
 }
+
+void SBSection::SetIsIgnored(bool is_gnore_resolution) {
+  LLDB_INSTRUMENT_VA(this);
+
+  SectionSP section_sp(GetSP());
+  if (section_sp.get())
+    section_sp->SetIsIgnored(is_gnore_resolution);
+}

lldb/source/Core/Section.cpp

@@ -170,7 +170,7 @@ Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
       m_file_offset(file_offset), m_file_size(file_size),
       m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
       m_thread_specific(false), m_readable(false), m_writable(false),
-      m_executable(false), m_relocated(false),
+      m_executable(false), m_relocated(false), m_ignore(false),
       m_target_byte_size(target_byte_size) {}
 
 Section::Section(const lldb::SectionSP &parent_section_sp,
@@ -185,7 +185,7 @@ Section::Section(const lldb::SectionSP &parent_section_sp,
       m_file_offset(file_offset), m_file_size(file_size),
       m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
       m_thread_specific(false), m_readable(false), m_writable(false),
-      m_executable(false), m_relocated(false),
+      m_executable(false), m_relocated(false), m_ignore(false),
       m_target_byte_size(target_byte_size) {
   if (parent_section_sp)
     m_parent_wp = parent_section_sp;

lldb/source/Target/SectionLoadList.cpp

@@ -220,6 +220,7 @@ bool SectionLoadList::ResolveLoadAddress(addr_t load_addr, Address &so_addr,
                                          bool allow_section_end) const {
   // First find the top level section that this load address exists in
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  bool result = false;
   if (!m_addr_to_sect.empty()) {
     addr_to_sect_collection::const_iterator pos =
         m_addr_to_sect.lower_bound(load_addr);
@@ -232,8 +233,8 @@ bool SectionLoadList::ResolveLoadAddress(addr_t load_addr, Address &so_addr,
         if (offset < pos->second->GetByteSize() + (allow_section_end ? 1 : 0)) {
           // We have found the top level section, now we need to find the
           // deepest child section.
-          return pos->second->ResolveContainedAddress(offset, so_addr,
-                                                      allow_section_end);
+          result = pos->second->ResolveContainedAddress(offset, so_addr,
+                                                        allow_section_end);
         }
       }
     } else {
@@ -247,12 +248,19 @@ bool SectionLoadList::ResolveLoadAddress(addr_t load_addr, Address &so_addr,
             rpos->second->GetByteSize() + (allow_section_end ? 1 : 0)) {
           // We have found the top level section, now we need to find the
           // deepest child section.
-          return rpos->second->ResolveContainedAddress(offset, so_addr,
-                                                       allow_section_end);
+          result = rpos->second->ResolveContainedAddress(offset, so_addr,
+                                                         allow_section_end);
         }
       }
     }
   }
+
+  if (result) {
+    SectionSP section_sp = so_addr.GetSection();
+    if (section_sp && !section_sp->IsIgnored())
+      return true;
+  }
+
   so_addr.Clear();
   return false;
 }

lldb/source/Target/Target.cpp

@@ -47,6 +47,7 @@
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/JITLoaderList.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/JITLoaderList.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
@@ -3249,8 +3250,14 @@ Status Target::Install(ProcessLaunchInfo *launch_info) {
 
 bool Target::ResolveLoadAddress(addr_t load_addr, Address &so_addr,
                                 uint32_t stop_id, bool allow_section_end) {
-  return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr,
-                                                   allow_section_end);
+  if (m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr,
+                                                allow_section_end))
+    return true;
+
+  ProcessSP process_sp(GetProcessSP());
+  if (!process_sp)
+    return false;
+  return process_sp->GetJITLoaders().ResolveLoadAddress(load_addr, so_addr);
 }
 
 bool Target::ResolveFileAddress(lldb::addr_t file_addr,