Centralize all calls to select() into a single class so we always call select properly

[clayborg]

Summary

New calls to select() were introduced into LLDB over the past year that were not doing the right thing on Darwin and these were causing crashes when the file descriptor exceeded FD_SETSIZE. Darwin has special abilities to deal with file descriptors that are greater than or equal to FD_SETSIZE, so we should be able to do things correctly.

This change makes a new File::SelectInfo class that helps encapsulate calls to select() so they all happen correctly. I have updates all calls to select() within LLDB to use this code.

This needs to be tested on Windows, Linux, and FreeBSD. If anyone can't test in the next few days, please resign as reviewer and add someone that can.

[emaste]

Testing now on FreeBSD. Do you have a sense of how many fds lldb might use in practice? For FreeBSD we can increase it from the default if necessary via

NOTES
     The default size of FD_SETSIZE is currently 1024.  In order to accommo‐
     date programs which might potentially use a larger number of open files
     with select(), it is possible to increase this size by having the program
     define FD_SETSIZE before the inclusion of any header which includes
     <sys/types.h>.

Also for future patch uploads would you include more context to make review easier (e.g. git diff -U999 or svn diff --diff-cmd=diff -x -U999)?

[emaste]

I saw no regression on FreeBSD with this patch

[labath]

I see no regressions on Linux. Reassigning to Tamas, if you need any more input, as I will be away next week.

I don't want to block this on that, as I think it is a step in the right direction, but am thinking about the interaction of this and the MainLoopPosix class I added last year, which I envisioned as doing the same thing. I think they should be eventually merged, or at least implemented in terms of each other. The current differences are :

• SelectInfo does not handle signals -- pselect (hard requirement for lldb-server). They don't need to work on windows though. I assume the darwin select extension trick will work on pselect as well(?)
• MainLoop uses a callback-based interface - might be more cumbersome for some uses, but some of the uses I see here would actually benefit from that, as they are doing a while(!done) loop anyway.

include/lldb/Host/File.h

442 ↗

(On Diff #66063)

I am not sure about the location of this class, File seems like a bad place, especially considering that select does not even work with files (sockets only) on Windows. Maybe IOObject.h, or a standalone file?

501 ↗

(On Diff #66063)

I think we use _up as a suffix now.

[labath]

Ok, there is one more big difference: MainLoop doesn't have timeouts yet. So yes, I guess these are not yet ready for merging...

[zturner]

Currently running the test suite, will report back when it's done.

include/lldb/Host/File.h

442 ↗

(On Diff #66063)

+1 for making a new file out of this. I would probably just call it Select.h or SelectInfo.h. I like Select better than SelectInfo (as a file name and as a class name), because SelectInfo makes it sound like you're going to query the class for something, not that it's actually going to perform some system level operation.

493–498 ↗

(On Diff #66063)

How about a bitfield?

500 ↗

(On Diff #66063)

llvm::DenseMap will be more efficient (space-wise, and speed-wise)

501 ↗

(On Diff #66063)

llvm::Optional<T> is another option here. It's nice in that it doesn't use a heap allocation and has better cache performance.

source/Host/common/File.cpp

19 ↗

(On Diff #66063)

Inside of the #if defined(_WIN32) preprocessor section here, you need to add this line:

#include <winsock2.h>

[zturner]

Aside from the compilation error caused by not including winsock2.h, I saw no other obvious problems here, and there are no test regressions.

[jingham]

In D22950#500582, @emaste wrote:

Testing now on FreeBSD. Do you have a sense of how many fds lldb might use in practice? For FreeBSD we can increase it from the default if necessary via

NOTES
     The default size of FD_SETSIZE is currently 1024.  In order to accommo‐
     date programs which might potentially use a larger number of open files
     with select(), it is possible to increase this size by having the program
     define FD_SETSIZE before the inclusion of any header which includes
     <sys/types.h>.

Also for future patch uploads would you include more context to make review easier (e.g. git diff -U999 or svn diff --diff-cmd=diff -x -U999)?

This is a particular problem on OS X because we support debugging with the debug info in .o files, so for a complex project we could be opening lots of those files. If you don't do that, then it's more like number of shared libraries a normal program will open. That's unlikely to get to more than 1024.

[emaste]

This is a particular problem on OS X because we support debugging with the debug info in .o files, so for a complex project we could be opening lots of those files. If you don't do that, then it's more like number of shared libraries a normal program will open. That's unlikely to get to more than 1024.

OK. We'll want to support the same approach in FreeBSD too, but other tooling needs to be in place first (at least a new linker) so it can be left alone for now. We can just bump it up if/when it becomes a problem.

[clayborg]

I am back from vacation again.

I will place this in a stand alone file and I will use SelectInfo.h if there is a "select.h" already in any "include" directories like "/usr/include" so we don't run into problems including the right file. If there aren't any select.h files, I will use Select.h. I would like to not use anything llvm in the SelectInfo.h file to keep us able to use this class in other tools that might not be including llvm or clang.

[clayborg]

Updated with all comments taken into account. Zach, please try this out and let me know if it compiles.

[clayborg]

I used SelectHelper.h because there is a "/usr/include/select.h" header file and case insensitive file systems would have issues if I used Select.h.

[clayborg]

This was committed with 278299. We can iterate on this as needed.

include/lldb/Utility/SelectHelper.h

+//===-- SelectHelper.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_SelectHelper_h_
+#define liblldb_SelectHelper_h_
+
+// C Includes
+// C++ Includes
+#include <chrono>
+
+// Other libraries and framework includes
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+
+// Project includes
+#include "lldb/lldb-forward.h"
+
+class SelectHelper
+{
+public:
+
+    // Defaults to infinite wait for select unless you call SetTimeout()
+    SelectHelper();
+
+    // Call SetTimeout() before calling SelectHelper::Select() to set the
+    // timeout based on the current time + the timeout. This allows multiple
+    // calls to SelectHelper::Select() without having to worry about the
+    // absolute timeout as this class manages to set the relative timeout
+    // correctly.
+    void SetTimeout(const std::chrono::microseconds &timeout);
+
+    // Call the FDSet*() functions before calling SelectHelper::Select() to
+    // set the file descriptors that we will watch for when calling
+    // select. This will cause FD_SET() to be called prior to calling select
+    // using the "fd" provided.
+    void FDSetRead(int fd);
+    void FDSetWrite(int fd);
+    void FDSetError(int fd);
+
+    // Call the FDIsSet*() functions after calling SelectHelper::Select()
+    // to check which file descriptors are ready for read/write/error. This
+    // will contain the result of FD_ISSET after calling select for a given
+    // file descriptor.
+    bool FDIsSetRead(int fd) const;
+    bool FDIsSetWrite(int fd) const;
+    bool FDIsSetError(int fd) const;
+
+    // Call the system's select() to wait for descriptors using
+    // timeout provided in a call the SelectHelper::SetTimeout(),
+    // or infinite wait if no timeout was set.
+    lldb_private::Error Select();
+protected:
+    struct FDInfo
+    {
+        FDInfo() :
+            read_set(false),
+            write_set(false),
+            error_set(false),
+            read_is_set(false),
+            write_is_set(false),
+            error_is_set(false)
+        {
+        }
+
+        void
+        PrepareForSelect()
+        {
+            read_is_set = false;
+            write_is_set = false;
+            error_is_set = false;
+        }
+
+        bool read_set     : 1,
+             write_set    : 1,
+             error_set    : 1,
+             read_is_set  : 1,
+             write_is_set : 1,
+             error_is_set : 1;
+    };
+    llvm::DenseMap<int, FDInfo> m_fd_map;
+    llvm::Optional<std::chrono::steady_clock::time_point> m_end_time;
+};
+
+#endif // liblldb_SelectHelper_h_

lldb.xcodeproj/project.pbxproj

     26954EBE1401EE8B00294D09 /* DynamicRegisterInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26954EBC1401EE8B00294D09 /* DynamicRegisterInfo.cpp */; };
     26957D9813D381C900670048 /* RegisterContextDarwin_arm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26957D9213D381C900670048 /* RegisterContextDarwin_arm.cpp */; };
     26957D9A13D381C900670048 /* RegisterContextDarwin_i386.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26957D9413D381C900670048 /* RegisterContextDarwin_i386.cpp */; };
     26957D9C13D381C900670048 /* RegisterContextDarwin_x86_64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26957D9613D381C900670048 /* RegisterContextDarwin_x86_64.cpp */; };
     2697A39315E404B1003E682C /* OptionValueArch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2697A39215E404B1003E682C /* OptionValueArch.cpp */; };
     2697A54D133A6305004E4240 /* PlatformDarwin.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2697A54B133A6305004E4240 /* PlatformDarwin.cpp */; };
     2698699B15E6CBD0002415FF /* OperatingSystemPython.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2698699815E6CBD0002415FF /* OperatingSystemPython.cpp */; };
     269DDD4A1B8FD1C300D0DBD8 /* DWARFASTParserClang.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 269DDD481B8FD1C300D0DBD8 /* DWARFASTParserClang.cpp */; };
+    26A375811D59462700D6CBDB /* SelectHelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26A3757F1D59462700D6CBDB /* SelectHelper.cpp */; };
     26A527C114E24F5F00F3A14A /* ProcessMachCore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26A527BD14E24F5F00F3A14A /* ProcessMachCore.cpp */; };
     26A527C314E24F5F00F3A14A /* ThreadMachCore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26A527BF14E24F5F00F3A14A /* ThreadMachCore.cpp */; };
     26A69C5F137A17A500262477 /* RegisterValue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26C6886E137880C400407EDF /* RegisterValue.cpp */; };
     26A7A035135E6E4200FB369E /* OptionValue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26A7A034135E6E4200FB369E /* OptionValue.cpp */; };
     26AB92121819D74600E63F3E /* DWARFDataExtractor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26AB92101819D74600E63F3E /* DWARFDataExtractor.cpp */; };
     26B1EFAE154638AF00E2DAC7 /* DWARFDeclContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26B1EFAC154638AF00E2DAC7 /* DWARFDeclContext.cpp */; };
     26B1FCC21338115F002886E2 /* Host.mm in Sources */ = {isa = PBXBuildFile; fileRef = 26BC7EE810F1B88F00F91463 /* Host.mm */; };
     26B42C4D1187ABA50079C8C8 /* LLDB.h in Headers */ = {isa = PBXBuildFile; fileRef = 26B42C4C1187ABA50079C8C8 /* LLDB.h */; settings = {ATTRIBUTES = (Public, ); }; };

     265205A613D3E3F700132FE2 /* RegisterContextKDP_x86_64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextKDP_x86_64.cpp; sourceTree = "<group>"; };
     265205A713D3E3F700132FE2 /* RegisterContextKDP_x86_64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterContextKDP_x86_64.h; sourceTree = "<group>"; };
     26579F68126A25920007C5CB /* darwin-debug */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "darwin-debug"; sourceTree = BUILT_PRODUCTS_DIR; };
     2657AFB51B8690EC00958979 /* CompilerDeclContext.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = CompilerDeclContext.h; path = include/lldb/Symbol/CompilerDeclContext.h; sourceTree = "<group>"; };
     2657AFB61B86910100958979 /* CompilerDeclContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CompilerDeclContext.cpp; path = source/Symbol/CompilerDeclContext.cpp; sourceTree = "<group>"; };
     265ABF6210F42EE900531910 /* DebugSymbols.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = DebugSymbols.framework; path = /System/Library/PrivateFrameworks/DebugSymbols.framework; sourceTree = "<absolute>"; };
     265E9BE1115C2BAA00D0DCCB /* debugserver.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = debugserver.xcodeproj; path = tools/debugserver/debugserver.xcodeproj; sourceTree = "<group>"; };
     2660D9F611922A1300958FBD /* StringExtractor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StringExtractor.cpp; path = source/Utility/StringExtractor.cpp; sourceTree = "<group>"; };
-    2660D9F711922A1300958FBD /* StringExtractor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StringExtractor.h; path = source/Utility/StringExtractor.h; sourceTree = "<group>"; };
     2660D9FE11922A7F00958FBD /* ThreadPlanStepUntil.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadPlanStepUntil.cpp; path = source/Target/ThreadPlanStepUntil.cpp; sourceTree = "<group>"; };
     26651A14133BEC76005B64B7 /* lldb-public.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "lldb-public.h"; path = "include/lldb/lldb-public.h"; sourceTree = "<group>"; };
     26651A15133BF9CC005B64B7 /* Opcode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Opcode.h; path = include/lldb/Core/Opcode.h; sourceTree = "<group>"; };
     26651A17133BF9DF005B64B7 /* Opcode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Opcode.cpp; path = source/Core/Opcode.cpp; sourceTree = "<group>"; };
     2665CD0D15080846002C8FAE /* Makefile */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.make; path = Makefile; sourceTree = "<group>"; };
     266603C91345B5A8004DA8B6 /* ConnectionSharedMemory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ConnectionSharedMemory.cpp; path = source/Core/ConnectionSharedMemory.cpp; sourceTree = "<group>"; };
     266603CC1345B5C0004DA8B6 /* ConnectionSharedMemory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ConnectionSharedMemory.h; path = include/lldb/Core/ConnectionSharedMemory.h; sourceTree = "<group>"; };
     2666ADC11B3CB675001FAFD3 /* DynamicLoaderHexagonDYLD.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DynamicLoaderHexagonDYLD.cpp; sourceTree = "<group>"; };

     269DDD481B8FD1C300D0DBD8 /* DWARFASTParserClang.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DWARFASTParserClang.cpp; sourceTree = "<group>"; };
     269DDD491B8FD1C300D0DBD8 /* DWARFASTParserClang.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DWARFASTParserClang.h; sourceTree = "<group>"; };
     269FF07D12494F7D00225026 /* FuncUnwinders.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FuncUnwinders.h; path = include/lldb/Symbol/FuncUnwinders.h; sourceTree = "<group>"; };
     269FF07F12494F8E00225026 /* UnwindPlan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = UnwindPlan.h; path = include/lldb/Symbol/UnwindPlan.h; sourceTree = "<group>"; };
     269FF08112494FC200225026 /* UnwindTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = UnwindTable.h; path = include/lldb/Symbol/UnwindTable.h; sourceTree = "<group>"; };
     26A0604711A5BC7A00F75969 /* Baton.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Baton.h; path = include/lldb/Core/Baton.h; sourceTree = "<group>"; };
     26A0604811A5D03C00F75969 /* Baton.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Baton.cpp; path = source/Core/Baton.cpp; sourceTree = "<group>"; };
     26A0DA4D140F721D006DA411 /* HashedNameToDIE.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = HashedNameToDIE.h; sourceTree = "<group>"; };
+    26A3757F1D59462700D6CBDB /* SelectHelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SelectHelper.cpp; path = source/Utility/SelectHelper.cpp; sourceTree = "<group>"; };
+    26A375831D59486000D6CBDB /* StringExtractor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = StringExtractor.h; path = include/lldb/Utility/StringExtractor.h; sourceTree = "<group>"; };
+    26A375841D59487700D6CBDB /* SelectHelper.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SelectHelper.h; path = include/lldb/Utility/SelectHelper.h; sourceTree = "<group>"; };
     26A3B4AC1181454800381BC2 /* ObjectContainerBSDArchive.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ObjectContainerBSDArchive.cpp; sourceTree = "<group>"; };
     26A3B4AD1181454800381BC2 /* ObjectContainerBSDArchive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ObjectContainerBSDArchive.h; sourceTree = "<group>"; };
     26A4EEB511682AAC007A372A /* LLDBWrapPython.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = LLDBWrapPython.cpp; sourceTree = BUILT_PRODUCTS_DIR; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
     26A527BD14E24F5F00F3A14A /* ProcessMachCore.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProcessMachCore.cpp; sourceTree = "<group>"; };
     26A527BE14E24F5F00F3A14A /* ProcessMachCore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProcessMachCore.h; sourceTree = "<group>"; };
     26A527BF14E24F5F00F3A14A /* ThreadMachCore.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ThreadMachCore.cpp; sourceTree = "<group>"; };
     26A527C014E24F5F00F3A14A /* ThreadMachCore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ThreadMachCore.h; sourceTree = "<group>"; };
     26A7A034135E6E4200FB369E /* OptionValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = OptionValue.cpp; path = source/Interpreter/OptionValue.cpp; sourceTree = "<group>"; };

         26D1803C16CEBFD300EDFB5B /* KQueue.cpp */,
         3F81691C1ABA242B001DA9DF /* NameMatches.h */,
         3F8169181ABA2419001DA9DF /* NameMatches.cpp */,
         94031A9F13CF5B3D00DCFF3C /* PriorityPointerPair.h */,
         94F6C4D119C264C70049D089 /* ProcessStructReader.h */,
         2682F16B115EDA0D00CCFF99 /* PseudoTerminal.h */,
         2682F16A115EDA0D00CCFF99 /* PseudoTerminal.cpp */,
         4CAB257C18EC9DB800BAD33E /* SafeMachO.h */,
+        26A375841D59487700D6CBDB /* SelectHelper.h */,
+        26A3757F1D59462700D6CBDB /* SelectHelper.cpp */,
         261B5A5211C3F2AD00AABD0A /* SharingPtr.cpp */,
         4C2FAE2E135E3A70001EDE44 /* SharedCluster.h */,
         261B5A5311C3F2AD00AABD0A /* SharingPtr.h */,
-        2660D9F711922A1300958FBD /* StringExtractor.h */,
+        26A375831D59486000D6CBDB /* StringExtractor.h */,
         2660D9F611922A1300958FBD /* StringExtractor.cpp */,
         2676A094119C93C8008A98EF /* StringExtractorGDBRemote.h */,
         2676A093119C93C8008A98EF /* StringExtractorGDBRemote.cpp */,
         94380B8019940B0300BFE4A8 /* StringLexer.h */,
         94380B8119940B0A00BFE4A8 /* StringLexer.cpp */,
         26D1804616CEE12C00EDFB5B /* TimeSpecTimeout.h */,
         26D1804016CEDF0700EDFB5B /* TimeSpecTimeout.cpp */,
         94EBAC8313D9EE26009BA64E /* PythonPointer.h */,

         2640E19F15DC78FD00F23B50 /* Property.cpp in Sources */,
         949EEDA01BA74B6D008C63CF /* CoreMedia.cpp in Sources */,
         26491E3E15E1DB9F00CBFFC2 /* OptionValueRegex.cpp in Sources */,
         2697A39315E404B1003E682C /* OptionValueArch.cpp in Sources */,
         6D55B2921A8A806200A70529 /* GDBRemoteCommunicationServerPlatform.cpp in Sources */,
         2698699B15E6CBD0002415FF /* OperatingSystemPython.cpp in Sources */,
         947A1D641616476B0017C8D1 /* CommandObjectPlugin.cpp in Sources */,
         2666ADC81B3CB675001FAFD3 /* HexagonDYLDRendezvous.cpp in Sources */,
+        26A375811D59462700D6CBDB /* SelectHelper.cpp in Sources */,
         AE44FB471BB4BB090033EB62 /* GoLanguage.cpp in Sources */,
         262ED0081631FA3A00879631 /* OptionGroupString.cpp in Sources */,
         94F48F251A01C687005C0EC6 /* StringPrinter.cpp in Sources */,
         94094C6B163B6F840083A547 /* ValueObjectCast.cpp in Sources */,
         AF9107EF168570D200DBCD3C /* RegisterContextDarwin_arm64.cpp in Sources */,
         AF1FA88A1A60A69500272AFC /* RegisterNumber.cpp in Sources */,
         94CB255C16B069770059775D /* DataVisualization.cpp in Sources */,
         94CB255D16B069770059775D /* FormatClasses.cpp in Sources */,

source/Host/common/Editline.cpp

 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/SelectHelper.h"
 
 using namespace lldb_private;
 using namespace lldb_private::line_editor;
 
 // Workaround for what looks like an OS X-specific issue, but other platforms
 // may benefit from something similar if issues arise.  The libedit library
 // doesn't explicitly initialize the curses termcap library, which it gets away
 // with until TERM is set to VT100 where it stumbles over an implementation

 bool
 IsInputPending (FILE * file)
 {
     // FIXME: This will be broken on Windows if we ever re-enable Editline.  You can't use select
     // on something that isn't a socket.  This will have to be re-written to not use a FILE*, but
     // instead use some kind of yet-to-be-created abstraction that select-like functionality on
     // non-socket objects.
     const int fd = fileno (file);
-    fd_set fds;
-    FD_ZERO (&fds);
-    FD_SET (fd, &fds);
-    timeval timeout = { 0, 0 };
-    return select (fd + 1, &fds, NULL, NULL, &timeout);
+    SelectHelper select_helper;
+    select_helper.SetTimeout(std::chrono::microseconds(0));
+    select_helper.FDSetRead(fd);
+    return select_helper.Select().Success();
 }
 
 namespace lldb_private
 {
     namespace line_editor
     {
         typedef std::weak_ptr<EditlineHistory> EditlineHistoryWP;
 

source/Host/posix/ConnectionFileDescriptorPosix.cpp

 #endif
 
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/IOObject.h"
 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
+#include "lldb/Utility/SelectHelper.h"
 
 // C Includes
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 

 }
 
 std::string
 ConnectionFileDescriptor::GetURI()
 {
     return m_uri;
 }
 
-// This ConnectionFileDescriptor::BytesAvailable() uses select().
+// This ConnectionFileDescriptor::BytesAvailable() uses select() via SelectHelper
 //
 // PROS:
 //  - select is consistent across most unix platforms
 //  - The Apple specific version allows for unlimited fds in the fd_sets by
 //    setting the _DARWIN_UNLIMITED_SELECT define prior to including the
 //    required header files.
 // CONS:
 //  - on non-Apple platforms, only supports file descriptors up to FD_SETSIZE.
 //     This implementation  will assert if it runs into that hard limit to let
 //     users know that another ConnectionFileDescriptor::BytesAvailable() should
 //     be used or a new version of ConnectionFileDescriptor::BytesAvailable()
 //     should be written for the system that is running into the limitations.
 
-#if defined(__APPLE__)
-#define FD_SET_DATA(fds) fds.data()
-#else
-#define FD_SET_DATA(fds) &fds
-#endif
 
 ConnectionStatus
 ConnectionFileDescriptor::BytesAvailable(uint32_t timeout_usec, Error *error_ptr)
 {
     // Don't need to take the mutex here separately since we are only called from Read.  If we
     // ever get used more generally we will need to lock here as well.
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_CONNECTION));
     if (log)
         log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)", static_cast<void *>(this), timeout_usec);
 
-    struct timeval *tv_ptr;
-    struct timeval tv;
-    if (timeout_usec == UINT32_MAX)
-    {
-        // Infinite wait...
-        tv_ptr = nullptr;
-    }
-    else
-    {
-        TimeValue time_value;
-        time_value.OffsetWithMicroSeconds(timeout_usec);
-        tv.tv_sec = time_value.seconds();
-        tv.tv_usec = time_value.microseconds();
-        tv_ptr = &tv;
-    }
 
     // Make a copy of the file descriptors to make sure we don't
     // have another thread change these values out from under us
     // and cause problems in the loop below where like in FS_SET()
     const IOObject::WaitableHandle handle = m_read_sp->GetWaitableHandle();
     const int pipe_fd = m_pipe.GetReadFileDescriptor();
 
+
     if (handle != IOObject::kInvalidHandleValue)
     {
+        SelectHelper select_helper;
+        if (timeout_usec != UINT32_MAX)
+            select_helper.SetTimeout(std::chrono::microseconds(timeout_usec));
+
+        select_helper.FDSetRead(handle);
 #if defined(_MSC_VER)
         // select() won't accept pipes on Windows.  The entire Windows codepath needs to be
         // converted over to using WaitForMultipleObjects and event HANDLEs, but for now at least
         // this will allow ::select() to not return an error.
         const bool have_pipe_fd = false;
 #else
         const bool have_pipe_fd = pipe_fd >= 0;
-#if !defined(__APPLE__)
-        assert(handle < FD_SETSIZE);
-        if (have_pipe_fd)
-            assert(pipe_fd < FD_SETSIZE);
-#endif
 #endif
-        while (handle == m_read_sp->GetWaitableHandle())
-        {
-            const int nfds = std::max<int>(handle, pipe_fd) + 1;
-#if defined(__APPLE__)
-            llvm::SmallVector<fd_set, 1> read_fds;
-            read_fds.resize((nfds / FD_SETSIZE) + 1);
-            for (size_t i = 0; i < read_fds.size(); ++i)
-                FD_ZERO(&read_fds[i]);
-// FD_SET doesn't bounds check, it just happily walks off the end
-// but we have taken care of making the extra storage with our
-// SmallVector of fd_set objects
-#else
-            fd_set read_fds;
-            FD_ZERO(&read_fds);
-#endif
-            FD_SET(handle, FD_SET_DATA(read_fds));
-            if (have_pipe_fd)
-                FD_SET(pipe_fd, FD_SET_DATA(read_fds));
-
-            Error error;
+            select_helper.FDSetRead(pipe_fd);
 
-            if (log)
-            {
-                if (have_pipe_fd)
-                    log->Printf(
-                        "%p ConnectionFileDescriptor::BytesAvailable()  ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p)...",
-                        static_cast<void *>(this), nfds, handle, pipe_fd, static_cast<void *>(tv_ptr));
-                else
-                    log->Printf("%p ConnectionFileDescriptor::BytesAvailable()  ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p)...",
-                                static_cast<void *>(this), nfds, handle, static_cast<void *>(tv_ptr));
-            }
+        while (handle == m_read_sp->GetWaitableHandle())
 
-            const int num_set_fds = ::select(nfds, FD_SET_DATA(read_fds), NULL, NULL, tv_ptr);
-            if (num_set_fds < 0)
-                error.SetErrorToErrno();
-            else
-                error.Clear();
-
-            if (log)
-            {
-                if (have_pipe_fd)
-                    log->Printf("%p ConnectionFileDescriptor::BytesAvailable()  ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p) "
-                                "=> %d, error = %s",
-                                static_cast<void *>(this), nfds, handle, pipe_fd, static_cast<void *>(tv_ptr), num_set_fds,
-                                error.AsCString());
-                else
-                    log->Printf("%p ConnectionFileDescriptor::BytesAvailable()  ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p) => "
-                                "%d, error = %s",
-                                static_cast<void *>(this), nfds, handle, static_cast<void *>(tv_ptr), num_set_fds, error.AsCString());
-            }
+            Error error = select_helper.Select();
 
             if (error_ptr)
                 *error_ptr = error;
 
             if (error.Fail())
             {
                 switch (error.GetError())
                 {
                     case EBADF: // One of the descriptor sets specified an invalid descriptor.
                         return eConnectionStatusLostConnection;
 
                     case EINVAL: // The specified time limit is invalid. One of its components is negative or too large.
                     default:     // Other unknown error
                         return eConnectionStatusError;
 
+                    case ETIMEDOUT:
+                        return eConnectionStatusTimedOut;
+
                     case EAGAIN: // The kernel was (perhaps temporarily) unable to
                                  // allocate the requested number of file descriptors,
                                  // or we have non-blocking IO
                     case EINTR:  // A signal was delivered before the time limit
                         // expired and before any of the selected events
                         // occurred.
                         break; // Lets keep reading to until we timeout
                 }
             }
-            else if (num_set_fds == 0)
-            {
-                return eConnectionStatusTimedOut;
-            }
-            else if (num_set_fds > 0)
+            else
             {
-                if (FD_ISSET(handle, FD_SET_DATA(read_fds)))
+                if (select_helper.FDIsSetRead(handle))
                     return eConnectionStatusSuccess;
-                if (have_pipe_fd && FD_ISSET(pipe_fd, FD_SET_DATA(read_fds)))
+
+                if (select_helper.FDIsSetRead(pipe_fd))
                 {
                     // There is an interrupt or exit command in the command pipe
                     // Read the data from that pipe:
                     char buffer[1];
 
                     ssize_t bytes_read;
 
                     do

source/Host/posix/PipePosix.cpp

 //===-- PipePosix.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/PipePosix.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Utility/SelectHelper.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 
 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
 #ifndef _GLIBCXX_USE_NANOSLEEP
 #define _GLIBCXX_USE_NANOSLEEP
 #endif
 #endif

 #endif
 
 std::chrono::time_point<std::chrono::steady_clock>
 Now()
 {
     return std::chrono::steady_clock::now();
 }
 
-Error
-SelectIO(int handle, bool is_read, const std::function<Error(bool&)> &io_handler, const std::chrono::microseconds &timeout)
-{
-    Error error;
-    fd_set fds;
-    bool done = false;
-
-    using namespace std::chrono;
-
-    const auto finish_time = Now() + timeout;
-
-    while (!done)
-    {
-        struct timeval tv = {0, 0};
-        if (timeout != microseconds::zero())
-        {
-            const auto remaining_dur = duration_cast<microseconds>(finish_time - Now());
-            if (remaining_dur.count() <= 0)
-            {
-                error.SetErrorString("timeout exceeded");
-                break;
-            }
-            const auto dur_secs = duration_cast<seconds>(remaining_dur);
-            const auto dur_usecs = remaining_dur % seconds(1);
-
-            tv.tv_sec = dur_secs.count();
-            tv.tv_usec = dur_usecs.count();
-        }
-        else
-            tv.tv_sec = 1;
-
-        FD_ZERO(&fds);
-        FD_SET(handle, &fds);
-
-        const auto retval = ::select(handle + 1,
-                                     (is_read) ? &fds : nullptr,
-                                     (is_read) ? nullptr : &fds,
-                                     nullptr, &tv);
-        if (retval == -1)
-        {
-            if (errno == EINTR)
-                continue;
-            error.SetErrorToErrno();
-            break;
-        }
-        if (retval == 0)
-        {
-            error.SetErrorString("timeout exceeded");
-            break;
-        }
-        if (!FD_ISSET(handle, &fds))
-        {
-            error.SetErrorString("invalid state");
-            break;
-        }
-
-        error = io_handler(done);
-        if (error.Fail())
-        {
-          if (error.GetError() == EINTR)
-              continue;
-            break;
-        }
-    }
-    return error;
-}
-
 }
 
 PipePosix::PipePosix()
     : m_fds{
         PipePosix::kInvalidDescriptor,
         PipePosix::kInvalidDescriptor
     } {}
 

 
 Error
 PipePosix::ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_read)
 {
     bytes_read = 0;
     if (!CanRead())
         return Error(EINVAL, eErrorTypePOSIX);
 
-    auto handle = GetReadFileDescriptor();
-    return SelectIO(handle,
-                    true,
-                    [=, &bytes_read](bool &done)
-                    {
-                      Error error;
-                      auto result = ::read(handle,
-                                           reinterpret_cast<char*>(buf) + bytes_read,
-                                           size - bytes_read);
-                      if (result != -1)
-                      {
-                          bytes_read += result;
-                          if (bytes_read == size || result == 0)
-                              done = true;
-                      }
-                      else
-                          error.SetErrorToErrno();
-
-                      return error;
-                  },
-                  timeout);
+    const int fd = GetReadFileDescriptor();
+
+    SelectHelper select_helper;
+    select_helper.SetTimeout(timeout);
+    select_helper.FDSetRead(fd);
+
+    while (error.Success())
+    {
+        error = select_helper.Select();
+        if (error.Success())
+        {
+            auto result = ::read(fd, reinterpret_cast<char*>(buf) + bytes_read, size - bytes_read);
+                    break;
+            {
+                break;
+            }
+        }
+    }
 }
 
 Error
 PipePosix::Write(const void *buf, size_t size, size_t &bytes_written)
 {
     bytes_written = 0;
     if (!CanWrite())
         return Error(EINVAL, eErrorTypePOSIX);
 
-    auto handle = GetWriteFileDescriptor();
-    return SelectIO(handle,
-                    false,
-                    [=, &bytes_written](bool &done)
-                    {
-                        Error error;
-                        auto result = ::write(handle,
-                                              reinterpret_cast<const char*>(buf) + bytes_written,
-                                              size - bytes_written);
-                        if (result != -1)
-                        {
-                            bytes_written += result;
-                            if (bytes_written == size)
-                                done = true;
-                        }
-                        else
-                            error.SetErrorToErrno();
-
-                        return error;
-                    },
-                    std::chrono::microseconds::zero());
+    const int fd = GetWriteFileDescriptor();
+    SelectHelper select_helper;
+    select_helper.SetTimeout(std::chrono::seconds(0));
+    select_helper.FDSetWrite(fd);
+
+    while (error.Success())
+    {
+        error = select_helper.Select();
+        if (error.Success())
+        {
+            auto result = ::write(fd, reinterpret_cast<const char*>(buf) + bytes_written, size - bytes_written);
+                    break;
+            {
+            }
+        }
+    }
 }

source/Target/Process.cpp

 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanBase.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/NameMatches.h"
+#include "lldb/Utility/SelectHelper.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Comment out line below to disable memory caching, overriding the process setting
 // target.process.disable-memory-cache
 #define ENABLE_MEMORY_CACHING
 

         terminal.SetCanonical(false);
         terminal.SetEcho(false);
 // FD_ZERO, FD_SET are not supported on windows
 #ifndef _WIN32
         const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
         m_is_running = true;
         while (!GetIsDone())
         {
-            fd_set read_fdset;
-            FD_ZERO (&read_fdset);
-            FD_SET (read_fd, &read_fdset);
-            FD_SET (pipe_read_fd, &read_fdset);
-            const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1;
-            int num_set_fds = select(nfds, &read_fdset, nullptr, nullptr, nullptr);
+            SelectHelper select_helper;
+            select_helper.FDSetRead(read_fd);
+            select_helper.FDSetRead(pipe_read_fd);
+            Error error = select_helper.Select();
 
-            if (num_set_fds < 0)
+            if (error.Fail())
             {
-                const int select_errno = errno;
-
-                if (select_errno != EINTR)
-                    SetIsDone(true);
+                SetIsDone(true);
             }
-            else if (num_set_fds > 0)
+            else
             {
                 char ch = 0;
                 size_t n;
-                if (FD_ISSET (read_fd, &read_fdset))
+                if (select_helper.FDIsSetRead(read_fd))
                 {
                     n = 1;
                     if (m_read_file.Read(&ch, n).Success() && n == 1)
                     {
                         if (m_write_file.Write(&ch, n).Fail() || n != 1)
                             SetIsDone(true);
                     }
                     else
                         SetIsDone(true);
                 }
-                if (FD_ISSET (pipe_read_fd, &read_fdset))
+                if (select_helper.FDIsSetRead(pipe_read_fd))
                 {
                     size_t bytes_read;
                     // Consume the interrupt byte
                     Error error = m_pipe.Read(&ch, 1, bytes_read);
                     if (error.Success())
                     {
                         switch (ch)
                         {

source/Utility/SelectHelper.cpp

+//===-- SelectHelper.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__APPLE__)
+// Enable this special support for Apple builds where we can have unlimited
+// select bounds. We tried switching to poll() and kqueue and we were panicing
+// the kernel, so we have to stick with select for now.
+#define _DARWIN_UNLIMITED_SELECT
+#endif
+
+// C Includes
+#include <errno.h>
+#include <sys/select.h>
+#if defined(_WIN32)
+#include <winsock2.h>
+#endif
+
+// C++ Includes
+#include <algorithm>
+
+// Other libraries and framework includes
+#include "llvm/ADT/SmallVector.h"
+
+// Project includes
+#include "lldb/Core/Error.h"
+#include "lldb/Utility/SelectHelper.h"
+#include "lldb/Utility/LLDBAssert.h"
+
+SelectHelper::SelectHelper() :
+    m_fd_map(),
+    m_end_time() // Infinite timeout unless SelectHelper::SetTimeout() gets called
+{
+}
+
+void
+SelectHelper::SetTimeout(const std::chrono::microseconds &timeout)
+{
+    using namespace std::chrono;
+    m_end_time = steady_clock::time_point(steady_clock::now() + timeout);
+}
+
+void
+SelectHelper::FDSetRead(int fd)
+{
+    m_fd_map[fd].read_set = true;
+}
+
+void
+SelectHelper::FDSetWrite(int fd)
+{
+    m_fd_map[fd].write_set = true;
+}
+
+void
+SelectHelper::FDSetError(int fd)
+{
+    m_fd_map[fd].error_set = true;
+}
+
+bool
+SelectHelper::FDIsSetRead(int fd) const
+{
+    auto pos = m_fd_map.find(fd);
+    if (pos != m_fd_map.end())
+        return pos->second.read_is_set;
+    else
+        return false;
+}
+
+bool
+SelectHelper::FDIsSetWrite(int fd) const
+{
+    auto pos = m_fd_map.find(fd);
+    if (pos != m_fd_map.end())
+        return pos->second.write_is_set;
+    else
+        return false;
+}
+
+bool
+SelectHelper::FDIsSetError(int fd) const
+{
+    auto pos = m_fd_map.find(fd);
+    if (pos != m_fd_map.end())
+        return pos->second.error_is_set;
+    else
+        return false;
+}
+
+lldb_private::Error
+SelectHelper::Select()
+{
+    lldb_private::Error error;
+
+    int max_read_fd = -1;
+    int max_write_fd = -1;
+    int max_error_fd = -1;
+    int max_fd = -1;
+    for (auto &pair : m_fd_map)
+    {
+        pair.second.PrepareForSelect();
+        const int fd = pair.first;
+#if !defined(__APPLE__)
+        lldbassert(fd < FD_SETSIZE);
+        if (fd >= FD_SETSIZE)
+        {
+            error.SetErrorStringWithFormat("%i is too large for select()", fd);
+            return error;
+        }
+#endif
+        if (pair.second.read_set)
+        {
+            max_read_fd = std::max<int>(fd, max_read_fd);
+            max_fd = std::max<int>(fd, max_fd);
+        }
+        if (pair.second.write_set)
+        {
+            max_write_fd = std::max<int>(fd, max_write_fd);
+            max_fd = std::max<int>(fd, max_fd);
+        }
+        if (pair.second.error_set)
+        {
+            max_error_fd = std::max<int>(fd, max_error_fd);
+            max_fd = std::max<int>(fd, max_fd);
+        }
+    }
+
+    if (max_fd == -1)
+    {
+        error.SetErrorString("no valid file descriptors");
+        return error;
+    }
+
+    const int nfds = max_fd + 1;
+    fd_set *read_fdset_ptr = nullptr;
+    fd_set *write_fdset_ptr = nullptr;
+    fd_set *error_fdset_ptr = nullptr;
+    //----------------------------------------------------------------------
+    // Initialize and zero out the fdsets
+    //----------------------------------------------------------------------
+#if defined(__APPLE__)
+    llvm::SmallVector<fd_set, 1> read_fdset;
+    llvm::SmallVector<fd_set, 1> write_fdset;
+    llvm::SmallVector<fd_set, 1> error_fdset;
+
+    if (max_read_fd >= 0)
+    {
+        read_fdset.resize((nfds / FD_SETSIZE) + 1);
+        read_fdset_ptr = read_fdset.data();
+    }
+    if (max_write_fd >= 0)
+    {
+        write_fdset.resize((nfds / FD_SETSIZE) + 1);
+        write_fdset_ptr = write_fdset.data();
+    }
+    if (max_error_fd >= 0)
+    {
+        error_fdset.resize((nfds / FD_SETSIZE) + 1);
+        error_fdset_ptr = error_fdset.data();
+    }
+    for (auto &fd_set : read_fdset)
+        FD_ZERO(&fd_set);
+    for (auto &fd_set : write_fdset)
+        FD_ZERO(&fd_set);
+    for (auto &fd_set : error_fdset)
+        FD_ZERO(&fd_set);
+#else
+    fd_set read_fdset;
+    fd_set write_fdset;
+    fd_set error_fdset;
+
+    if (max_read_fd >= 0)
+    {
+        FD_ZERO(&read_fdset);
+        read_fdset_ptr = &read_fdset;
+    }
+    if (max_write_fd >= 0)
+    {
+        FD_ZERO(&write_fdset);
+        write_fdset_ptr = &write_fdset;
+    }
+    if (max_error_fd >= 0)
+    {
+        FD_ZERO(&error_fdset);
+        error_fdset_ptr = &error_fdset;
+    }
+#endif
+    //----------------------------------------------------------------------
+    // Set the FD bits in the fdsets for read/write/error
+    //----------------------------------------------------------------------
+    for (auto &pair : m_fd_map)
+    {
+        const int fd = pair.first;
+
+        if (pair.second.read_set)
+            FD_SET(fd, read_fdset_ptr);
+
+        if (pair.second.write_set)
+            FD_SET(fd, write_fdset_ptr);
+
+        if (pair.second.error_set)
+            FD_SET(fd, error_fdset_ptr);
+    }
+
+    //----------------------------------------------------------------------
+    // Setup our timeout time value if needed
+    //----------------------------------------------------------------------
+    struct timeval *tv_ptr = nullptr;
+    struct timeval tv = {0, 0};
+
+    while (1)
+    {
+        using namespace std::chrono;
+        //------------------------------------------------------------------
+        // Setup out relative timeout based on the end time if we have one
+        //------------------------------------------------------------------
+        if (m_end_time.hasValue())
+        {
+            tv_ptr = &tv;
+            const auto remaining_dur = duration_cast<microseconds>(m_end_time.getValue() - steady_clock::now());
+            if (remaining_dur.count() > 0)
+            {
+                // Wait for a specific amount of time
+                const auto dur_secs = duration_cast<seconds>(remaining_dur);
+                const auto dur_usecs = remaining_dur % seconds(1);
+                tv.tv_sec = dur_secs.count();
+                tv.tv_usec = dur_usecs.count();
+            }
+            else
+            {
+                // Just poll once with no timeout
+                tv.tv_sec = 0;
+                tv.tv_usec = 0;
+            }
+        }
+        const int num_set_fds = ::select(nfds, read_fdset_ptr, write_fdset_ptr, error_fdset_ptr, tv_ptr);
+        if (num_set_fds < 0)
+        {
+            // We got an error
+            error.SetErrorToErrno();
+            if (error.GetError() == EINTR)
+            {
+                error.Clear();
+                continue; // Keep calling select if we get EINTR
+            }
+            else
+                return error;
+        }
+        else if (num_set_fds == 0)
+        {
+            // Timeout
+            error.SetError(ETIMEDOUT, lldb::eErrorTypePOSIX);
+            error.SetErrorString("timed out");
+            return error;
+        }
+        else
+        {
+            // One or more descriptors were set, update the FDInfo::select_is_set mask
+            // so users can ask the SelectHelper class so clients can call one of:
+
+            for (auto &pair : m_fd_map)
+            {
+                const int fd = pair.first;
+
+                if (pair.second.read_set)
+                {
+                    if (FD_ISSET(fd, read_fdset_ptr))
+                        pair.second.read_is_set = true;
+                }
+                if (pair.second.write_set)
+                {
+                    if (FD_ISSET(fd, write_fdset_ptr))
+                        pair.second.write_is_set = true;
+                }
+                if (pair.second.error_set)
+                {
+                    if (FD_ISSET(fd, error_fdset_ptr))
+                        pair.second.error_is_set = true;
+                }
+            }
+            break;
+        }
+    }
+    return error;
+}