[lldb] [POSIX-DYLD] Add libraries from initial rendezvous brkpt hit

[mgorny]

Summary

Explicitly consider the libraries reported on the initial rendezvous
breakpoint hit added. This is necessary on FreeBSD since the dynamic
loader issues only a single 'consistent' state rendezvous breakpoint hit
for all the libraries present in DT_NEEDED. It is also helpful on Linux
where it ensures that ld-linux is considered loaded as well
as the shared system libraries reported afterwards.

Reenable memory maps on FreeBSD since this fixed the issue triggered
by them.

[labath]

What's the state of TestBreakpointInGlobalConstructor.py after this change? Does it continue to fail?

If so, then this is probably a bug in FreeBSD that is worth reporting, as it means that it is not possible to debug the initialization code (global constructors, __attribute__((init)), etc.) of libraries loaded at startup (DT_NEEDED). It might be also worth checking what gdb does in this case. If gdb is able to break in this code, then it means that there is a different way to fetch the loaded libraries early enough, and we could possibly emulate that... (I would very much love that, as the current approach is pretty hacky already)

[mgorny]

In D92187#2422085, @labath wrote:

What's the state of TestBreakpointInGlobalConstructor.py after this change? Does it continue to fail?

Yes, it does.

If so, then this is probably a bug in FreeBSD that is worth reporting, as it means that it is not possible to debug the initialization code (global constructors, __attribute__((init)), etc.) of libraries loaded at startup (DT_NEEDED). It might be also worth checking what gdb does in this case. If gdb is able to break in this code, then it means that there is a different way to fetch the loaded libraries early enough, and we could possibly emulate that... (I would very much love that, as the current approach is pretty hacky already)

I will check that.

[mgorny]

GDB indeed handles it somehow. I'm going to investigate.

[emaste]

I'm curious how gdb handles this, and asked @bsdjhb if he knows off hand.

Is there a brief description of how this works on Linux and/or NetBSD?

[krytarowski]

In D92187#2423018, @emaste wrote:

I'm curious how gdb handles this, and asked @bsdjhb if he knows off hand.

Is there a brief description of how this works on Linux and/or NetBSD?

We are working on researching this, NetBSD, Linux and FreeBSD should behave almost in the same way. At least GNU gdbserver reused the Linux code on NetBSD practically as-is. LLDB does not work with r_debug on NetBSD either.

One thing that FreeBSD should do, is to upgrade to the protocol version 1 (stored in r_version), like Linux, NetBSD and OpenBSD.

[emaste]

Link to Linux info:
https://sourceware.org/gdb/wiki/LinkerInterface

[emaste]

This comment was removed by emaste.

[emaste]

One thing that FreeBSD should do, is to upgrade to the protocol version 1 (stored in r_version), like Linux, NetBSD and OpenBSD.

It looks like Linux has always used r_version=1 (since 1995).

AFAICT we can just add r_ldbase and set version to 1.
See https://reviews.freebsd.org/D27429

[krytarowski]

In D92187#2424109, @emaste wrote:

One thing that FreeBSD should do, is to upgrade to the protocol version 1 (stored in r_version), like Linux, NetBSD and OpenBSD.

It looks like Linux has always used r_version=1 (since 1995).

AFAICT we can just add r_ldbase and set version to 1.
See https://reviews.freebsd.org/D27429

I propose to add #define R_DEBUG_VERSION 1 too, to keep compat with NetBSD (and SunOS?).

[mgorny]

I've added some more debug as requested, and it confirmed that Linux and FreeBSD dyld are behaving differently here.

Linux triggers the breakpoint twice: first time in add state, including only /lib64/ld-linux-x86-64.so.2 and linux-vdso.so.1 in module list, and the second time in consistent state, adding soentries for all shared libraries.

FreeBSD triggers it only once, in consistent state and the remote list includes all libraries immediately.

[mgorny]

Full logs below.

Linux:

(lldb) log enable lldb dyld
(lldb) run
lldb             DynamicLoaderDarwin::UseDYLDSPI: Use old DynamicLoader plugin
lldb             DynamicLoaderDarwin::UseDYLDSPI: Use old DynamicLoader plugin
lldb             DYLDRendezvous::DYLDRendezvous exe module executable path set: '/home/mgorny/git/llvm-project/_build/a.out'
lldb             DynamicLoaderPOSIXDYLD::DidLaunch()
lldb             DynamicLoaderPOSIXDYLD::DidLaunch about to call ProbeEntry()
lldb             Rendezvous structure is not set up yet. Trying to locate rendezvous breakpoint in the interpreter by symbol name.
lldb             Successfully set rendezvous breakpoint at address 0x7ffff7fe1850 for pid 221689
intern-state     DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit called for pid 221689
intern-state     DYLDRendezvous::Resolve address size: 8, padding 4
intern-state     ResolveRendezvousAddress info_location = 0xffffffffffffffff
intern-state     ResolveRendezvousAddress resolved via direct object file approach to 0x403ee8
intern-state     ResolveRendezvousAddress reading pointer (8 bytes) from 0x403ee8
intern-state     DYLDRendezvous::Resolve cursor = 0x7ffff7ffe0a0
intern-state     DYLDRendezvous:
intern-state        Address: 7ffff7ffe0a0
intern-state        Version: 1
intern-state        Link   : 7ffff7ffe1a0
intern-state        Break  : 7ffff7fe1850
intern-state        LDBase : 7ffff7fd1000
intern-state        State  : add
intern-state     DYLDRendezvous::UpdateSOEntriesFromRemote action = 1

intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=7ffff7ffda08, base_addr=7ffff7fd1000, dyn_addr=7ffff7ffce28, filename=/lib64/ld-linux-x86-64.so.2
intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=7ffff7ffe750, base_addr=7ffff7fcf000, dyn_addr=7ffff7fcf3a0, filename=linux-vdso.so.1
intern-state     DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit pid 221689 stop_when_images_change=false
intern-state     DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit called for pid 221689
intern-state     DYLDRendezvous::Resolve address size: 8, padding 4
intern-state     DYLDRendezvous::Resolve cursor = 0x7ffff7ffe0a0
intern-state     DYLDRendezvous:
intern-state        Address: 7ffff7ffe0a0
intern-state        Version: 1
intern-state        Link   : 7ffff7ffe1a0
intern-state        Break  : 7ffff7fe1850
intern-state        LDBase : 7ffff7fd1000
intern-state        State  : consistent
intern-state     DYLDRendezvous SOEntries:
intern-state     
   SOEntry [1] /lib64/ld-linux-x86-64.so.2
intern-state           Base : 7ffff7fd1000
intern-state           Path : 0
intern-state           Dyn  : 7ffff7ffce28
intern-state           Next : 0
intern-state           Prev : 0
intern-state     
   SOEntry [2] linux-vdso.so.1
intern-state           Base : 7ffff7fcf000
intern-state           Path : 0
intern-state           Dyn  : 7ffff7fcf3a0
intern-state           Next : 0
intern-state           Prev : 0
intern-state     DYLDRendezvous::UpdateSOEntriesFromRemote action = 2

intern-state     DYLDRendezvous::AddSOEntriesFromRemote add soentry: link_addr=7ffff7f8c000, base_addr=7ffff7f4f000, dyn_addr=7ffff7f86cb0, filename=/lib64/libedit.so.0
intern-state     DYLDRendezvous::AddSOEntriesFromRemote add soentry: link_addr=7ffff7f8c4f0, base_addr=7ffff7d88000, dyn_addr=7ffff7f48b60, filename=/lib64/libc.so.6
intern-state     DYLDRendezvous::AddSOEntriesFromRemote add soentry: link_addr=7ffff7f8c9e0, base_addr=7ffff7d4c000, dyn_addr=7ffff7d85cc8, filename=/lib64/libtinfo.so.6
intern-state     DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit pid 221689 stop_when_images_change=false
Hello, world!
Process 221689 exited with status = 0 (0x00000000) 

Process 221689 launched: '/home/mgorny/git/llvm-project/_build/a.out' (x86_64)

FreeBSD:

(lldb) run
lldb             DynamicLoaderDarwin::UseDYLDSPI: Use old DynamicLoader plugin
lldb             DynamicLoaderDarwin::UseDYLDSPI: Use old DynamicLoader plugin
lldb             DYLDRendezvous::DYLDRendezvous exe module executable path set: '/home/mgorny/llvm-project/_build/a.out'
lldb             DynamicLoaderPOSIXDYLD::DidLaunch()
lldb             DynamicLoaderPOSIXDYLD::DidLaunch about to call ProbeEntry()
lldb             Rendezvous structure is not set up yet. Trying to locate rendezvous breakpoint in the interpreter by symbol name.
lldb             Successfully set rendezvous breakpoint at address 0x80020fe20 for pid 3770
intern-state     DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit called for pid 3770
intern-state     DYLDRendezvous::Resolve address size: 8, padding 4
intern-state     ResolveRendezvousAddress info_location = 0xffffffffffffffff
intern-state     ResolveRendezvousAddress resolved via direct object file approach to 0x202a50
intern-state     ResolveRendezvousAddress reading pointer (8 bytes) from 0x202a50
intern-state     DYLDRendezvous::Resolve cursor = 0x800229900
intern-state     DYLDRendezvous:
intern-state        Address: 800229900
intern-state        Version: 0
intern-state        Link   : 80022e240
intern-state        Break  : 80020fe20
intern-state        LDBase : 3
intern-state        State  : consistent
intern-state     DYLDRendezvous::UpdateSOEntriesFromRemote action = 1

intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=80022e240, base_addr=200000, dyn_addr=202a28, filename=/home/mgorny/llvm-project/_build/a.out
intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=80022e640, base_addr=80024c000, dyn_addr=8002815c0, filename=/lib/libedit.so.7
intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=80022ea40, base_addr=800287000, dyn_addr=80044f058, filename=/lib/libc.so.7
intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=80022ee40, base_addr=80067d000, dyn_addr=8006db830, filename=/lib/libncursesw.so.8
intern-state     DYLDRendezvous::SaveSOEntriesFromRemote soentry from module list: link_addr=800229580, base_addr=800203000, dyn_addr=800227af0, filename=/libexec/ld-elf.so.1
intern-state     DynamicLoaderPOSIXDYLD::RendezvousBreakpointHit pid 3770 stop_when_images_change=false
Hello world
Process 3770 exited with status = 0 (0x00000000) 

Process 3770 launched: '/home/mgorny/llvm-project/_build/a.out' (x86_64)

(the test program links to libc and libedit, the latter links to libtinfo/libncursesw appropriately)

[labath]

In D92187#2425301, @mgorny wrote:

I've added some more debug as requested, and it confirmed that Linux and FreeBSD dyld are behaving differently here.

Linux triggers the breakpoint twice: first time in add state, including only /lib64/ld-linux-x86-64.so.2 and linux-vdso.so.1 in module list, and the second time in consistent state, adding soentries for all shared libraries.

FreeBSD triggers it only once, in consistent state and the remote list includes all libraries immediately

Thanks for investigating this. And I'm sorry for being so picky -- this is all very messy, and I am trying to understand things to avoid making an even bigger mess.

When you say "FreeBSD triggers it only once", which breakpoint are you referring to? The "rendezvous" breakpoint? Judging by the log's, I would say yes. But if that's true, then how does the "entry" breakpoint fit into this picture (IIUC, your change basically forces setting of the entry breakpoint on freebsd)? The question I'm looking to answer is whether we really need to set the entry breakpoint, or we just need some side-effect of what happens when we process that breakpoint hit (and we could achieve that differently).

I'm not saying that setting the entry breakpoint is a bad idea -- that mechanism seems more canonical than searching for some hardcoded symbol name -- but in order to decide that, we need to know what actually goes on in there...

[krytarowski]

Ideally we should iterate over the startup process and investigate the state of the r_debug structure. Once it gets initialized, set the software brakpoint to r_brk and keep track of the dynamic loading and unloading of libraries. The tricky part is to detect the right moment to plug into r_brk, early enough in the startup process before calling constructors, loading the libraries etc and late enough to become initialized.

Right now we place the breakpoints unconditionally, hardcoding the linker name, mostly ignoring the r_brk, but in practice it's not clear whether it's the simplest and sufficient approach.

[mgorny]

In D92187#2425378, @labath wrote:

In D92187#2425301, @mgorny wrote:

I've added some more debug as requested, and it confirmed that Linux and FreeBSD dyld are behaving differently here.

Linux triggers the breakpoint twice: first time in add state, including only /lib64/ld-linux-x86-64.so.2 and linux-vdso.so.1 in module list, and the second time in consistent state, adding soentries for all shared libraries.

FreeBSD triggers it only once, in consistent state and the remote list includes all libraries immediately

Thanks for investigating this. And I'm sorry for being so picky -- this is all very messy, and I am trying to understand things to avoid making an even bigger mess.

When you say "FreeBSD triggers it only once", which breakpoint are you referring to? The "rendezvous" breakpoint? Judging by the log's, I would say yes.

Yes.

But if that's true, then how does the "entry" breakpoint fit into this picture (IIUC, your change basically forces setting of the entry breakpoint on freebsd)? The question I'm looking to answer is whether we really need to set the entry breakpoint, or we just need some side-effect of what happens when we process that breakpoint hit (and we could achieve that differently).

It's not really about setting the breakpoint (it actually doesn't get set again because it's set already) but about registering the loaded libraries. I've presumed there's no harm in reusing the existing function as-is, i.e. issuing the unnecessary breakpoint call.

However, as I've noted on iRC, assuming the libraries reported on first rendezvous breakpoint to be 'added' would be a better solution. Most importantly, it fixes handling breakpoints in global constructors. I mean something like this:

diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
index 866acbddbdc..ad696995f9a 100644
--- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
+++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp
@@ -296,8 +296,10 @@ bool DYLDRendezvous::SaveSOEntriesFromRemote(
       return false;
 
     // Only add shared libraries and not the executable.
-    if (!SOEntryIsMainExecutable(entry))
+    if (!SOEntryIsMainExecutable(entry)) {
+      m_added_soentries.push_back(entry);
       m_soentries.push_back(entry);
+    }
   }
 
   m_loaded_modules = module_list;

I would appreciate any advice how to turn that hack into a proper-ish solution.

[mgorny]

Updated as discussed on IRC, to instead add libs returned by the first 'take snapshot' action.

[labath]

Awesome. Let's ship it.

[mgorny]

This causes ld-linux to be added twice on Linux. I need to change the logic a bit.

[mgorny]

Updated to perform the logic inside DynamicLoaderPOSIXDYLD, without touching DYLDRendezvous. This is much safer, and does not cause the double-load of ld-linux.

[mgorny]

Actually, I can still reproduce the double symbol problem with Arch's ld-2.32.so. I can't figure out what's wrong.

[mgorny]

One possible hackaround would be to do this only if 1st breakpoint hit is consistent (vs add on Linux), or just make the whole logic #if defined(__FreeBSD__).

[mgorny]

Avoid adding duplicate entry for ld-linux.

[mgorny]

Updated to unload duplicate ld.so as suggested by @labath.

[mgorny]

Another fix: we should only unload duplicate ld.so if it's actually a duplicate, i.e. the path differs. Otherwise, we've ended up unloading the only copy.

[labath]

In D92187#2450526, @mgorny wrote:

Another fix: we should only unload duplicate ld.so if it's actually a duplicate, i.e. the path differs. Otherwise, we've ended up unloading the only copy.

Would comparing the module shared_pointers work? I think that's exactly what we want here. I think it's possible for LoadModuleAtAddress to return the same module, even with paths which don't match exactly. But if it does that, then we will still end up unloading the original interpreter module...

[mgorny]

In D92187#2450976, @labath wrote:

In D92187#2450526, @mgorny wrote:

Another fix: we should only unload duplicate ld.so if it's actually a duplicate, i.e. the path differs. Otherwise, we've ended up unloading the only copy.

Would comparing the module shared_pointers work? I think that's exactly what we want here. I think it's possible for LoadModuleAtAddress to return the same module, even with paths which don't match exactly. But if it does that, then we will still end up unloading the original interpreter module...

How do you suggest we get the shared pointer for comparison? Store in class instance, or search for it somehow?

[labath]

In D92187#2451013, @mgorny wrote:

In D92187#2450976, @labath wrote:

In D92187#2450526, @mgorny wrote:

Another fix: we should only unload duplicate ld.so if it's actually a duplicate, i.e. the path differs. Otherwise, we've ended up unloading the only copy.

Would comparing the module shared_pointers work? I think that's exactly what we want here. I think it's possible for LoadModuleAtAddress to return the same module, even with paths which don't match exactly. But if it does that, then we will still end up unloading the original interpreter module...

How do you suggest we get the shared pointer for comparison? Store in class instance, or search for it somehow?

Store in the class (probably as a weak_ptr), just like you did with the path....

[mgorny]

Compare using weak_ptr to the interpreter module.

[labath]

Let's give this another shot.

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

protected:
   /// Contains AT_SYSINFO_EHDR, which means a vDSO has been
   /// mapped to the address space
   lldb::addr_t m_vdso_base;
 
   /// Contains AT_BASE, which means a dynamic loader has been
   /// mapped to the address space
   lldb::addr_t m_interpreter_base;
 
+  /// Contains the pointer to the interpret module, if loaded.
+  std::weak_ptr<lldb_private::Module> m_interpreter_module;
+
   /// Loaded module list. (link map for each module)
   std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>>
       m_loaded_modules;
 
   /// If possible sets a breakpoint on a function called by the runtime
   /// linker each time a module is loaded or unloaded.
   bool SetRendezvousBreakpoint();
 
   /// Callback routine which updates the current list of loaded modules based
   /// on the information supplied by the runtime linker.
   static bool RendezvousBreakpointHit(
       void *baton, lldb_private::StoppointCallbackContext *context,
       lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
 
+  /// Indicates whether the initial set of modules was reported added.
+  bool m_initial_modules_added;
+
   /// Helper method for RendezvousBreakpointHit.  Updates LLDB's current set
   /// of loaded modules.
   void RefreshModules();
 
   /// Updates the load address of every allocatable section in \p module.
   ///
   /// \param module The module to traverse.
   ///

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

DynamicLoader *DynamicLoaderPOSIXDYLD::CreateInstance(Process *process,
   return nullptr;
 }
 
 DynamicLoaderPOSIXDYLD::DynamicLoaderPOSIXDYLD(Process *process)
     : DynamicLoader(process), m_rendezvous(process),
       m_load_offset(LLDB_INVALID_ADDRESS), m_entry_point(LLDB_INVALID_ADDRESS),
       m_auxv(), m_dyld_bid(LLDB_INVALID_BREAK_ID),
       m_vdso_base(LLDB_INVALID_ADDRESS),
-      m_interpreter_base(LLDB_INVALID_ADDRESS) {}
+      m_interpreter_base(LLDB_INVALID_ADDRESS), m_initial_modules_added(false) {
+}
 
 DynamicLoaderPOSIXDYLD::~DynamicLoaderPOSIXDYLD() {
   if (m_dyld_bid != LLDB_INVALID_BREAK_ID) {
     m_process->GetTarget().RemoveBreakpointByID(m_dyld_bid);
     m_dyld_bid = LLDB_INVALID_BREAK_ID;
   }
 }
 
void DynamicLoaderPOSIXDYLD::RefreshModules() {
   if (!m_rendezvous.Resolve())
     return;
 
   DYLDRendezvous::iterator I;
   DYLDRendezvous::iterator E;
 
   ModuleList &loaded_modules = m_process->GetTarget().GetImages();
 
-  if (m_rendezvous.ModulesDidLoad()) {
+  if (m_rendezvous.ModulesDidLoad() || !m_initial_modules_added) {
     ModuleList new_modules;
 
+    // If this is the first time rendezvous breakpoint fires, we need
+    // to take care of adding all the initial modules reported by
+    // the loader.  This is necessary to list ld-linux.so on Linux,
+    // and all DT_NEEDED entries on *BSD.
+    if (m_initial_modules_added) {
+      I = m_rendezvous.loaded_begin();
       E = m_rendezvous.loaded_end();
-    for (I = m_rendezvous.loaded_begin(); I != E; ++I) {
+    } else {
+      I = m_rendezvous.begin();
+      E = m_rendezvous.end();
+      m_initial_modules_added = true;
+    }
+    for (; I != E; ++I) {
       ModuleSP module_sp =
           LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr, true);
       if (module_sp.get()) {
+        if (module_sp->GetObjectFile()->GetBaseAddress().GetLoadAddress(
+                &m_process->GetTarget()) == m_interpreter_base &&
+            module_sp != m_interpreter_module.lock()) {
+          // If this is a duplicate instance of ld.so, unload it.  We may end up
+          // with it if we load it via a different path than before (symlink
+          // vs real path).
+          // TODO: remove this once we either fix library matching or avoid
+          // loading the interpreter when setting the rendezvous breakpoint.
+          UnloadSections(module_sp);
+          loaded_modules.Remove(module_sp);
+          continue;
+        }
+
         loaded_modules.AppendIfNeeded(module_sp);
         new_modules.Append(module_sp);
       }
     }
     m_process->GetTarget().ModulesDidLoad(new_modules);
   }
 
   if (m_rendezvous.ModulesDidUnload()) {
ModuleSP DynamicLoaderPOSIXDYLD::LoadInterpreterModule() {
 
   FileSpec file(info.GetName().GetCString());
   ModuleSpec module_spec(file, target.GetArchitecture());
 
   if (ModuleSP module_sp = target.GetOrCreateModule(module_spec, 
                                                     true /* notify */)) {
     UpdateLoadedSections(module_sp, LLDB_INVALID_ADDRESS, m_interpreter_base,
                          false);
+    m_interpreter_module = module_sp;
     return module_sp;
   }
   return nullptr;
 }
 
 void DynamicLoaderPOSIXDYLD::LoadAllCurrentModules() {
   DYLDRendezvous::iterator I;
   DYLDRendezvous::iterator E;

lldb/source/Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.cpp

Status NativeProcessFreeBSD::Kill() {
   }
 
   return PtraceWrapper(PT_KILL, m_pid);
 }
 
 Status NativeProcessFreeBSD::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                                  MemoryRegionInfo &range_info) {
 
-  // TODO: figure out why it breaks stuff
-  return Status("currently breaks determining module list");
-
   if (m_supports_mem_region == LazyBool::eLazyBoolNo) {
     // We're done.
     return Status("unsupported");
   }
 
   Status error = PopulateMemoryRegionCache();
   if (error.Fail()) {
     return error;

lldb/test/API/api/multithreaded/TestMultithreaded.py

def setUp(self):
         self.generateSource('test_stop-hook.cpp')
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @skipIfNoSBHeaders
     # clang-cl does not support throw or catch (llvm.org/pr24538)
     @skipIfWindows
-    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr48370')
     def test_python_stop_hook(self):
         """Test that you can run a python command in a stop-hook when stdin is File based. """
         self.build_and_test('driver.cpp test_stop-hook.cpp',
                             'test_python_stop_hook')
 
     @skipIfRemote
     @skipIfNoSBHeaders
     # clang-cl does not support throw or catch (llvm.org/pr24538)

lldb/test/API/functionalities/breakpoint/global_constructor/TestBreakpointInGlobalConstructor.py

 from lldbsuite.test import lldbutil
 
 
 class TestBreakpointInGlobalConstructors(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
-    @expectedFailureAll(oslist=["freebsd"], bugnumber='llvm.org/pr48373')
     @expectedFailureNetBSD
     def test(self):
         self.build()
         self.line_foo = line_number('foo.cpp', '// !BR_foo')
         self.line_main = line_number('main.cpp', '// !BR_main')
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/functionalities/memory-region/TestMemoryRegion.py

class MemoryCommandRegion(TestBase):
 
     def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number(
             'main.cpp',
             '// Run here before printing memory regions')
 
-    @expectedFailureAll(oslist=["freebsd"])
     def test(self):
         self.build()
 
         # Set breakpoint in main and run
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_is_supported_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_is_supported()
 
     @llgs_test
-    @expectedFailureAll(oslist=["freebsd"])
     def test_qMemoryRegionInfo_is_supported_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_is_supported()
 
     def qMemoryRegionInfo_reports_code_address_as_executable(self):
         # Start up the inferior.
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     def test_qMemoryRegionInfo_reports_code_address_as_executable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_code_address_as_executable()
 
     @skipIfWindows # No pty support to test any inferior output
-    @expectedFailureAll(oslist=["freebsd"])
     @llgs_test
     def test_qMemoryRegionInfo_reports_code_address_as_executable_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_code_address_as_executable()
 
     def qMemoryRegionInfo_reports_stack_address_as_readable_writeable(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
 
     @skipIfWindows # No pty support to test any inferior output
-    @expectedFailureAll(oslist=["freebsd"])
     @llgs_test
     def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
 

     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 
     @skipIfWindows # No pty support to test any inferior output
-    @expectedFailureAll(oslist=["freebsd"])
     @llgs_test
     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 

lldb/test/API/tools/lldb-server/libraries-svr4/TestGdbRemoteLibrariesSvr4Support.py

class TestGdbRemoteLibrariesSvr4Support(gdbremote_testcase.GdbRemoteTestCaseBase):
     @skipUnlessPlatform(["linux", "android", "freebsd", "netbsd"])
     @expectedFailureNetBSD
     def test_libraries_svr4_well_formed(self):
         self.setup_test()
         self.libraries_svr4_well_formed()
 
     @llgs_test
     @skipUnlessPlatform(["linux", "android", "freebsd", "netbsd"])
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureNetBSD
     def test_libraries_svr4_load_addr(self):
         self.setup_test()
         self.libraries_svr4_has_correct_load_addr()
 
     @llgs_test
     @skipUnlessPlatform(["linux", "android", "freebsd", "netbsd"])
     @expectedFailureNetBSD
     def test_libraries_svr4_libs_present(self):
         self.setup_test()
         self.libraries_svr4_libs_present()

lldb/test/Shell/Unwind/thread-step-out-ret-addr-check.test

 # Test that `thread step-out` fails when the "return address"
 # points to non-executable memory.
 
 # REQUIRES: target-x86_64
 # UNSUPPORTED: system-windows
-# XFAIL: system-freebsd
 
 # RUN: %clang_host %p/Inputs/call-asm.c -x assembler-with-cpp %p/Inputs/thread-step-out-ret-addr-check.s -o %t
 # RUN: not %lldb %t -s %s -b 2>&1 | FileCheck %s
 
 breakpoint set -n nonstandard_stub
 # CHECK: Breakpoint 1: where = {{.*}}`nonstandard_stub
 
 process launch
 # CHECK: stop reason = breakpoint 1.1
 
 thread step-out
 # CHECK: Could not create return address breakpoint.
 # CHECK: Return address (0x{{[a-f0-9]*}}) did not point to executable memory.