reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

   17 class Status;

   31 class Status;

   24 class Status;

   25 class Status;

   25 class Status;

   23 class Status;

   30 class Status;

   26 class Status;

   29 class Status;

   27 class Status;

   37 class Status;

   15 class Status;

   25 class Status;

   24 class Status;

   32 class Status;

   88 class Status;

   15 class Status;

   16 class Status;

   29 class Status;

   28 class Status;

References

  253 inline auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object<decltype(
  254     std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
  256       std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
  259       std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));

   33   T Item;
   36   explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
   36   explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
   39     format_provider<typename std::decay<T>::type>::format(Item, S, Options);
   62   using Decayed = typename std::decay<T>::type;
   78   using ConstRefT = const typename std::decay<T>::type &;
  136 typename std::enable_if<uses_format_provider<T>::value,
  137                         provider_format_adapter<T>>::type
  138 build_format_adapter(T &&Item) {
  139   return provider_format_adapter<T>(std::forward<T>(Item));

   75   lldb_private::Status *get();
   77   lldb_private::Status *operator->();
   79   const lldb_private::Status &operator*() const;
   81   lldb_private::Status &ref();
   83   void SetError(const lldb_private::Status &lldb_error);
   86   std::unique_ptr<lldb_private::Status> m_opaque_up;

  158       const std::function<lldb_private::Status(const lldb::PlatformSP &)>

  145       Target &target, StructuredData::ObjectSP &data_object_sp, Status &error);

   76   static bool StringIsBreakpointName(llvm::StringRef str, Status &error);

  134   bool ConditionSaysStop(ExecutionContext &exe_ctx, Status &error);

   62                              Status &error);
  130                            Status &error);

   25   virtual Status ConfigurePrecondition(Args &args);

  108                            Status &error);

   34                            Status &error);

   31                            Status &error);

   33                            Status &error);

   54                            Status &error);

   36                            Status &error);

   98   const Status &GetError() { return m_error; }
  197   Status m_error; // An error object describing errors associated with this

  140   lldb::ConnectionStatus Connect(const char *url, Status *error_ptr);
  151   lldb::ConnectionStatus Disconnect(Status *error_ptr = nullptr);
  192               lldb::ConnectionStatus &status, Status *error_ptr);
  210                Status *error_ptr);
  248   virtual bool StartReadThread(Status *error_ptr = nullptr);
  255   virtual bool StopReadThread(Status *error_ptr = nullptr);
  257   virtual bool JoinReadThread(Status *error_ptr = nullptr);
  320                             lldb::ConnectionStatus &status, Status *error_ptr);

  233   Status SetPropertyValue(const ExecutionContext *exe_ctx,
  306   bool LoadPlugin(const FileSpec &spec, Status &error);
  318   Status RunREPL(lldb::LanguageType language, const char *repl_options);

  196   static Status Parse(const llvm::StringRef &format, Entry &entry);
  198   static Status ExtractVariableInfo(llvm::StringRef &format_str,
  215   static Status ParseInternal(llvm::StringRef &format, Entry &parent_entry,

  536   bool LoadScriptingResourceInTarget(Target *target, Status &error,
  613                                   lldb::addr_t header_addr, Status &error,

  457   bool LoadScriptingResourcesInTarget(Target *target, std::list<Status> &errors,
  465   static Status GetSharedModule(const ModuleSpec &module_spec,

  196   static Status SaveCore(const lldb::ProcessSP &process_sp,

  195                            Status &error);
  293                            Status &error);
  339                            Status &error);
  392                            Status &error);
  443                            Status &error);

   49   Status GetAsJSON(Stream &stream) const {
   50     Status error;
   62   Status GetDescription(Stream &stream) const {
   63     Status error;

   51                                                Status &error) const;
   53   virtual Status SetPropertyValue(const ExecutionContext *exe_ctx,
   58   virtual Status DumpPropertyValue(const ExecutionContext *exe_ctx,

  210   uint64_t GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx);
  212   Status GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,

  440   virtual bool SetValueFromCString(const char *value_str, Status &error);
  457   const Status &GetError();
  495   virtual bool IsLogicalTrue(Status &error);
  595   virtual lldb::ValueObjectSP Dereference(Status &error);
  603   virtual lldb::ValueObjectSP AddressOf(Status &error);
  671   ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
  678   virtual uint64_t GetData(DataExtractor &data, Status &error);
  680   virtual bool SetData(DataExtractor &data, Status &error);
  845   Status

   63                                     const Status &error);
   79   lldb::ValueObjectSP Dereference(Status &error) override;
   88   lldb::ValueObjectSP AddressOf(Status &error) override;
  147   ValueObjectConstResult(ExecutionContextScope *exe_scope, const Status &error);

   36   lldb::ValueObjectSP Dereference(Status &error) override;
   49   lldb::ValueObjectSP AddressOf(Status &error) override;

   42   lldb::ValueObjectSP Dereference(Status &error) override;
   55   lldb::ValueObjectSP AddressOf(Status &error) override;

   39   lldb::ValueObjectSP Dereference(Status &error);
   49   lldb::ValueObjectSP AddressOf(Status &error);

   80   bool SetValueFromCString(const char *value_str, Status &error) override;
   82   bool SetData(DataExtractor &data, Status &error) override;

  133   bool SetValueFromCString(const char *value_str, Status &error) override;
  135   bool SetData(DataExtractor &data, Status &error) override;

  104   bool SetValueFromCString(const char *value_str, Status &error) override;

   62   bool SetValueFromCString(const char *value_str, Status &error) override;
   64   bool SetData(DataExtractor &data, Status &error) override;

  280   Status m_error;

  164                 Value &result, Status *error_ptr) const;
  171                 Value &result, Status *error_ptr) const;
  230                        Status *error_ptr);

  133   virtual Status

   78   void GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
   85   lldb::addr_t WriteNow(const uint8_t *bytes, size_t size, Status &error);
  214   Status DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp);
  365   bool CommitOneAllocation(lldb::ProcessSP &process_sp, Status &error,

   39                            lldb_private::Status &error,
   45                         lldb_private::Status &error,
   52                                lldb_private::Status &err);

   54                       AllocationPolicy policy, bool zero_memory, Status &error);
   55   void Leak(lldb::addr_t process_address, Status &error);
   56   void Free(lldb::addr_t process_address, Status &error);
   59                    size_t size, Status &error);
   61                            size_t size, Status &error);
   63                             Status &error);
   65                   Status &error);
   67                             size_t size, Status &error);
   69                              lldb::addr_t process_address, Status &error);
   72                      size_t size, Status &error);

   80                            lldb_private::Status &err) = 0;

   36     void Dematerialize(Status &err, lldb::addr_t frame_top,
   70                                lldb::addr_t process_address, Status &err);
   81                         PersistentVariableDelegate *delegate, Status &err);
   82   uint32_t AddVariable(lldb::VariableSP &variable_sp, Status &err);
   85                              PersistentVariableDelegate *delegate, Status &err);
   86   uint32_t AddSymbol(const Symbol &symbol_sp, Status &err);
   87   uint32_t AddRegister(const RegisterInfo &register_info, Status &err);
  100                              lldb::addr_t process_address, Status &err) = 0;
  104                                lldb::addr_t frame_bottom, Status &err) = 0;

   55   static lldb::REPLSP Create(Status &Status, lldb::LanguageType language,
   79   Status RunLoop();
  114   virtual Status DoInitialization() = 0;

  264            lldb::ValueObjectSP &result_valobj_sp, Status &error,
  269   static const Status::ValueType kNoResult =
  287                                        ConstString &object_name, Status &err);

  103                                      Status &error);

   88   Status Read(void *buf, size_t &num_bytes) override;
  105   Status Write(const void *buf, size_t &num_bytes) override;
  118   Status Close() override;
  137   virtual Status GetFileSpec(FileSpec &file_spec) const;
  176   virtual off_t SeekFromStart(off_t offset, Status *error_ptr = nullptr);
  196   virtual off_t SeekFromCurrent(off_t offset, Status *error_ptr = nullptr);
  217   virtual off_t SeekFromEnd(off_t offset, Status *error_ptr = nullptr);
  240   virtual Status Read(void *dst, size_t &num_bytes, off_t &offset);
  265   virtual Status Write(const void *src, size_t &num_bytes, off_t &offset);
  272   virtual Status Flush();
  279   virtual Status Sync();
  332   uint32_t GetPermissions(Status &error) const;
  397   Status Read(void *buf, size_t &num_bytes) override;
  398   Status Write(const void *buf, size_t &num_bytes) override;
  399   Status Close() override;
  401   Status GetFileSpec(FileSpec &file_spec) const override;
  404   off_t SeekFromStart(off_t offset, Status *error_ptr = nullptr) override;
  405   off_t SeekFromCurrent(off_t offset, Status *error_ptr = nullptr) override;
  406   off_t SeekFromEnd(off_t offset, Status *error_ptr = nullptr) override;
  407   Status Read(void *dst, size_t &num_bytes, off_t &offset) override;
  408   Status Write(const void *src, size_t &num_bytes, off_t &offset) override;
  409   Status Flush() override;
  410   Status Sync() override;

   32                            uint32_t mode, Status &error);
   33   bool CloseFile(lldb::user_id_t fd, Status &error);
   36                      uint64_t src_len, Status &error);
   38                     uint64_t dst_len, Status &error);

   55   Status Symlink(const FileSpec &src, const FileSpec &dst);
   56   Status Readlink(const FileSpec &src, FileSpec &dst);
   58   Status ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);

  189   static Status LaunchProcess(ProcessLaunchInfo &launch_info);
  196   static Status ShellExpandArguments(ProcessLaunchInfo &launch_info);
  207   static Status RunShellCommand(const char *command,
  221   static Status RunShellCommand(const Args &args, const FileSpec &working_dir,

   30   virtual Status Terminate() = 0;
   31   virtual Status GetMainModule(FileSpec &file_spec) const = 0;

   33   virtual Status Join(lldb::thread_result_t *result) = 0;
   34   virtual Status Cancel() = 0;

   40   Status Terminate();
   41   Status GetMainModule(FileSpec &file_spec) const;

   34   Status Join(lldb::thread_result_t *result);
   35   Status Cancel();

   24   Status WriteLock(const uint64_t start, const uint64_t len);
   25   Status TryWriteLock(const uint64_t start, const uint64_t len);
   27   Status ReadLock(const uint64_t start, const uint64_t len);
   28   Status TryReadLock(const uint64_t start, const uint64_t len);
   30   Status Unlock();
   33   using Locker = std::function<Status(const uint64_t, const uint64_t)>;
   39   virtual Status DoWriteLock(const uint64_t start, const uint64_t len) = 0;
   40   virtual Status DoTryWriteLock(const uint64_t start, const uint64_t len) = 0;
   42   virtual Status DoReadLock(const uint64_t start, const uint64_t len) = 0;
   43   virtual Status DoTryReadLock(const uint64_t start, const uint64_t len) = 0;
   45   virtual Status DoUnlock() = 0;
   47   Status DoLock(const Locker &locker, const uint64_t start, const uint64_t len);

   49                                   Status &error) override;
   59                                 Status &error);
   61   Status Run() override;

   45                                           Status &error) {
   51   virtual Status Run() { llvm_unreachable("Not implemented"); }

   26                             Status &error) override;

   25   virtual Status CreateNew(bool child_process_inherit) = 0;
   26   virtual Status CreateNew(llvm::StringRef name,
   28   virtual Status CreateWithUniqueName(llvm::StringRef prefix,
   32   virtual Status OpenAsReader(llvm::StringRef name,
   35   Status OpenAsWriter(llvm::StringRef name, bool child_process_inherit);
   36   virtual Status
   57   virtual Status Delete(llvm::StringRef name) = 0;
   59   virtual Status Write(const void *buf, size_t size, size_t &bytes_written) = 0;
   60   virtual Status ReadWithTimeout(void *buf, size_t size,
   63   Status Read(void *buf, size_t size, size_t &bytes_read);

   97   bool ConvertArgumentsForLaunchingInShell(Status &error, bool localhost,

   22                                     Status &error) = 0;

   58                                         Status &error);
   60   virtual Status Connect(llvm::StringRef name) = 0;
   61   virtual Status Listen(llvm::StringRef name, int backlog) = 0;
   62   virtual Status Accept(Socket *&socket) = 0;
   67   static Status TcpListen(llvm::StringRef host_and_port,
   70   static Status TcpConnect(llvm::StringRef host_and_port,
   72   static Status UdpConnect(llvm::StringRef host_and_port,
   74   static Status UnixDomainConnect(llvm::StringRef host_and_port,
   77   static Status UnixDomainAccept(llvm::StringRef host_and_port,
   79   static Status UnixAbstractConnect(llvm::StringRef host_and_port,
   82   static Status UnixAbstractAccept(llvm::StringRef host_and_port,
   92   Status Read(void *buf, size_t &num_bytes) override;
   93   Status Write(const void *buf, size_t &num_bytes) override;
   95   virtual Status PreDisconnect();
   96   Status Close() override;
  103                                 int32_t &port, Status *error_ptr);
  114   static void SetLastError(Status &error);
  117                                    bool child_processes_inherit, Status &error);
  120                                    bool child_processes_inherit, Status &error);

   48   virtual Status Resume(const ResumeActionList &resume_actions) = 0;
   50   virtual Status Halt() = 0;
   52   virtual Status Detach() = 0;
   58   virtual Status Signal(int signo) = 0;
   68   virtual Status Interrupt();
   70   virtual Status Kill() = 0;
   74   virtual Status IgnoreSignals(llvm::ArrayRef<int> signals);
   78   virtual Status GetMemoryRegionInfo(lldb::addr_t load_addr,
   81   virtual Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
   84   Status ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size,
  112   virtual Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
  115   virtual Status AllocateMemory(size_t size, uint32_t permissions,
  118   virtual Status DeallocateMemory(lldb::addr_t addr) = 0;
  135   virtual Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
  138   virtual Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false);
  143   virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size);
  145   virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr);
  153   virtual Status SetWatchpoint(lldb::addr_t addr, size_t size,
  156   virtual Status RemoveWatchpoint(lldb::addr_t addr);
  250   virtual Status GetLoadedModuleFileSpec(const char *module_path,
  253   virtual Status GetFileLoadAddress(const llvm::StringRef &file_name,
  320                                      Status &error) {
  339   virtual Status StopTrace(lldb::user_id_t traceid,
  363   virtual Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
  371   virtual Status GetMetaData(lldb::user_id_t traceid, lldb::tid_t thread,
  392   virtual Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) {
  446   Status SetSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint);
  447   Status RemoveSoftwareBreakpoint(lldb::addr_t addr);

   46   virtual Status ReadRegister(const RegisterInfo *reg_info,
   49   virtual Status WriteRegister(const RegisterInfo *reg_info,
   52   virtual Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) = 0;
   54   virtual Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) = 0;
   66   virtual Status ClearAllHardwareBreakpoints();
   68   virtual Status GetHardwareBreakHitIndex(uint32_t &bp_index,
   78   virtual Status ClearAllHardwareWatchpoints();
   80   virtual Status IsWatchpointHit(uint32_t wp_index, bool &is_hit);
   82   virtual Status GetWatchpointHitIndex(uint32_t &wp_index,
   85   virtual Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant);
  102   virtual Status
  107   virtual Status
  127   Status SetPC(lldb::addr_t pc);
  131   Status SetSP(lldb::addr_t sp);
  135   Status SetFP(lldb::addr_t fp);
  148   Status WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval);
  150   Status WriteRegisterFromUnsigned(const RegisterInfo *reg_info, uint64_t uval);

   40   virtual Status SetWatchpoint(lldb::addr_t addr, size_t size,
   43   virtual Status RemoveWatchpoint(lldb::addr_t addr) = 0;
   46   virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) = 0;
   48   virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr) = 0;

   27   Status Add(lldb::addr_t addr, size_t size, uint32_t watch_flags,
   30   Status Remove(lldb::addr_t addr);

   41   Status Connect(llvm::StringRef name) override;
   42   Status Listen(llvm::StringRef name, int backlog) override;
   43   Status Accept(Socket *&conn_socket) override;
   45   Status CreateSocket(int domain);

   19   static Status Connect(llvm::StringRef name, bool child_processes_inherit,
   28   Status Connect(llvm::StringRef name) override;
   29   Status Listen(llvm::StringRef name, int backlog) override;
   30   Status Accept(Socket *&socket) override;

   52   lldb::ConnectionStatus Connect(llvm::StringRef s, Status *error_ptr) override;
   54   lldb::ConnectionStatus Disconnect(Status *error_ptr) override;
   57               lldb::ConnectionStatus &status, Status *error_ptr) override;
   60                Status *error_ptr) override;
   65                                         Status *error_ptr);
   82                                                Status *error_ptr);
   85                                     Status *error_ptr);
   87   lldb::ConnectionStatus ConnectUDP(llvm::StringRef args, Status *error_ptr);
   90                                             Status *error_ptr);
   93                                            Status *error_ptr);
   96                                                    Status *error_ptr);

   19   Status Connect(llvm::StringRef name) override;
   20   Status Listen(llvm::StringRef name, int backlog) override;
   21   Status Accept(Socket *&socket) override;

   26   virtual Status Signal(int signo) const;
   27   static Status Signal(lldb::process_t process, int signo);
   29   Status Terminate() override;
   30   Status GetMainModule(FileSpec &file_spec) const override;

   24   Status Join(lldb::thread_result_t *result) override;
   25   Status Cancel() override;
   27   Status Detach();

   22   Status DoWriteLock(const uint64_t start, const uint64_t len) override;
   24   Status DoTryWriteLock(const uint64_t start, const uint64_t len) override;
   26   Status DoReadLock(const uint64_t start, const uint64_t len) override;
   28   Status DoTryReadLock(const uint64_t start, const uint64_t len) override;
   30   Status DoUnlock() override;

   35   Status CreateNew(bool child_process_inherit) override;
   36   Status CreateNew(llvm::StringRef name, bool child_process_inherit) override;
   37   Status CreateWithUniqueName(llvm::StringRef prefix,
   40   Status OpenAsReader(llvm::StringRef name,
   42   Status
   66   Status Delete(llvm::StringRef name) override;
   68   Status Write(const void *buf, size_t size, size_t &bytes_written) override;
   69   Status ReadWithTimeout(void *buf, size_t size,

   19                             Status &error) override;

  516   Status PreprocessCommand(std::string &command);

  127   void SetError(const Status &error, const char *fallback_error_cstr = nullptr);

   19                                 Status *error);
   27                               int32_t fail_value, Status &error);
   34   static Status ToFormat(const char *s, lldb::Format &format,

   27   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

   34   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   36   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   33   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   35   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
   64   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   66   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   39   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   41   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   27   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   29   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   31   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   33   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
   39                                              bool make_selected, Status &error,

   38   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   40   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
   43   Status OptionParsingFinished(ExecutionContext *execution_context) override;

   31   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   33   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   32   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   34   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   27   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   29   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   27   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   29   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   27   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   29   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   28   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   30   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;

   88   virtual Status
  103                                           Status &error) const {
  108   virtual Status SetSubValue(const ExecutionContext *exe_ctx,
  172                                     Status &error);

   43   Status
   46   Status

   32   Status
   35   Status
   51                                   Status &error) const override;
  116   Status SetArgs(const Args &args, VarSetOperationType op);

   33   Status
   36   Status

   34   Status
   37   Status

   34   Status
   60                                   Status &error) const override;
   62   Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
   73   Status SetArgs(const Args &args, VarSetOperationType op);

   43   Status
   46   Status

   37   Status
   40   Status

   35   Status
   38   Status

   34   Status
   37   Status

   30   Status
   33   Status

   37   Status
   40   Status

   31   Status
   34   Status

   41   Status
   50   virtual Status DumpPropertyValue(const ExecutionContext *exe_ctx,
  102                                   Status &error) const override;
  104   Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,

   31   Status
   34   Status

   46   Status
   49   Status

   22   typedef Status (*ValidatorCallback)(const char *string, void *baton);
   81   Status
   84   Status
  113   Status SetCurrentValue(const char *) = delete;
  114   Status SetCurrentValue(llvm::StringRef value);
  116   Status AppendToCurrentValue(const char *value);

   34   static lldb::OptionValueSP Create(const char *, Status &) = delete;
   35   static lldb::OptionValueSP Create(llvm::StringRef value_str, Status &error);
   43   Status
   46   Status

   32   Status
   35   Status

  141   Status NotifyOptionParsingFinished(ExecutionContext *execution_context);
  160   virtual Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  230   virtual Status OptionParsingFinished(ExecutionContext *execution_context) {
  233     Status error;
  246   virtual Status SetOptionValue(uint32_t option_idx,
  252   virtual Status OptionParsingFinished(ExecutionContext *execution_context) {
  255     Status error;
  303   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  308   Status OptionParsingFinished(ExecutionContext *execution_context) override;

  108   virtual Status ExecuteMultipleLines(
  111     Status error;
  116   virtual Status
  118     Status error;
  123   virtual Status GenerateBreakpointCommandCallbackData(
  127     Status error;
  271   LoadPluginModule(const FileSpec &file_spec, lldb_private::Status &error) {
  277                      const char *setting_name, lldb_private::Status &error) {
  281   virtual Status GenerateFunction(const char *signature,
  283     Status error;
  296   Status
  300   virtual Status SetBreakpointCommandCallback(BreakpointOptions *bp_options,
  302     Status error;
  308   virtual Status SetBreakpointCommandCallback(
  311     Status error;
  316   Status SetBreakpointCommandCallbackFunction(
  322   virtual Status
  327     Status error;
  389                         Status &error,
  397       lldb_private::CommandReturnObject &cmd_retobj, Status &error,
  404                                       Status &error) {
  410                                       std::string &output, Status &error) {
  416                                       std::string &output, Status &error) {
  423                                       Status &error) {
  430                                       Status &error) {
  462                       lldb_private::Status &error,

  201                                         Status &error);
  222   const Symbol *FindBestGlobalDataSymbol(ConstString name, Status &error);

   96   static Status GetValuesForVariableExpressionPath(

   75   virtual Status SetReturnValueObject(lldb::StackFrameSP &frame_sp,

  165   virtual Status CanLoadImage() = 0;

  215   virtual LazyBool IsLogicalTrue(ValueObject &valobj, Status &error);

   47                            Status &error);

   32   size_t Read(lldb::addr_t addr, void *dst, size_t dst_len, Status &error);
  121                               Status &error);
  129                                 uint32_t chunk_size, Status &error);

   50       std::function<Status(const ModuleSpec &, const FileSpec &)>;
   52       std::function<Status(const lldb::ModuleSP &, const FileSpec &)>;
   54   Status GetAndPut(const FileSpec &root_dir_spec, const char *hostname,
   61   Status Put(const FileSpec &root_dir_spec, const char *hostname,
   65   Status Get(const FileSpec &root_dir_spec, const char *hostname,

  106   static lldb::PlatformSP Create(ConstString name, Status &error);
  109                                  ArchSpec *platform_arch_ptr, Status &error);
  146   virtual Status ResolveExecutable(const ModuleSpec &module_spec,
  195   virtual Status ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
  289   virtual Status GetFileWithUUID(const FileSpec &platform_file,
  300   virtual Status GetSharedModule(const ModuleSpec &module_spec,
  309   virtual Status ConnectRemote(Args &args);
  311   virtual Status DisconnectRemote();
  334   virtual Status LaunchProcess(ProcessLaunchInfo &launch_info);
  341   virtual Status ShellExpandArguments(ProcessLaunchInfo &launch_info);
  344   virtual Status KillProcess(const lldb::pid_t pid);
  367                Status &error);
  373                                          lldb_private::Status &error);
  396                                  Status &error) = 0;
  501   virtual Status MakeDirectory(const FileSpec &file_spec, uint32_t permissions);
  503   virtual Status GetFilePermissions(const FileSpec &file_spec,
  506   virtual Status SetFilePermissions(const FileSpec &file_spec,
  511                                    Status &error) {
  515   virtual bool CloseFile(lldb::user_id_t fd, Status &error) { return false; }
  522                             uint64_t dst_len, Status &error) {
  530                              const void *src, uint64_t src_len, Status &error) {
  537   virtual Status GetFile(const FileSpec &source, const FileSpec &destination);
  539   virtual Status PutFile(const FileSpec &source, const FileSpec &destination,
  542   virtual Status
  568   virtual Status Install(const FileSpec &src, const FileSpec &dst);
  574   virtual Status Unlink(const FileSpec &file_spec);
  615   virtual lldb_private::Status RunShellCommand(
  765                      lldb_private::Status &error);
  800                                lldb_private::Status &error,
  806                                lldb_private::Status &error,
  809   virtual Status UnloadImage(lldb_private::Process *process,
  827                                            lldb_private::Status &error);
  878   Status GetCachedExecutable(ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
  882   virtual Status DownloadModuleSlice(const FileSpec &src_file_spec,
  887   virtual Status DownloadSymbolFile(const lldb::ModuleSP &module_sp,
  893   typedef std::function<Status(const ModuleSpec &)> ModuleResolver;
  895   Status GetRemoteSharedModule(const ModuleSpec &module_spec, Process *process,
  903   Status LoadCachedExecutable(const ModuleSpec &module_spec,
  986   lldb_private::Status
 1011   lldb_private::Status
 1034   lldb_private::Status

  212   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  617   virtual Status Launch(ProcessLaunchInfo &launch_info);
  619   virtual Status LoadCore();
  621   virtual Status DoLoadCore() {
  622     Status error;
  723   virtual Status Attach(ProcessAttachInfo &attach_info);
  737   virtual Status ConnectRemote(Stream *strm, llvm::StringRef remote_url);
  827   Status Resume();
  829   Status ResumeSynchronous(Stream *stream);
  848   Status Halt(bool clear_thread_plans = false, bool use_run_lock = true);
  859   Status Detach(bool keep_stopped);
  876   Status Destroy(bool force_kill);
  884   Status Signal(int signal);
  900   virtual Status WillAttachToProcessWithID(lldb::pid_t pid) { return Status(); }
  908   virtual Status WillAttachToProcessWithName(const char *process_name,
  925   virtual Status DoConnectRemote(Stream *strm, llvm::StringRef remote_url) {
  926     Status error;
  945   virtual Status DoAttachToProcessWithID(lldb::pid_t pid,
  947     Status error;
  967   virtual Status
  970     Status error;
 1003   virtual Status WillLaunch(Module *module) { return Status(); }
 1022   virtual Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) {
 1023     Status error;
 1041   virtual Status WillResume() { return Status(); }
 1058   virtual Status DoResume() {
 1059     Status error;
 1077   virtual Status WillHalt() { return Status(); }
 1094   virtual Status DoHalt(bool &caused_stop) {
 1095     Status error;
 1114   virtual Status WillDetach() { return Status(); }
 1121   virtual Status DoDetach(bool keep_stopped) {
 1122     Status error;
 1146   virtual Status WillSignal() { return Status(); }
 1152   virtual Status DoSignal(int signal) {
 1153     Status error;
 1160   virtual Status WillDestroy() { return Status(); }
 1162   virtual Status DoDestroy() = 0;
 1425                               Status &error) = 0;
 1460                             Status &error);
 1491                                 Status &error);
 1521                               Status &error, size_t type_width = 1);
 1531                                size_t cstr_max_len, Status &error);
 1534                                Status &error);
 1563                                          Status &error);
 1566                                       int64_t fail_value, Status &error);
 1568   lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error);
 1571                             Status &error);
 1592                                size_t size, Status &error) {
 1629                              size_t size, Status &error);
 1633                                      Status &error);
 1660                      Status &error);
 1676                                         Status &error) {
 1683   virtual Status WriteObjectFile(std::vector<ObjectFile::LoadableData> entries);
 1706   lldb::addr_t AllocateMemory(size_t size, uint32_t permissions, Status &error);
 1732                                Status &error);
 1746                                                Status &error);
 1772   virtual Status GetMemoryRegionInfo(lldb::addr_t load_addr,
 1774     Status error;
 1787   virtual Status
 1790   virtual Status GetWatchpointSupportInfo(uint32_t &num) {
 1791     Status error;
 1797   virtual Status GetWatchpointSupportInfo(uint32_t &num, bool &after) {
 1798     Status error;
 1878   virtual Status DoDeallocateMemory(lldb::addr_t ptr) {
 1879     Status error;
 1897   Status DeallocateMemory(lldb::addr_t ptr);
 1926   virtual size_t GetSTDOUT(char *buf, size_t buf_size, Status &error);
 1955   virtual size_t GetSTDERR(char *buf, size_t buf_size, Status &error);
 1975   virtual size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) {
 1993   virtual size_t GetAsyncProfileData(char *buf, size_t buf_size, Status &error);
 1998   virtual Status EnableBreakpointSite(BreakpointSite *bp_site) {
 1999     Status error;
 2006   virtual Status DisableBreakpointSite(BreakpointSite *bp_site) {
 2007     Status error;
 2018   virtual Status EnableSoftwareBreakpoint(BreakpointSite *bp_site);
 2024   virtual Status DisableSoftwareBreakpoint(BreakpointSite *bp_site);
 2032   Status ClearBreakpointSiteByID(lldb::user_id_t break_id);
 2037   Status DisableBreakpointSiteByID(lldb::user_id_t break_id);
 2039   Status EnableBreakpointSiteByID(lldb::user_id_t break_id);
 2048   virtual Status EnableWatchpoint(Watchpoint *wp, bool notify = true);
 2050   virtual Status DisableWatchpoint(Watchpoint *wp, bool notify = true);
 2278   virtual Status SendEventData(const char *data) {
 2279     Status return_error("Sending an event is not supported for this process.");
 2326   virtual Status GetFileLoadAddress(const FileSpec &file, bool &is_loaded,
 2385   virtual Status
 2427                                      Status &error) {
 2438   virtual Status StopTrace(lldb::user_id_t uid, lldb::tid_t thread_id) {
 2447   virtual Status GetData(lldb::user_id_t uid, lldb::tid_t thread_id,
 2454   virtual Status GetMetaData(lldb::user_id_t uid, lldb::tid_t thread_id,
 2467   virtual Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) {
 2486   Status PrivateResume();
 2796   Status HaltPrivate();
 2812                             Status &error);
 2833   Status StopForDestroyOrDetach(lldb::EventSP &exit_event_sp);
 2835   virtual Status UpdateAutomaticSignalFiltering();

   73     Status error;

  126   virtual Status
  131   virtual Status

   26                            uint32_t mode, Status &error) override;
   28   bool CloseFile(lldb::user_id_t fd, Status &error) override;
   31                     uint64_t dst_len, Status &error) override;
   34                      uint64_t src_len, Status &error) override;
   38   Status CreateSymlink(const FileSpec &src, const FileSpec &dst) override;
   42   Status Unlink(const FileSpec &file_spec) override;
   48   Status MakeDirectory(const FileSpec &file_spec, uint32_t mode) override;
   50   Status GetFilePermissions(const FileSpec &file_spec,
   53   Status SetFilePermissions(const FileSpec &file_spec,
   59   Status GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid,
   67   Status RunShellCommand(const char *command, const FileSpec &working_dir,
   85                                  Status &error) override;
   87   Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
   89   Status KillProcess(const lldb::pid_t pid) override;

  187   bool GetFrameBaseValue(Scalar &value, Status *error_ptr);
  199   DWARFExpression *GetFrameBaseExpression(Status *error_ptr);
  290       uint32_t options, lldb::VariableSP &var_sp, Status &error);
  518   Status m_frame_base_error;

  115   virtual Status GetDescription(const StructuredData::ObjectSP &object_sp,

  532                                    Status *error_ptr = nullptr);
  568   Status Launch(ProcessLaunchInfo &launch_info,
  571   Status Attach(ProcessAttachInfo &attach_info,
  646                             Status *additional_args_error = nullptr);
  652       Status *creation_error = nullptr);
  684                                       Status &error);
  693   void AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error);
  696                            Status &error);
  701                                      Status &error);
  758   Status SerializeBreakpointsToFile(const FileSpec &file,
  762   Status CreateBreakpointsFromFile(const FileSpec &file,
  765   Status CreateBreakpointsFromFile(const FileSpec &file,
  870   bool LoadScriptingResources(std::list<Status> &errors,
  972                                  Status &error);
  985                     size_t dst_len, Status &error,
  989                                Status &error);
  992                                size_t dst_max_len, Status &result_error);
  997                                      Status &error);
 1002                                          uint64_t fail_value, Status &error);
 1005                              Status &error, Address &pointer_addr);
 1045                                ValueObject *ctx_obj, Status &error);
 1059                                                const char *name, Status &error);
 1068                                                  Status &error);
 1076   Status Install(ProcessLaunchInfo *launch_info);
 1252   lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language,

   83   Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path,
   93   Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path,
  193   Status CreateDummyTarget(Debugger &debugger,
  197   Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
  203   Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,

  410   Status ReturnFromFrameWithIndex(uint32_t frame_idx,
  414   Status ReturnFromFrame(lldb::StackFrameSP frame_sp,
  418   Status JumpToLine(const FileSpec &file, uint32_t line,
  496   virtual Status
  512   virtual Status StepOver(
  523   virtual Status StepOut();
  620       Status &status);
  663       Status &status,
  672       Status &status,
  725       lldb::RunMode stop_other_threads, Status &status,
  735       lldb::RunMode stop_other_threads, Status &status,
  780       uint32_t frame_idx, Status &status,
  842       uint32_t frame_idx, Status &status, bool continue_to_next_branch = false);
  869                                 Status &status);
  894                                  bool stop_other_threads, Status &status);
  898       bool stop_others, uint32_t frame_idx, Status &status);
  903                                  bool stop_other_threads, Status &status);
  919   Status UnwindInnermostExpression();
  984   Status QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans);

  584   Status m_status;
  637   const Status &GetStatus() { return m_status; }

   98                                     Status &status);
  102                                      Status &status);
  112                                             Status &status, void *baton);
  116                               lldb::FrameComparison operation, Status &status,
  121                            Status &status);

   56                                             Status &status, void *baton);
   78       Status &status, LazyBool avoid_code_without_debug_info);
   82       lldb::RunMode stop_others, Status &status,

   42       Status &status);

   79       Status &status, LazyBool step_out_avoids_code_without_debug_info);

   45                                         bool stop_others, Status &status);

   57       bool stop_others, uint32_t frame_idx, Status &status);

   39                            Status &error);

   68                                          Status *error_ptr) = 0;
   83   virtual lldb::ConnectionStatus Disconnect(Status *error_ptr) = 0;
  120                       lldb::ConnectionStatus &status, Status *error_ptr) = 0;
  143                        lldb::ConnectionStatus &status, Status *error_ptr) = 0;

   35   virtual Status Read(void *buf, size_t &num_bytes) = 0;
   36   virtual Status Write(const void *buf, size_t &num_bytes) = 0;
   38   virtual Status Close() = 0;

  141               const char *format, Args &&... args) {
  142     Format(file, function, llvm::formatv(format, std::forward<Args>(args)...));

   99                            Status &error) const;
  103                              Status &error);
  235   Status SetValueFromString(const RegisterInfo *reg_info,
  237   Status SetValueFromString(const RegisterInfo *reg_info,
  240   Status SetValueFromData(const RegisterInfo *reg_info, DataExtractor &data,

  125                          lldb::ByteOrder dst_byte_order, Status &error) const;
  234   Status SetValueFromCString(const char *s, lldb::Encoding encoding,
  237   Status SetValueFromData(DataExtractor &data, lldb::Encoding encoding,

   50   lldb_private::Status Select();

   67   const Status &operator=(const Status &rhs);
   67   const Status &operator=(const Status &rhs);
   73   const Status &operator=(llvm::Error error);
  175   void SetErrorStringWithFormatv(const char *format, Args &&... args) {
  210   static void format(const lldb_private::Status &error, llvm::raw_ostream &OS,

  194   lldb_private::Status GetStatus();

  551   static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);

   48                                    const FileSpec &outfile, Status &error);
   63 typedef Status (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info,
   89     Status &status, void *baton);
   92     Status &status, void *baton);
  101 typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,

   29     const lldb::DebuggerSP &debugger_sp, const FileSpec &spec, Status &error);

  611     Status error;
  640     Status error =
  660     Status error; // Think I'm just going to swallow the error here, it's

  227     Status error;
  258     Status error =

  104   Status error;
  594   Status error;
  621   Status error =

   63                                             Status &error) {
  767     Status error(m_opaque_sp->GetTargetList().CreateTarget(
  794     Status error;
  824     Status error;
 1241   Status error;
 1266   Status error;

  105 void SBError::SetError(const Status &lldb_error) {
  152     m_opaque_up.reset(new Status());
  155 lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); }
  157 lldb_private::Status *SBError::get() { return m_opaque_up.get(); }
  159 lldb_private::Status &SBError::ref() {
  164 const lldb_private::Status &SBError::operator*() const {

   50     Status status = m_opaque_sp->Read(buf, num_bytes);
   67     Status status = m_opaque_sp->Write(buf, num_bytes);
   80     Status status = m_opaque_sp->Flush();
   95     Status status = m_opaque_sp->Close();

  486         Status error;

  133   Status error;
  147   Status error;
  168   Status error;

   42   Status error = ModuleList::GetSharedModule(

  271   Status error;
  550     const std::function<Status(const lldb::PlatformSP &)> &func) {

  265     Status error;
  279     Status error;
  293     Status error;
  307     Status error;

  104   Status error = m_impl_up->GetDescription(stream.ref());

   78 Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
 1104     Status error;
 1425     Status cw_error;
 2040       lldb_private::Status error;

  611   Status new_plan_status;
  664   Status new_plan_status;
  719   Status new_plan_status;
  766   Status new_plan_status;
  797   Status new_plan_status;
  833   Status new_plan_status;
  944       Status new_plan_status;
 1001   Status new_plan_status;
 1039   Status err = thread->JumpToLine(file_spec.get(), line, true);

  232     Status plan_status;
  277     Status plan_status;
  316     Status plan_status;
  352     Status plan_status;
  385     Status plan_status;
  410     Status plan_status;

  110                             Status &error) {
  210   Status &GetError() { return m_lock_error; }
  215   Status m_lock_error;
 1024     Status error;
 1314     Status error;
 1409     Status error;
 1433       Status set_error;
 1501     Status rc;

   17 template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) {
   17 template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) {
   19     return std::make_unique<T>(*src);

  123     Target &target, StructuredData::ObjectSP &object_data, Status &error) {
  142   Status create_error;
  204       Status error;

   95 bool BreakpointID::StringIsBreakpointName(llvm::StringRef str, Status &error) {

  134     Status error;
  300     Status error;

  133   Status error;

  230                                            Status &error) {
  291   Status expr_error;

   61     const StructuredData::Dictionary &options_dict, Status &error) {
  238     Status &error) {
  302     Status cmds_error;
  332       Status script_error;
  347     Status thread_spec_error;

   22 Status BreakpointPrecondition::ConfigurePrecondition(Args &args) {
   23   Status error;

   71     const StructuredData::Dictionary &resolver_dict, Status &error) {

   40     Status &error) {

   35     Status &error) {

   33     Status &error) {

   95     Status &error) {

   66     Status &error) {

  288     Status error;

  200       auto error = fs.ResolveSymbolicLink(symlink_filespec, resolved_filespec);

   64   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   66     Status error;
  156   Status OptionParsingFinished(ExecutionContext *execution_context) override {
  198   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  200     Status error;
  276     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  278       Status error;
  684       Status precond_error;
  700       Status error;
  723         Status name_error;
 1115     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1117       Status error;
 1248     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1250       Status error;
 1395     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1397       Status error;
 1521   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1523     Status error;
 1580   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1582     Status error;
 1688       Status error;
 1713     Status error;
 1800       Status error; // This error reports illegal names, but we've already 
 1933         Status error;
 2032     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 2034       Status error;
 2042         Status name_error;
 2083     Status error = target.CreateBreakpointsFromFile(input_spec,
 2150     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 2152       Status error;
 2204     Status error = target.SerializeBreakpointsToFile(file_spec, valid_bp_ids,

  287     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  289       Status error;
  421           Status error = script_interp->SetBreakpointCommandCallbackFunction(
  503     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  505       Status error;

   62     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   64       Status error;
  235     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  237       Status error;
  350     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
  352       Status error;
  965           Status error = AppendRegexSubstitution(line, check_only);
  990     Status error;
 1033   Status AppendRegexSubstitution(const llvm::StringRef &regex_sed,
 1035     Status error;
 1146     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1148       Status error;
 1240     Status error;
 1327     Status error;
 1400     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1402       Status error;
 1444       Status error;
 1534     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1536       Status error;

   46 Status CommandObjectDisassemble::CommandOptions::SetOptionValue(
   49   Status error;
  194 Status CommandObjectDisassemble::CommandOptions::OptionParsingFinished(

   28     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   45     Status OptionParsingFinished(ExecutionContext *execution_context) override;

   60 Status CommandObjectExpression::CommandOptions::SetOptionValue(
   63   Status error;
  347   Status error;
  357 static lldb_private::Status
  443           Status error(CanBeUsedForElementCountPrinting(*result_valobj_sp));
  611           Status repl_error;

   32     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

   67     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   69       Status error;
  244     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  246       Status error;
  585             Status error;
  746     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  748       Status error;

   39     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   41       Status error;

   93     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   95       Status error;

   64   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
   66     Status error;
  113   Status FinalizeSettings(Target *target, OptionGroupFormat &format_options) {
  114     Status error;
  372     Status error;
  726         Status error;
  916     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
  918       Status error;
 1012       Status error;
 1039     Status error;
 1204     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
 1206       Status error;
 1344     Status error;
 1365           Status error;
 1507         Status error;
 1575       Status error;
 1640     Status error;
 1696       Status error;

   70   lldb_private::Status
   73     Status error;
  174         Status error;
  295       Status error(platform_sp->ConnectRemote(args));
  345         Status error;
  457       Status error = platform_sp->MakeDirectory(FileSpec(cmd_line), mode);
  496       Status error;
  554       Status error;
  595       Status error;
  617     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  619       Status error;
  679       Status error;
  703     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  705       Status error;
  822       Status error = platform_sp->GetFile(FileSpec(remote_file_path),
  928       Status error(platform_sp->PutFile(src_fs, dst_fs));
  969       Status error;
 1061       Status error;
 1160     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1162       Status error;
 1337         Status error;
 1397     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1399       Status error;
 1500       Status err;
 1567     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1569       Status error;
 1626     Status error;
 1704     Status error = platform_sp->Install(src, dst);

   58     Status error;

   73             Status detach_error(process->Detach(keep_stopped));
   84             Status destroy_error(process->Destroy(false));
  220     Status error = target->Launch(m_options.launch_info, &stream);
  273     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  275       Status error;
  395       Status error;
  425     const auto error = target->Attach(m_options.attach_info, &stream);
  521     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  523       Status error;
  603       Status error;
  661     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  663       Status error;
  724     Status error(process->Detach(keep_stopped));
  756     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  758       Status error;
  819     Status error;
  875     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  877       Status error;
  923       Status error;
  993         Status error(process->GetTarget().GetPlatform()->UnloadImage(
 1057         Status error(process->Signal(signo));
 1101       Status error(process->Halt(clear_thread_plans));
 1142       Status error(process->Destroy(true));
 1180         Status error = PluginManager::SaveCore(process_sp, output_file);
 1249     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1251       Status error;

  247     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
  249       Status error;
  353         Status error(reg_value.SetValueFromString(reg_info, value_str));

  179     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
  181       Status error;

   94     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   96       Status error;
  159       Status error;
  196       Status error(GetDebugger().SetPropertyValue(
  210     Status error;
  282         Status error(GetDebugger().DumpPropertyValue(
  340     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  342       Status error;
  403       Status error(GetDebugger().DumpPropertyValue(
  441     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  443       Status error;
  647     Status error(GetDebugger().SetPropertyValue(
  743     Status error(GetDebugger().SetPropertyValue(
  845     Status error(GetDebugger().SetPropertyValue(
  944     Status error(GetDebugger().SetPropertyValue(
 1034     Status error(GetDebugger().SetPropertyValue(
 1100     Status error(GetDebugger().SetPropertyValue(

   46     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
   48       Status error;
  646     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  648       Status error;

  169   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
  171     Status error;
  196   Status SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
  326       Status error(debugger.GetTargetList().CreateTarget(
  343                 Status err = platform_sp->PutFile(file_spec, remote_file);
  364                 Status err = platform_sp->GetFile(remote_file, file_spec);
  873           Status error(Variable::GetValuesForVariableExpressionPath(
 1967     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1969       Status error;
 2391     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 2562           Status error;
 2806                 Status error = process->WriteObjectFile(std::move(loadables));
 2904     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 2906       Status error;
 3259     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 3261       Status error;
 3583     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 3585       Status error;
 4155             Status error;
 4424     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 4426       Status error;

  256     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  258       Status error;
  419   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  421     Status error;
  638     Status new_plan_status;
  648           Status error;
  657           Status error;
  754       Status error;
  933       Status error;
 1000     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1002       Status error;
 1158       Status new_plan_status;
 1263       Status error;
 1405     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1408       Status error;
 1535     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1537       Status error;
 1615       Status error;
 1670     Status error;
 1709     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1712       Status error;
 1809       Status err = thread->JumpToLine(file, line, m_options.m_force, &warnings);
 1845     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1847       Status error;

  110     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  196                 Status error;
  264                          Status *error = nullptr);
  293     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  295       Status error;
  434                 Status error;
  490                        Status *error);
  519     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
  521       Status error;
  720     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  722       Status error;
  855     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  857       Status error;
  968     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  970       Status error;
 1175 Status CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(
 1178   Status error;
 1354   Status error;
 1429   Status error;
 1612                                              Status *error) {
 1719     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1721       Status error;
 1815     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1817       Status error;
 1982     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 1984       Status error;
 2293   Status error;
 2336                                          Status *error) {
 2389     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 2391       Status error;
 2461                  Status *error) {
 2592     Status error;
 2655     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
 2657       Status error;

  179     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  181       Status error;
  220       Status error = target->GetProcessSP()->GetWatchpointSupportInfo(
  525     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  527       Status error;
  645     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  647       Status error;
  833     Status error;
  847       Status error(Variable::GetValuesForVariableExpressionPath(
 1057     Status error;

  320     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  322       Status error;

   67     Status error;
  340     Status error;
  748         Status memory_error;

   78 ConnectionStatus Communication::Connect(const char *url, Status *error_ptr) {
   92 ConnectionStatus Communication::Disconnect(Status *error_ptr) {
  172                             ConnectionStatus &status, Status *error_ptr) {
  190 bool Communication::StartReadThread(Status *error_ptr) {
  226 bool Communication::StopReadThread(Status *error_ptr) {
  239   Status error = m_read_thread.Join(nullptr);
  243 bool Communication::JoinReadThread(Status *error_ptr) {
  247   Status error = m_read_thread.Join(nullptr);
  315   Status error;

  254 Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
  275   Status error(Properties::SetPropertyValue(exe_ctx, op, property_path, value));
  297         std::list<Status> errors;
  301           for (auto error : errors) {
  538 bool Debugger::LoadPlugin(const FileSpec &spec, Status &error) {
  558   Status error;
  583     Status plugin_load_error;
 1272     Status error;
 1337           Status error =
 1590 Status Debugger::RunREPL(LanguageType language, const char *repl_options) {
 1591   Status err;

  359       Status error;
 1130       Status error;
 1191     Status error;
 1236   Status error;

  181     Status error = m_process->GetFileLoadAddress(file, is_loaded, load_addr);
  192     Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
  222   Status error;
  232   Status error;

  259     Status error;
  276     Status error;

  294 Status FormatEntity::Parse(const llvm::StringRef &format_str, Entry &entry) {
  401       Status error;
  767     Status error;
  811     Status error;
 1060     Status error = FormatEntity::Parse(format_str, root);
 1077     Status error = FormatEntity::Parse(format_str, root);
 1873 static Status ParseEntry(const llvm::StringRef &format_str,
 1876   Status error;
 1962   Status error;
 1989 Status FormatEntity::ParseInternal(llvm::StringRef &format, Entry &parent_entry,
 1991   Status error;
 2278 Status FormatEntity::ExtractVariableInfo(llvm::StringRef &format_str,
 2281   Status error;

  377       Status error = m_input_sp->Read((void *)buffer, bytes_read);
  516     Status error;

  287                                         lldb::addr_t header_addr, Status &error,
  296       Status readmem_error;
 1462 bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,

  712 Status ModuleList::GetSharedModule(const ModuleSpec &module_spec,
  722   Status error;
  966                                                 std::list<Status> &errors,
  973     Status error;

   96   Status error;
 1132 Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
 1134   Status error;

   79     Status &error) {
  362     Status &error) {
  476     Status &error) {
  627     Status &error) {
  689     Status &error) {

   36                              Status &error) const {
   43 Status Properties::SetPropertyValue(const ExecutionContext *exe_ctx,
   50   Status error;
   71 Status Properties::DumpPropertyValue(const ExecutionContext *exe_ctx,
   80   Status error;

  148   Status error;
  211 uint64_t Value::GetValueByteSize(Status *error_ptr, ExecutionContext *exe_ctx) {
  316 Status Value::GetValueAsData(ExecutionContext *exe_ctx, DataExtractor &data,
  320   Status error;
  599       Status error(GetValueAsData(exe_ctx, data, nullptr));

  365 const Status &ValueObject::GetError() {
  441 bool ValueObject::IsLogicalTrue(Status &error) {
  786       Status error;
  795       Status error;
  801     Status error;
  863 uint64_t ValueObject::GetData(DataExtractor &data, Status &error) {
  881 bool ValueObject::SetData(DataExtractor &data, Status &error) {
  899     Status set_error =
  954 ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
 1295         Status error;
 1571 bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
 2195       Status error;
 2212       Status error;
 2562             Status error;
 2707           Status error;
 2824 ValueObjectSP ValueObject::Dereference(Status &error) {
 2889 ValueObjectSP ValueObject::AddressOf(Status &error) {
 3172         Status err;

  165                                              const Status &error) {
  170                                                const Status &error)
  238 lldb::ValueObjectSP ValueObjectConstResult::Dereference(Status &error) {
  249 lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Status &error) {

   32 lldb::ValueObjectSP ValueObjectConstResultCast::Dereference(Status &error) {
   43 lldb::ValueObjectSP ValueObjectConstResultCast::AddressOf(Status &error) {

   39 lldb::ValueObjectSP ValueObjectConstResultChild::Dereference(Status &error) {
   50 lldb::ValueObjectSP ValueObjectConstResultChild::AddressOf(Status &error) {

   41 lldb::ValueObjectSP ValueObjectConstResultImpl::Dereference(Status &error) {
  116 lldb::ValueObjectSP ValueObjectConstResultImpl::AddressOf(Status &error) {

  275                                                   Status &error) {
  308 bool ValueObjectDynamicValue::SetData(DataExtractor &data, Status &error) {

  326                                               Status &error) {
  340 bool ValueObjectRegister::SetData(DataExtractor &data, Status &error) {

  135       Status error;
  335                                                Status &error) {

  275                                               Status &error) {
  304 bool ValueObjectVariable::SetData(DataExtractor &data, Status &error) {

  419   Status my_error;
  563   Status error;

   54         Status error;
   80               Status error;
   90           Status error;
  184   Status error;

  163                                       uint32_t reg_num, Status *error_ptr,
  722                                        Status *error_ptr, Log *log) {
  931                                Status *error_ptr) const {
  942                                Status *error_ptr) const {
 1018     Value &result, Status *error_ptr) {
 1172             Status error;
 1274             Status error;
 2186           Status error;

   81   Status jit_error(m_parser->PrepareForExecution(
  135   Status error;
  172   Status value_error;
  288   Status error;

   53                                        Status &error) {
   65     Status err;
   74     Status err;
   93   Status err;
   98 Status IRExecutionUnit::DisassembleFunction(Stream &stream,
  104   Status ret;
  154   Status err;
  205   Status *err = static_cast<Status *>(Context);
  218 void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
  439     Status err = DisassembleFunction(disassembly_stream, process_sp);
  454         Status err;
  607     Status err;
  638     Status err;
 1099                                           Status &error,
 1143   lldb_private::Status err;
 1187       lldb_private::Status err;

  181       lldb_private::Status extract_error;
  215     lldb_private::Status get_data_error;
  221     lldb_private::Status write_error;
  314     lldb_private::Status write_error;
  319       lldb_private::Status free_error;
  349     lldb_private::Status get_data_error;
  357     lldb_private::Status write_error;
  379     lldb_private::Status alloc_error;
  390     lldb_private::Status read_error;
  421         lldb_private::Status free_error;
  487                                  lldb_private::Status &error,
  641                               lldb_private::Status &error,
  854       lldb_private::Status write_error;
  862         lldb_private::Status free_error;
 1314       lldb_private::Status read_error;
 1337       lldb_private::Status write_error;
 1402       lldb_private::Status read_error;
 1425       lldb_private::Status write_error;

   33     Status err;
   68     Status alloc_error;
  106     Status err = process_sp->GetMemoryRegionInfo(ret, region_info);
  290                                  bool zero_memory, Status &error) {
  397     Status write_error;
  430 void IRMemoryMap::Leak(lldb::addr_t process_address, Status &error) {
  446 void IRMemoryMap::Free(lldb::addr_t process_address, Status &error) {
  515                               Status &error) {
  591                                       Status &error) {
  616                                        lldb::addr_t address, Status &error) {
  625                              size_t size, Status &error) {
  722                                        size_t size, Status &error) {
  765                                         Status &error) {
  782                                 Status &error) {

   99       Status interpreter_error;
  260   Status dematerialize_error;
  299       Status alloc_error;
  325       Status alloc_error;
  347     Status materialize_error;

   60   void MakeAllocation(IRMemoryMap &map, Status &err) {
   66     Status allocate_error;
   98       Status leak_error;
  106     Status write_error;
  120   void DestroyAllocation(IRMemoryMap &map, Status &err) {
  121     Status deallocate_error;
  139                    lldb::addr_t process_address, Status &err) override {
  168       Status write_error;
  191                      lldb::addr_t frame_bottom, Status &err) override {
  221         Status read_error;
  288         Status read_error;
  337     Status err;
  400     PersistentVariableDelegate *delegate, Status &err) {
  423                    lldb::addr_t process_address, Status &err) override {
  449     Status valobj_error = valobj_sp->GetError();
  460       Status extract_error;
  473       Status write_error;
  489         Status write_error;
  500         Status extract_error;
  543         Status alloc_error;
  563         Status write_error;
  575         Status pointer_write_error;
  592                      lldb::addr_t frame_bottom, Status &err) override {
  621       Status extract_error;
  642       Status set_error;
  655       Status free_error;
  679     Status err;
  736       Status free_error;
  753 uint32_t Materializer::AddVariable(lldb::VariableSP &variable_sp, Status &err) {
  777                    lldb::addr_t process_address, Status &err) override {
  803       Status alloc_error;
  819       Status pointer_write_error;
  834                      lldb::addr_t frame_bottom, Status &err) override {
  846     Status read_error;
  934         Status free_error;
  953     Status err;
 1010       Status free_error;
 1033                                          Status &err) {
 1051                    lldb::addr_t process_address, Status &err) override {
 1084     Status pointer_write_error;
 1098                      lldb::addr_t frame_bottom, Status &err) override {
 1117     Status err;
 1150 uint32_t Materializer::AddSymbol(const Symbol &symbol_sp, Status &err) {
 1168                    lldb::addr_t process_address, Status &err) override {
 1216     Status write_error;
 1231                      lldb::addr_t frame_bottom, Status &err) override {
 1243     Status extract_error;
 1292     Status err;
 1327                                    Status &err) {
 1347                           lldb::addr_t process_address, Status &error) {
 1391 void Materializer::Dematerializer::Dematerialize(Status &error,

   35 lldb::REPLSP REPL::Create(Status &err, lldb::LanguageType language,
  291       Status error;
  509 Status REPL::RunLoop() {
  510   Status error;

  105                                               Status &err) {
  144     lldb::ValueObjectSP &result_valobj_sp, Status &error,

   63     lldb::ThreadSP thread_to_use_sp, Status &error) {

  100 Status File::Read(void *buf, size_t &num_bytes) {
  103 Status File::Write(const void *buf, size_t &num_bytes) {
  109 Status File::Close() { return Flush(); }
  115 Status File::GetFileSpec(FileSpec &file_spec) const {
  124 off_t File::SeekFromStart(off_t offset, Status *error_ptr) {
  130 off_t File::SeekFromCurrent(off_t offset, Status *error_ptr) {
  136 off_t File::SeekFromEnd(off_t offset, Status *error_ptr) {
  142 Status File::Read(void *dst, size_t &num_bytes, off_t &offset) {
  146 Status File::Write(const void *src, size_t &num_bytes, off_t &offset) {
  150 Status File::Flush() { return Status(); }
  152 Status File::Sync() { return Flush(); }
  234 uint32_t File::GetPermissions(Status &error) const {
  307 Status NativeFile::Close() {
  308   Status error;
  332 Status NativeFile::GetFileSpec(FileSpec &file_spec) const {
  333   Status error;
  368 off_t NativeFile::SeekFromStart(off_t offset, Status *error_ptr) {
  394 off_t NativeFile::SeekFromCurrent(off_t offset, Status *error_ptr) {
  420 off_t NativeFile::SeekFromEnd(off_t offset, Status *error_ptr) {
  446 Status NativeFile::Flush() {
  447   Status error;
  457 Status NativeFile::Sync() {
  458   Status error;
  480 Status NativeFile::Read(void *buf, size_t &num_bytes) {
  481   Status error;
  539 Status NativeFile::Write(const void *buf, size_t &num_bytes) {
  540   Status error;
  601 Status NativeFile::Read(void *buf, size_t &num_bytes, off_t &offset) {
  602   Status error;
  661 Status NativeFile::Write(const void *buf, size_t &num_bytes, off_t &offset) {
  662   Status error;

   28                                     Status &error) {
   43 bool FileCache::CloseFile(lldb::user_id_t fd, Status &error) {
   65                               Status &error) {
   91                              uint64_t dst_len, Status &error) {

  458 Status Host::RunShellCommand(const char *command, const FileSpec &working_dir,
  469 Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
  475   Status error;
  582 Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
  591   Status error;

   23 Status HostProcess::Terminate() { return m_native_process->Terminate(); }
   25 Status HostProcess::GetMainModule(FileSpec &file_spec) const {

   20 Status HostThread::Join(lldb::thread_result_t *result) {
   24 Status HostThread::Cancel() { return m_native_thread->Cancel(); }

   16 Status AlreadyLocked() { return Status("Already locked"); }
   18 Status NotLocked() { return Status("Not locked"); }
   26 Status LockFileBase::WriteLock(const uint64_t start, const uint64_t len) {
   32 Status LockFileBase::TryWriteLock(const uint64_t start, const uint64_t len) {
   38 Status LockFileBase::ReadLock(const uint64_t start, const uint64_t len) {
   44 Status LockFileBase::TryReadLock(const uint64_t start, const uint64_t len) {
   50 Status LockFileBase::Unlock() {
   54   const auto error = DoUnlock();
   65 Status LockFileBase::DoLock(const Locker &locker, const uint64_t start,
   73   const auto error = locker(start, len);

   76   Status Poll();
  198 Status MainLoop::RunImpl::Poll() {
  273                                                     Status &error) {
  299 MainLoop::RegisterSignal(int signo, const Callback &callback, Status &error) {
  380 Status MainLoop::Run() {
  383   Status error;

   26                                          Status &error) {

   34 lldb_private::Status NativeProcessProtocol::Interrupt() {
   35   Status error;
   44 Status NativeProcessProtocol::IgnoreSignals(llvm::ArrayRef<int> signals) {
   50 lldb_private::Status
  135 Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
  164     Status thread_error =
  183         Status remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
  195 Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
  199   Status overall_error;
  205     const Status thread_error = thread->RemoveWatchpoint(addr);
  214   const Status error = m_watchpoint_list.Remove(addr);
  223 Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
  251     Status thread_error = thread->SetHardwareBreakpoint(addr, size);
  261         Status remove_error =
  280 Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
  284   Status error;
  359 Status NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
  377 Status NativeProcessProtocol::RemoveSoftwareBreakpoint(lldb::addr_t addr) {
  388   Status error;
  453   Status error = ReadMemory(addr, saved_opcode_bytes.data(),
  585   Status error;
  631 Status NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
  639 Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
  642   Status error = ReadMemory(addr, buf, size, bytes_read);
  679   Status status;

  135 Status NativeRegisterContext::SetPC(lldb::addr_t pc) {
  147 Status NativeRegisterContext::SetSP(lldb::addr_t sp) {
  159 Status NativeRegisterContext::SetFP(lldb::addr_t fp) {
  192     Status error = ReadRegister(reg_info, value);
  211 Status NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg,
  218 Status
  243 Status NativeRegisterContext::ClearAllHardwareBreakpoints() {
  251 Status NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index,
  269 Status NativeRegisterContext::ClearAllHardwareWatchpoints() {
  273 Status NativeRegisterContext::IsWatchpointHit(uint32_t wp_index, bool &is_hit) {
  278 Status NativeRegisterContext::GetWatchpointHitIndex(uint32_t &wp_index,
  284 Status NativeRegisterContext::IsWatchpointVacant(uint32_t wp_index,
  300 Status NativeRegisterContext::ReadRegisterValueFromMemory(
  303   Status error;
  370 Status NativeRegisterContext::WriteRegisterValueToMemory(
  376   Status error;

   16 Status NativeWatchpointList::Add(addr_t addr, size_t size, uint32_t watch_flags,
   22 Status NativeWatchpointList::Remove(addr_t addr) {

   15 Status PipeBase::OpenAsWriter(llvm::StringRef name,
   21 Status PipeBase::Read(void *buf, size_t size, size_t &bytes_read) {

  245     Status &error, bool localhost, bool will_debug,

  111                                        Status &error) {
  150 Status Socket::TcpConnect(llvm::StringRef host_and_port,
  156   Status error;
  169 Status Socket::TcpListen(llvm::StringRef host_and_port,
  175   Status error;
  208 Status Socket::UdpConnect(llvm::StringRef host_and_port,
  217 Status Socket::UnixDomainConnect(llvm::StringRef name,
  220   Status error;
  233 Status Socket::UnixDomainAccept(llvm::StringRef name,
  235   Status error;
  249 Status Socket::UnixAbstractConnect(llvm::StringRef name,
  252   Status error;
  264 Status Socket::UnixAbstractAccept(llvm::StringRef name,
  267   Status error;
  283                                int32_t &port, Status *error_ptr) {
  329 Status Socket::Read(void *buf, size_t &num_bytes) {
  330   Status error;
  356 Status Socket::Write(const void *buf, size_t &num_bytes) {
  358   Status error;
  384 Status Socket::PreDisconnect() {
  385   Status error;
  389 Status Socket::Close() {
  390   Status error;
  431 void Socket::SetLastError(Status &error) {
  441                                   bool child_processes_inherit, Status &error) {
  457                                   bool child_processes_inherit, Status &error) {

  129 Status TCPSocket::CreateSocket(int domain) {
  130   Status error;
  140 Status TCPSocket::Connect(llvm::StringRef name) {
  145   Status error;
  177 Status TCPSocket::Listen(llvm::StringRef name, int backlog) {
  181   Status error;
  242 Status TCPSocket::Accept(Socket *&conn_socket) {
  243   Status error;

   44 Status UDPSocket::Connect(llvm::StringRef name) {
   48 Status UDPSocket::Listen(llvm::StringRef name, int backlog) {
   52 Status UDPSocket::Accept(Socket *&socket) {
   56 Status UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
   63   Status error;

  309 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {

  121   Status result = m_pipe.CreateNew(m_child_processes_inherit);
  150                                                    Status *error_ptr) {
  290   Status result = m_pipe.Write("i", 1, bytes_written);
  294 ConnectionStatus ConnectionFileDescriptor::Disconnect(Status *error_ptr) {
  321       Status result = m_pipe.Write("q", 1, bytes_written);
  339   Status error = m_read_sp->Close();
  340   Status error2 = m_write_sp->Close();
  384   Status error;
  465                                        Status *error_ptr) {
  487   Status error;
  583       Status error = select_helper.Select();
  644                                             Status *error_ptr) {
  646   Status error =
  661                                              Status *error_ptr) {
  663   Status error =
  678                                                     Status *error_ptr) {
  680   Status error = Socket::UnixAbstractConnect(socket_name,
  695                                                 Status *error_ptr) {
  700   Status error = Socket::TcpListen(s, m_child_processes_inherit, socket,
  723                                                       Status *error_ptr) {
  725   Status error = Socket::TcpConnect(s, m_child_processes_inherit, socket);
  738                                                       Status *error_ptr) {
  740   Status error = Socket::UdpConnect(s, m_child_processes_inherit, socket);

   75 Status DomainSocket::Connect(llvm::StringRef name) {
   81   Status error;
   92 Status DomainSocket::Listen(llvm::StringRef name, int backlog) {
  100   Status error;
  113 Status DomainSocket::Accept(Socket *&socket) {
  114   Status error;

   36 Status FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
   37   Status error;
   43 Status FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   44   Status error;
   56 Status FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   64     Status err;

   33 Status HostProcessPosix::Signal(int signo) const {
   35     Status error;
   43 Status HostProcessPosix::Signal(lldb::process_t process, int signo) {
   44   Status error;
   52 Status HostProcessPosix::Terminate() { return Signal(SIGKILL); }
   54 Status HostProcessPosix::GetMainModule(FileSpec &file_spec) const {
   55   Status error;
   86   Status error = Signal(0);

   25 Status HostThreadPosix::Join(lldb::thread_result_t *result) {
   26   Status error;
   40 Status HostThreadPosix::Cancel() {
   41   Status error;
   53 Status HostThreadPosix::Detach() {
   54   Status error;

   21 Status fileLock(int fd, int cmd, int lock_type, const uint64_t start,
   31   Status error;
   44 Status LockFilePosix::DoWriteLock(const uint64_t start, const uint64_t len) {
   48 Status LockFilePosix::DoTryWriteLock(const uint64_t start, const uint64_t len) {
   52 Status LockFilePosix::DoReadLock(const uint64_t start, const uint64_t len) {
   56 Status LockFilePosix::DoTryReadLock(const uint64_t start, const uint64_t len) {
   60 Status LockFilePosix::DoUnlock() {

   86 Status PipePosix::CreateNew(bool child_processes_inherit) {
   90   Status error;
  115 Status PipePosix::CreateNew(llvm::StringRef name, bool child_process_inherit) {
  119   Status error;
  126 Status PipePosix::CreateWithUniqueName(llvm::StringRef prefix,
  139   Status error;
  151 Status PipePosix::OpenAsReader(llvm::StringRef name,
  160   Status error;
  170 Status
  230 Status PipePosix::Delete(llvm::StringRef name) {
  256 Status PipePosix::ReadWithTimeout(void *buf, size_t size,
  269   Status error;
  290 Status PipePosix::Write(const void *buf, size_t size, size_t &bytes_written) {
  300   Status error;

  180                                         Status &error) {

 1436 Status CommandInterpreter::PreprocessCommand(std::string &command) {
 1443   Status error; // Status for any expressions that might not evaluate
 1678   Status error(PreprocessCommand(command_string));

  101     Status error;
  331   Status error(group_options.NotifyOptionParsingFinished(&exe_ctx));

  108 void CommandReturnObject::SetError(const Status &error,

   49                                       int32_t fail_value, Status &error) {
   78 Status OptionArgParser::ToFormat(const char *s, lldb::Format &format,
   81   Status error;
  143                                         Status *error_ptr) {
  222         Status error;

   36 Status
   40   Status error;

   38 Status OptionGroupBoolean::SetOptionValue(uint32_t option_idx,
   41   Status error;

   36 Status OptionGroupFile::SetOptionValue(uint32_t option_idx,
   39   Status error(m_file.SetValueFromString(option_arg));
   67 Status
   71   Status error(m_file_list.SetValueFromString(option_value));

   55 Status OptionGroupFormat::SetOptionValue(uint32_t option_idx,
   58   Status error;

   36 Status
   40   Status error;

   20     Status &error, ArchSpec &platform_arch) const {
   86 Status
   90   Status error;

   86 Status OptionGroupPythonClassWithDict::SetOptionValue(
   90   Status error;
  132 Status OptionGroupPythonClassWithDict::OptionParsingFinished(
  134   Status error;

   37 Status OptionGroupString::SetOptionValue(uint32_t option_idx,
   40   Status error(m_value.SetValueFromString(option_arg));

   37 Status OptionGroupUInt64::SetOptionValue(uint32_t option_idx,
   40   Status error(m_value.SetValueFromString(option_arg));

   29 Status OptionGroupUUID::SetOptionValue(uint32_t option_idx,
   32   Status error;

   72 Status OptionGroupValueObjectDisplay::SetOptionValue(
   75   Status error;

   53 static Status ValidateNamedSummary(const char *str, void *) {
   63 static Status ValidateSummaryString(const char *str, void *) {
   75 Status
   79   Status error;

   81 Status
   85   Status error;

   37 Status OptionValue::SetSubValue(const ExecutionContext *exe_ctx,
   40   Status error;
  502     const char *value_cstr, uint32_t type_mask, Status &error) {
  571 Status OptionValue::SetValueFromString(llvm::StringRef value,
  573   Status error;

   36 Status OptionValueArch::SetValueFromString(llvm::StringRef value,
   38   Status error;

   78 Status OptionValueArray::SetValueFromString(llvm::StringRef value,
   81   Status error = SetArgs(args, op);
   90                               Status &error) const {
  158 Status OptionValueArray::SetArgs(const Args &args, VarSetOperationType op) {
  159   Status error;

   33 Status OptionValueBoolean::SetValueFromString(llvm::StringRef value_str,
   35   Status error;

   34 Status OptionValueChar::SetValueFromString(llvm::StringRef value,
   36   Status error;

   96 Status OptionValueDictionary::SetArgs(const Args &args,
   98   Status error;
  202 Status OptionValueDictionary::SetValueFromString(llvm::StringRef value,
  205   Status error = SetArgs(args, op);
  214                                    Status &error) const {
  262 Status OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx,
  266   Status error;

   43 Status OptionValueEnumeration::SetValueFromString(llvm::StringRef value,
   45   Status error;

   55 Status OptionValueFileSpec::SetValueFromString(llvm::StringRef value,
   57   Status error;

   45 Status OptionValueFileSpecList::SetValueFromString(llvm::StringRef value,
   48   Status error;

   29 Status OptionValueFormat::SetValueFromString(llvm::StringRef value,
   31   Status error;

   23     Status error = FormatEntity::Parse(default_format_str, m_default_entry);
   66 Status OptionValueFormatEntity::SetValueFromString(llvm::StringRef value_str,
   68   Status error;

   32 Status OptionValueLanguage::SetValueFromString(llvm::StringRef value,
   34   Status error;

   39 Status OptionValuePathMappings::SetValueFromString(llvm::StringRef value,
   41   Status error;

  113                                    Status &error) const {
  194 Status OptionValueProperties::SetSubValue(const ExecutionContext *exe_ctx,
  198   Status error;
  527 Status OptionValueProperties::SetValueFromString(llvm::StringRef value,
  529   Status error;
  568 Status OptionValueProperties::DumpPropertyValue(const ExecutionContext *exe_ctx,
  572   Status error;

   30 Status OptionValueRegex::SetValueFromString(llvm::StringRef value,
   32   Status error;

   33 Status OptionValueSInt64::SetValueFromString(llvm::StringRef value_ref,
   35   Status error;

   45 Status OptionValueString::SetValueFromString(llvm::StringRef value,
   47   Status error;
  125 Status OptionValueString::SetCurrentValue(llvm::StringRef value) {
  127     Status error(m_validator(value.str().c_str(), m_validator_baton));
  135 Status OptionValueString::AppendToCurrentValue(const char *value) {
  140       Status error(m_validator(value, m_validator_baton));

   19                                               Status &error) {
   38 Status OptionValueUInt64::SetValueFromString(llvm::StringRef value_ref,
   40   Status error;

   30 Status OptionValueUUID::SetValueFromString(llvm::StringRef value,
   32   Status error;

   38 Status
  845 Status OptionGroupOptions::SetOptionValue(uint32_t option_idx,
  851   Status error;
  875 Status
  878   Status error;
 1292   Status error;

   72 Status ScriptInterpreter::SetBreakpointCommandCallback(
   75   Status return_error;
   84 Status ScriptInterpreter::SetBreakpointCommandCallbackFunction(
   88   Status error;

 1530           Status error;
 1617                 Status error;
 1700 Status ABIMacOSX_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
 1702   Status error;
 1726     Status data_error;

   28   lldb_private::Status

 1838         Status error;
 1856 Status
 1859   Status error;
 1877     Status data_error;
 2120   Status error;
 2306                     Status error;
 2403             Status error;

   86   lldb_private::Status

  740   Status error;
  787   Status error;
  840 Status ABIMacOSX_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  842   Status error;
  866     Status data_error;

   29   lldb_private::Status

  217   Status error;
  309 Status ABISysV_arc::SetReturnValueObject(StackFrameSP &frame_sp,
  311   Status result;

   40   lldb_private::Status

 1509           Status error;
 1525   Status error;
 1812         Status error;
 1843 Status ABISysV_arm::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
 1845   Status error;
 1869     Status data_error;

   28   lldb_private::Status

 1810           Status error;
 1829 Status ABISysV_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
 1831   Status error;
 1849     Status data_error;
 2097   Status error;
 2278                     Status error;
 2373           Status error;

   29   lldb_private::Status

 1067   Status error;
 1189 Status
 1192   Status error;

   37   lldb_private::Status

  229   Status error;
  272   Status error;
  324 Status ABISysV_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  326   Status error;
  342   Status data_error;
  655               Status error;
  683                 Status error;

   31   lldb_private::Status

  646   Status error;
  697 Status ABISysV_mips::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  699   Status error;
  723     Status data_error;

   29   lldb_private::Status

  606   Status error;
  658 Status ABISysV_mips64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  660   Status error;
  680   Status data_error;
  738   Status error;

   29   lldb_private::Status

  274   Status error;
  325     Status error;
  412 Status ABISysV_ppc::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  414   Status error;
  440     Status data_error;
  471         Status data_error;
  621               Status error;

   29   lldb_private::Status

  125   Status error;
  212     Status error;
  290 Status ABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  292   Status error;
  318     Status data_error;
  349         Status data_error;
  461       Status error;
  719     Status error;
  756       Status error;
  793         Status error;

   29   lldb_private::Status

  260       Status error;
  309     Status error;
  390 Status ABISysV_s390x::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  392   Status error;
  418     Status data_error;
  451         Status data_error;

   29   lldb_private::Status

  306   Status error;
  356     Status error;
  440 Status ABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
  442   Status error;
  468     Status data_error;
  502         Status data_error;
  663               Status error;
  691                 Status error;

   29   lldb_private::Status

 1148   Status error;
 1199   Status error;
 1273 Status ABIWindows_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
 1275   Status error;
 1301     Status data_error;
 1335         Status data_error;
 1496               Status error;

   29   lldb_private::Status

  245   Status read_err;
  396   Status error;
  515   Status error;
 1086     Status error;
 1370   Status error;
 1525 Status DynamicLoaderDarwinKernel::CanLoadImage() {
 1526   Status error;

   58   lldb_private::Status CanLoadImage() override;

  213 Status DynamicLoaderHexagonDYLD::CanLoadImage() { return Status(); }
  554   Status error;

   43   lldb_private::Status CanLoadImage() override;

   31   Status error;
  220   Status error;
  230   Status error;
  241   Status error;
  303   Status error;

  955           Status error;
 1050     Status error;

  275               Status error;
  397 Status DynamicLoaderMacOS::CanLoadImage() {
  398   Status error;

   55   lldb_private::Status CanLoadImage() override;

  193       Status error;
  448     Status error;
  660   Status error;
  761   Status error;
 1028 Status DynamicLoaderMacOSXDYLD::CanLoadImage() {
 1029   Status error;
 1063     Status err;
 1096           Status error;

   59   lldb_private::Status CanLoadImage() override;

   33   Status error;
  456   Status error;
  466   Status error;
  477   Status error;
  507     Status error =
  571   Status error;

  207 Status DynamicLoaderPOSIXDYLD::CanLoadImage() { return Status(); }
  510   Status status = m_process->GetMemoryRegionInfo(m_vdso_base, info);
  530   Status status = m_process->GetMemoryRegionInfo(m_interpreter_base, info);
  737   auto error = platform_sp->ResolveExecutable(

   49   lldb_private::Status CanLoadImage() override;

  124 Status DynamicLoaderStatic::CanLoadImage() {
  125   Status error;

   46   lldb_private::Status CanLoadImage() override;

   71     Status error;
  112   Status status =
  174 Status DynamicLoaderWindowsDYLD::CanLoadImage() { return Status(); }

   38   Status CanLoadImage() override;

  251     Status err;
  413     Status err;
  856         Status status;
  963         Status status;
 1489       Status error;
 1558   Status err;

 1165 lldb_private::Status ClangExpressionParser::PrepareForExecution(
 1173   lldb_private::Status err;
 1262       lldb_private::Status interpret_error;
 1348 lldb_private::Status ClangExpressionParser::RunStaticInitializers(
 1350   lldb_private::Status err;

  119   Status
  135   Status RunStaticInitializers(lldb::IRExecutionUnitSP &execution_unit_sp,

   92 void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
  513   Status err;
  632     Status jit_error = parser.PrepareForExecution(
  648     Status static_init_error =
  835     Status object_ptr_error;

  176                    lldb_private::Status &err) override;

  120   Status jit_error = parser.PrepareForExecution(

   51   Status error;

  825   Status error;
  971   Status error;

 1005       Status error;
 1281     Status error;
 1541     Status error;
 1624     Status error;

 1175     Status error;

  135   Status eval_error;
  172   Status error;

  100   Status read_error;

  258   Status error;
  326   Status eval_error;

  108   Status error;
  141   Status eval_error;

  125   Status error;
  291   Status error;

  133     Status err;

  159   Status error;
  185   Status error;
  211   Status error;
  237   Status error;

  125     Status error;
  263         Status error;

  283   Status error;
  305   Status err;
  402   Status error;
  419   Status err;

  257   Status error;
  362       Status error;
  403   Status error;

   81     Status error;
  150   Status error;

  209   Status err;

  204   Status err;
  246       Status error;
  306       Status error;
  412   Status error;

  107     Status error;

   89     Status error;
  149   Status error;
  276     Status error;

  210     Status error;
  256       Status error;
  473       Status error;
  622   Status error;
  824       Status error;
  832     Status error;
  970     Status error;
  977     Status error;
 1000     Status err;
 1075     Status error;

  185                       lldb::addr_t valobj_addr, Status &error) {
  199                  Status &error) {
  298                          Status &error) {
  384     Status error;
  392     Status error;
  402     Status error;
  408     Status error;
  413     Status error;
  419     Status error;
  431     Status error;
  518   Status error;
  664   Status error;
  711   Status error;
  810     Status error;

  313                            lldb::addr_t valobj_addr, Status &error) {
  327                Status &error) {
  384     Status error;
  394     Status error;
  448     Status error;
  538   Status error;
  587       Status error;
  687   Status error;
  766   Status error;
  831       Status error;
  934   Status error;
  989       Status error;

   44           Status error;
   69   Status error;
  150     Status error;

   53   Status error;

  176                     Status &error) {
  190                Status &error) {
  256     Status error;
  265     Status error;
  312     Status error;
  400   Status error;
  453       Status error;
  560   Status error;
  620       Status error;

  103   Status error;
  257       Status error;
  315   Status error;

  123   Status status;

  220   Status error;
  564   Status error;

   54   Status error;
   94   Status error;
  146   Status error;
  194   Status error;
  233   Status error;
  256   Status error;
  286   Status error;
  309   Status error;
  533       Status error;

  150     Status error;
  191     Status error;
  517     Status error;
  552     Status error;

  175   Status error;
  199   Status error;
  309           Status error;
  355       Status error;

  376                            const ModuleSP &module_sp, Status &error,
  521     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
  523       Status error;
  714           Status error;
  891   Status error;
  919     Status error;
  972     Status err;
 1065       Status err;
 1094       Status err;
 1206         Status error;
 1245       Status error;
 1275         Status error;
 1315   Status err;
 1334     Status error;
 1577   Status err;
 1598     Status error;
 2087   Status error;
 2155   Status error;
 2370     Status error;
 2458     Status error;
 2553         Status error;

  309   Status error;
  543     Status error;
  563   Status error;
  777         Status error;
  808       Status error;

  156       Status status;

  255         Status error;
  392 Status ObjCLanguageRuntime::ObjCExceptionPrecondition::ConfigurePrecondition(
  394   Status error;

  166     Status ConfigurePrecondition(Args &args) override;

  124   Status err;
  137     Status err;
  166   Status err;
  228   Status err;
  305   Status err;
  350   Status err;
 1156     Status err;
 1202     Status err;
 1294   Status err;
 1474   Status err;
 1698     Status err = expr_result->GetError();
 2061         Status err;
 2291         Status err;
 2382   Status err;
 2540   Status err;
 2692   Status err = file.get()->Write(&head, num_bytes);
 2795           Status err;
 3505   Status err;
 3534   Status err;
 3550   Status err;
 3765   Status err;
 4086     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 4088       Status err;
 4241     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 4243       Status err;
 4522     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 4524       Status err;
 4650     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 4652       Status err;

  169   Status eval_error;

  840       Status error;
  996 lldb_private::Status
 1001   Status error;
 1506             Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid);

  384   static lldb_private::Status

 3702         Status str_error;
 6021                                const FileSpec &outfile, Status &error) {
 6055       Status range_error = process_sp->GetMemoryRegionInfo(0, range_info);
 6270               Status memory_read_error;

   61                        lldb_private::Status &error);

  215                                 lldb_private::Status &error) {
  552     Status readmem_error;

   82                        lldb_private::Status &error);

   25                   lldb_private::Status &error) {

   18                   lldb_private::Status &error);

   95       Status error;

   66 Status ReadAllBytes(Connection &conn, void *buffer, size_t size) {
   68   Status error;
   95 Status AdbClient::CreateByDeviceID(const std::string &device_id,
   98   auto error = adb.GetDevices(connect_devices);
  137 Status AdbClient::Connect() {
  138   Status error;
  150 Status AdbClient::GetDevices(DeviceIDList &device_list) {
  153   auto error = SendMessage("host:devices");
  177 Status AdbClient::SetPortForwarding(const uint16_t local_port,
  183   const auto error = SendDeviceMessage(message);
  190 Status
  202   const auto error = SendDeviceMessage(message);
  209 Status AdbClient::DeletePortForwarding(const uint16_t local_port) {
  213   const auto error = SendDeviceMessage(message);
  220 Status AdbClient::SendMessage(const std::string &packet, const bool reconnect) {
  221   Status error;
  242 Status AdbClient::SendDeviceMessage(const std::string &packet) {
  248 Status AdbClient::ReadMessage(std::vector<char> &message) {
  254   auto error = ReadAllBytes(buffer, 4);
  269 Status AdbClient::ReadMessageStream(std::vector<char> &message,
  274   Status error;
  292 Status AdbClient::ReadResponseStatus() {
  298   auto error = ReadAllBytes(response_id, packet_len);
  308 Status AdbClient::GetResponseError(const char *response_id) {
  313   auto error = ReadMessage(error_message);
  321 Status AdbClient::SwitchDeviceTransport() {
  325   auto error = SendMessage(msg.str());
  332 Status AdbClient::StartSync() {
  333   auto error = SwitchDeviceTransport();
  345 Status AdbClient::Sync() {
  346   auto error = SendMessage("sync:", false);
  353 Status AdbClient::ReadAllBytes(void *buffer, size_t size) {
  357 Status AdbClient::internalShell(const char *command, milliseconds timeout,
  361   auto error = SwitchDeviceTransport();
  392 Status AdbClient::Shell(const char *command, milliseconds timeout,
  395   auto error = internalShell(command, timeout, output_buffer);
  404 Status AdbClient::ShellToFile(const char *command, milliseconds timeout,
  407   auto error = internalShell(command, timeout, output_buffer);
  425 AdbClient::GetSyncService(Status &error) {
  434 Status AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
  445   auto error = SendSyncRequest(kRECV, remote_file_path.length(),
  467 Status AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
  477   auto error = SendSyncRequest(kSEND, file_description_str.length(),
  516 Status AdbClient::SyncService::internalStat(const FileSpec &remote_file,
  520   auto error = SendSyncRequest(kSTAT, remote_file_path.length(),
  550 Status AdbClient::SyncService::PullFile(const FileSpec &remote_file,
  557 Status AdbClient::SyncService::PushFile(const FileSpec &local_file,
  564 Status AdbClient::SyncService::Stat(const FileSpec &remote_file, uint32_t &mode,
  578 Status
  579 AdbClient::SyncService::executeCommand(const std::function<Status()> &cmd) {
  583   const auto error = cmd();
  592 Status AdbClient::SyncService::SendSyncRequest(const char *request_id,
  600   Status error;
  611 Status AdbClient::SyncService::ReadSyncHeader(std::string &response_id,
  615   auto error = ReadAllBytes(buffer, kSyncPacketLen);
  626 Status AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer,
  632   auto error = ReadSyncHeader(response_id, data_len);
  655 Status AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {

   41     Status PullFile(const FileSpec &remote_file, const FileSpec &local_file);
   43     Status PushFile(const FileSpec &local_file, const FileSpec &remote_file);
   45     Status Stat(const FileSpec &remote_file, uint32_t &mode, uint32_t &size,
   53     Status SendSyncRequest(const char *request_id, const uint32_t data_len,
   56     Status ReadSyncHeader(std::string &response_id, uint32_t &data_len);
   58     Status PullFileChunk(std::vector<char> &buffer, bool &eof);
   60     Status ReadAllBytes(void *buffer, size_t size);
   62     Status internalPullFile(const FileSpec &remote_file,
   65     Status internalPushFile(const FileSpec &local_file,
   68     Status internalStat(const FileSpec &remote_file, uint32_t &mode,
   71     Status executeCommand(const std::function<Status()> &cmd);
   71     Status executeCommand(const std::function<Status()> &cmd);
   76   static Status CreateByDeviceID(const std::string &device_id, AdbClient &adb);
   85   Status GetDevices(DeviceIDList &device_list);
   87   Status SetPortForwarding(const uint16_t local_port,
   90   Status SetPortForwarding(const uint16_t local_port,
   94   Status DeletePortForwarding(const uint16_t local_port);
   96   Status Shell(const char *command, std::chrono::milliseconds timeout,
   99   Status ShellToFile(const char *command, std::chrono::milliseconds timeout,
  102   std::unique_ptr<SyncService> GetSyncService(Status &error);
  104   Status SwitchDeviceTransport();
  107   Status Connect();
  111   Status SendMessage(const std::string &packet, const bool reconnect = true);
  113   Status SendDeviceMessage(const std::string &packet);
  115   Status ReadMessage(std::vector<char> &message);
  117   Status ReadMessageStream(std::vector<char> &message,
  120   Status GetResponseError(const char *response_id);
  122   Status ReadResponseStatus();
  124   Status Sync();
  126   Status StartSync();
  128   Status internalShell(const char *command, std::chrono::milliseconds timeout,
  131   Status ReadAllBytes(void *buffer, size_t size);

  154 Status PlatformAndroid::ConnectRemote(Args &args) {
  175   auto error = PlatformLinux::ConnectRemote(args);
  187 Status PlatformAndroid::GetFile(const FileSpec &source,
  197   Status error;
  229 Status PlatformAndroid::PutFile(const FileSpec &source,
  241   Status error;
  250 Status PlatformAndroid::DownloadModuleSlice(const FileSpec &src_file_spec,
  260 Status PlatformAndroid::DisconnectRemote() {
  261   Status error = PlatformLinux::DisconnectRemote();
  282   Status error =
  297 Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
  320   Status error = adb.Shell("mktemp --directory --tmpdir /data/local/tmp",
  332     Status error = adb.Shell(command.GetData(), seconds(5), nullptr);
  386 AdbClient::SyncService *PlatformAndroid::GetSyncService(Status &error) {

   45   Status ConnectRemote(Args &args) override;
   47   Status GetFile(const FileSpec &source, const FileSpec &destination) override;
   49   Status PutFile(const FileSpec &source, const FileSpec &destination,
   56   Status DisconnectRemote() override;
   63   Status DownloadModuleSlice(const FileSpec &src_file_spec,
   67   Status DownloadSymbolFile(const lldb::ModuleSP &module_sp,
   74   AdbClient::SyncService *GetSyncService(Status &error);

   26 static Status ForwardPortWithAdb(
   34   auto error = AdbClient::CreateByDeviceID(device_id, adb);
   57 static Status DeleteForwardPortWithAdb(uint16_t local_port,
   63 static Status FindUnusedPort(uint16_t &port) {
   64   Status error;
   92   auto error =
  105 Status PlatformAndroidRemoteGDBServer::ConnectRemote(Args &args) {
  129   auto error =
  148 Status PlatformAndroidRemoteGDBServer::DisconnectRemote() {
  161   const auto error = DeleteForwardPortWithAdb(port, m_device_id);
  171 Status PlatformAndroidRemoteGDBServer::MakeConnectURL(
  176   Status error;
  203     lldb_private::Status &error) {

   31   Status ConnectRemote(Args &args) override;
   33   Status DisconnectRemote() override;
   39                                  lldb_private::Status &error) override;
   52   Status MakeConnectURL(const lldb::pid_t pid, const uint16_t remote_port,

  247 Status PlatformFreeBSD::LaunchProcess(ProcessLaunchInfo &launch_info) {
  248   Status error;
  262                                         Status &error) {

   52   Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
   55                          Target *target, Status &error) override;

  270                             Status &error) {

   53                                Status &error) override;

  184 Status PlatformDarwin::ResolveSymbolFile(Target &target,
  195 static lldb_private::Status
  202 static lldb_private::Status
  207   Status err = platform->GetFile(module_spec.GetFileSpec(), module_cache_spec);
  211 lldb_private::Status PlatformDarwin::GetSharedModuleWithLocalCache(
  228   Status err;
  288             Status err =
  311       Status err = BringInRemoteFile(this, module_spec, module_cache_spec);
  332 Status PlatformDarwin::GetSharedModule(
  336   Status error;
  365             Status new_error(Platform::GetSharedModule(
  392                 Status new_error(Platform::GetSharedModule(
 1107       Status status =
 1674 lldb_private::Status
 1695 lldb_private::Status
 1757           Status new_error(Platform::GetSharedModule(

   29   lldb_private::Status
   38   lldb_private::Status
   76   lldb_private::Status
   93   virtual lldb_private::Status GetSharedModuleWithLocalCache(
  126   lldb_private::Status

  182             lldb_private::Status error = RunShellCommand(
  227 Status PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file,
  241 lldb_private::Status
  270       Status err(
  297 lldb_private::Status PlatformMacOSX::GetSharedModule(
  302   Status error = GetSharedModuleWithLocalCache(
  317         Status x86_64_error = GetSharedModuleWithLocalCache(

   39   lldb_private::Status
   50   lldb_private::Status
   55   lldb_private::Status
   61   lldb_private::Status

   67 Status PlatformRemoteDarwinDevice::ResolveExecutable(
   70   Status error;
  445 Status PlatformRemoteDarwinDevice::GetSymbolFile(const FileSpec &platform_file,
  449   Status error;
  510 Status PlatformRemoteDarwinDevice::GetSharedModule(
  520   Status error;

   26   lldb_private::Status ResolveExecutable(
   32   virtual lldb_private::Status
   37   lldb_private::Status

  239                              Status &error) {

   53                                Status &error) override;

   67 Status
   71   Status error;
  231 lldb_private::Status
  296 lldb_private::Status PlatformPOSIX::GetFile(
  350     Status error;
  443 Status PlatformPOSIX::ConnectRemote(Args &args) {
  444   Status error;
  486 Status PlatformPOSIX::DisconnectRemote() {
  487   Status error;
  504                                       Status &error) {
  561                             Status &error) {
  587 Status PlatformPOSIX::EvaluateLibdlExpression(
  592     Status error = loader->CanLoadImage();
  616   Status expr_error;
  630                                             Status &error) {
  684   Status utility_error;
  748                                     lldb_private::Status &error,
  767   Status utility_error;
 1012 Status PlatformPOSIX::UnloadImage(lldb_private::Process *process,
 1022   Status error = EvaluateLibdlExpression(process, expr.GetData(), prefix,
 1050                                                 Status &error) {

   29   lldb_private::Status PutFile(const lldb_private::FileSpec &source,
   34   lldb_private::Status
   40   lldb_private::Status ResolveExecutable(
   50                          lldb_private::Status &error) override;
   59                                lldb_private::Status &error) override;
   65   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
   67   lldb_private::Status DisconnectRemote() override;
   72                        lldb_private::Status &error,
   75   lldb_private::Status UnloadImage(lldb_private::Process *process,
   79                                    lldb_private::Status &error) override;
   95   lldb_private::Status
  102                                lldb_private::Status &error);

  159 Status PlatformWindows::ResolveExecutable(
  162   Status error;
  263 Status PlatformWindows::ConnectRemote(Args &args) {
  264   Status error;
  293 Status PlatformWindows::DisconnectRemote() {
  294   Status error;
  311                                         Status &error) {
  358                                         Status &error) {

   39   Status
   48   lldb_private::Status ConnectRemote(lldb_private::Args &args) override;
   50   lldb_private::Status DisconnectRemote() override;
   55                                lldb_private::Status &error) override;
   60                          lldb_private::Status &error) override;

   94 Status PlatformRemoteGDBServer::ResolveExecutable(
   99   Status error;
  192 Status PlatformRemoteGDBServer::GetFileWithUUID(const FileSpec &platform_file,
  282 Status PlatformRemoteGDBServer::ConnectRemote(Args &args) {
  283   Status error;
  327 Status PlatformRemoteGDBServer::DisconnectRemote() {
  328   Status error;
  368 Status PlatformRemoteGDBServer::LaunchProcess(ProcessLaunchInfo &launch_info) {
  370   Status error;
  451 Status PlatformRemoteGDBServer::KillProcess(const lldb::pid_t pid) {
  461     Status &error) {
  547     Status &error) {
  596 Status PlatformRemoteGDBServer::MakeDirectory(const FileSpec &file_spec,
  598   Status error = m_gdb_client.MakeDirectory(file_spec, mode);
  607 Status PlatformRemoteGDBServer::GetFilePermissions(const FileSpec &file_spec,
  609   Status error = m_gdb_client.GetFilePermissions(file_spec, file_permissions);
  619 Status PlatformRemoteGDBServer::SetFilePermissions(const FileSpec &file_spec,
  621   Status error = m_gdb_client.SetFilePermissions(file_spec, file_permissions);
  634                                                   Status &error) {
  638 bool PlatformRemoteGDBServer::CloseFile(lldb::user_id_t fd, Status &error) {
  649                                            Status &error) {
  655                                             Status &error) {
  659 Status PlatformRemoteGDBServer::PutFile(const FileSpec &source,
  665 Status PlatformRemoteGDBServer::CreateSymlink(
  669   Status error = m_gdb_client.CreateSymlink(src, dst);
  679 Status PlatformRemoteGDBServer::Unlink(const FileSpec &file_spec) {
  680   Status error = m_gdb_client.Unlink(file_spec);
  691 Status PlatformRemoteGDBServer::RunShellCommand(
  820     lldb_private::Status &error) {
  830                                                           Status &error) {

   44   Status
   53   Status GetFileWithUUID(const FileSpec &platform_file, const UUID *uuid_ptr,
   61   Status LaunchProcess(ProcessLaunchInfo &launch_info) override;
   63   Status KillProcess(const lldb::pid_t pid) override;
   70                                Status &error) override;
   75                          Status &error) override;
  103   Status ConnectRemote(Args &args) override;
  105   Status DisconnectRemote() override;
  107   Status MakeDirectory(const FileSpec &file_spec,
  110   Status GetFilePermissions(const FileSpec &file_spec,
  113   Status SetFilePermissions(const FileSpec &file_spec,
  117                            uint32_t mode, Status &error) override;
  119   bool CloseFile(lldb::user_id_t fd, Status &error) override;
  122                     uint64_t len, Status &error) override;
  125                      uint64_t len, Status &error) override;
  129   Status PutFile(const FileSpec &source, const FileSpec &destination,
  132   Status CreateSymlink(const FileSpec &src, const FileSpec &dst) override;
  136   Status Unlink(const FileSpec &path) override;
  138   Status RunShellCommand(
  157                                  lldb_private::Status &error) override;
  160                                    lldb_private::Status &error) override;

  192 static Status EnsureFDFlags(int fd, int flags) {
  193   Status error;
  219   Status status;
  293     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
  297   Status status;
  319   Status status;
  380 Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
  429   const auto info_err = GetSignalInfo(pid, &info);
  660     Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
  831         Status error = ResumeThread(thread, thread.GetState(), 0);
  907   Status error =
  939 Status
  941   Status error;
 1032 Status NativeProcessLinux::Resume(const ResumeActionList &resume_actions) {
 1048         Status error = SetupSoftwareSingleStepping(
 1096 Status NativeProcessLinux::Halt() {
 1097   Status error;
 1105 Status NativeProcessLinux::Detach() {
 1106   Status error;
 1116     Status e = Detach(thread->GetID());
 1128 Status NativeProcessLinux::Signal(int signo) {
 1129   Status error;
 1141 Status NativeProcessLinux::Interrupt() {
 1165     Status error("found no running/stepping or live stopped threads as target "
 1184 Status NativeProcessLinux::Kill() {
 1188   Status error;
 1220 Status NativeProcessLinux::GetMemoryRegionInfo(lldb::addr_t load_addr,
 1235   Status error = PopulateMemoryRegionCache();
 1289 Status NativeProcessLinux::PopulateMemoryRegionCache() {
 1305   Status Result;
 1350 Status NativeProcessLinux::AllocateMemory(size_t size, uint32_t permissions,
 1383 Status NativeProcessLinux::DeallocateMemory(lldb::addr_t addr) {
 1396 Status NativeProcessLinux::SetBreakpoint(lldb::addr_t addr, uint32_t size,
 1404 Status NativeProcessLinux::RemoveBreakpoint(lldb::addr_t addr, bool hardware) {
 1434 Status NativeProcessLinux::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
 1471     Status error = NativeProcessLinux::PtraceWrapper(
 1489 Status NativeProcessLinux::WriteMemory(lldb::addr_t addr, const void *buf,
 1493   Status error;
 1535 Status NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo) {
 1539 Status NativeProcessLinux::GetEventMessage(lldb::tid_t tid,
 1544 Status NativeProcessLinux::Detach(lldb::tid_t tid) {
 1605       Status error(traceMonitor.takeError());
 1613 Status NativeProcessLinux::GetLoadedModuleFileSpec(const char *module_path,
 1615   Status error = PopulateMemoryRegionCache();
 1633 Status NativeProcessLinux::GetFileLoadAddress(const llvm::StringRef &file_name,
 1636   Status error = PopulateMemoryRegionCache();
 1655 Status NativeProcessLinux::ResumeThread(NativeThreadLinux &thread,
 1677     const auto resume_result = thread.Resume(signo);
 1683     const auto step_result = thread.SingleStep(signo);
 1730     Status error = RemoveBreakpoint(thread_info.second);
 1767       Status error(errno, eErrorTypePOSIX);
 1788 Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
 1791   Status error;
 1842 Status NativeProcessLinux::GetMetaData(lldb::user_id_t traceid,
 1848   Status error;
 1862 Status NativeProcessLinux::GetData(lldb::user_id_t traceid, lldb::tid_t thread,
 1866   Status error;
 1880 Status NativeProcessLinux::GetTraceConfig(lldb::user_id_t traceid,
 1882   Status error;
 1904                                            Status &error) {
 1935                                                Status &error) {
 1973 Status NativeProcessLinux::StopTracingForThread(lldb::tid_t thread) {
 1974   Status error;
 1995 Status NativeProcessLinux::StopTrace(lldb::user_id_t traceid,
 1997   Status error;
 2029 Status NativeProcessLinux::StopProcessorTracingOnThread(lldb::user_id_t traceid,
 2031   Status error;

   53   Status Resume(const ResumeActionList &resume_actions) override;
   55   Status Halt() override;
   57   Status Detach() override;
   59   Status Signal(int signo) override;
   61   Status Interrupt() override;
   63   Status Kill() override;
   65   Status GetMemoryRegionInfo(lldb::addr_t load_addr,
   68   Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
   71   Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
   74   Status AllocateMemory(size_t size, uint32_t permissions,
   77   Status DeallocateMemory(lldb::addr_t addr) override;
   83   Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
   86   Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;
   90   Status GetLoadedModuleFileSpec(const char *module_path,
   93   Status GetFileLoadAddress(const llvm::StringRef &file_name,
  104                              Status &error) override;
  106   Status StopTrace(lldb::user_id_t traceid,
  109   Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
  113   Status GetMetaData(lldb::user_id_t traceid, lldb::tid_t thread,
  117   Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) override;
  120   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
  151   static Status SetDefaultPtraceOpts(const lldb::pid_t);
  168   Status SetupSoftwareSingleStepping(NativeThreadLinux &thread);
  178   Status GetSignalInfo(lldb::tid_t tid, void *siginfo);
  183   Status GetEventMessage(lldb::tid_t tid, unsigned long *message);
  187   Status Detach(lldb::tid_t tid);
  202   Status ResumeThread(NativeThreadLinux &thread, lldb::StateType state,
  209   Status PopulateMemoryRegionCache();
  212                                          Status &error);
  216   Status StopTracingForThread(lldb::tid_t thread);
  230   Status StopProcessorTracingOnThread(lldb::user_id_t traceid,

   31 Status NativeRegisterContextLinux::ReadRegisterRaw(uint32_t reg_index,
   41 Status
   51     Status error;
   97 Status NativeRegisterContextLinux::ReadGPR() {
  102 Status NativeRegisterContextLinux::WriteGPR() {
  107 Status NativeRegisterContextLinux::ReadFPR() {
  113 Status NativeRegisterContextLinux::WriteFPR() {
  119 Status NativeRegisterContextLinux::ReadRegisterSet(void *buf, size_t buf_size,
  126 Status NativeRegisterContextLinux::WriteRegisterSet(void *buf, size_t buf_size,
  133 Status NativeRegisterContextLinux::DoReadRegisterValue(uint32_t offset,
  140   Status error = NativeProcessLinux::PtraceWrapper(
  152 Status NativeRegisterContextLinux::DoWriteRegisterValue(

   34   virtual Status ReadRegisterRaw(uint32_t reg_index, RegisterValue &reg_value);
   36   virtual Status WriteRegisterRaw(uint32_t reg_index,
   39   virtual Status ReadRegisterSet(void *buf, size_t buf_size,
   42   virtual Status WriteRegisterSet(void *buf, size_t buf_size,
   45   virtual Status ReadGPR();
   47   virtual Status WriteGPR();
   49   virtual Status ReadFPR();
   51   virtual Status WriteFPR();
   66   virtual Status DoReadRegisterValue(uint32_t offset, const char *reg_name,
   69   virtual Status DoWriteRegisterValue(uint32_t offset, const char *reg_name,

  408 Status
  411   Status error;
  569 Status NativeRegisterContextLinux_x86_64::WriteRegister(
  659     Status error = WriteFPR();
  678 Status NativeRegisterContextLinux_x86_64::ReadAllRegisterValues(
  680   Status error;
  752 Status NativeRegisterContextLinux_x86_64::WriteAllRegisterValues(
  754   Status error;
  880 Status NativeRegisterContextLinux_x86_64::WriteFPR() {
  954 Status NativeRegisterContextLinux_x86_64::ReadFPR() {
  955   Status error;
 1012 Status NativeRegisterContextLinux_x86_64::IsWatchpointHit(uint32_t wp_index,
 1018   Status error = ReadRegisterRaw(m_reg_info.first_dr + 6, reg_value);
 1031 Status NativeRegisterContextLinux_x86_64::GetWatchpointHitIndex(
 1036     Status error = IsWatchpointHit(wp_index, is_hit);
 1048 Status NativeRegisterContextLinux_x86_64::IsWatchpointVacant(uint32_t wp_index,
 1054   Status error = ReadRegisterRaw(m_reg_info.first_dr + 7, reg_value);
 1067 Status NativeRegisterContextLinux_x86_64::SetHardwareWatchpointWithIndex(
 1087   Status error = IsWatchpointVacant(wp_index, is_vacant);
 1138   Status error = ReadRegisterRaw(m_reg_info.first_dr + 6, reg_value);
 1159 Status NativeRegisterContextLinux_x86_64::ClearAllHardwareWatchpoints() {
 1163   Status error = ReadRegisterRaw(m_reg_info.first_dr + 6, reg_value);
 1187     Status error = IsWatchpointVacant(wp_index, is_vacant);

   35   Status ReadRegister(const RegisterInfo *reg_info,
   38   Status WriteRegister(const RegisterInfo *reg_info,
   41   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
   43   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
   45   Status IsWatchpointHit(uint32_t wp_index, bool &is_hit) override;
   47   Status GetWatchpointHitIndex(uint32_t &wp_index,
   50   Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant) override;
   54   Status ClearAllHardwareWatchpoints() override;
   56   Status SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size,
   74   Status ReadFPR() override;
   76   Status WriteFPR() override;

  146 Status NativeThreadLinux::SetWatchpoint(lldb::addr_t addr, size_t size,
  152   Status error = RemoveWatchpoint(addr);
  163 Status NativeThreadLinux::RemoveWatchpoint(lldb::addr_t addr) {
  174 Status NativeThreadLinux::SetHardwareBreakpoint(lldb::addr_t addr,
  179   Status error = RemoveHardwareBreakpoint(addr);
  192 Status NativeThreadLinux::RemoveHardwareBreakpoint(lldb::addr_t addr) {
  206 Status NativeThreadLinux::Resume(uint32_t signo) {
  248 Status NativeThreadLinux::SingleStep(uint32_t signo) {
  406 Status NativeThreadLinux::RequestStop() {
  419   Status err;

   45   Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
   48   Status RemoveWatchpoint(lldb::addr_t addr) override;
   50   Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
   52   Status RemoveHardwareBreakpoint(lldb::addr_t addr) override;
   59   Status Resume(uint32_t signo);
   63   Status SingleStep(uint32_t signo);
   88   Status RequestStop();

   29 Status ProcessorTraceMonitor::GetTraceConfig(TraceOptions &config) const {
   33   Status error;
   46 Status ProcessorTraceMonitor::StartTrace(lldb::pid_t pid, lldb::tid_t tid,
   51   Status error;
  169 Status ProcessorTraceMonitor::GetCPUType(TraceOptions &config) {
  171   Status error;
  247   Status error;
  270 Status
  277   Status error;
  300 Status
  308   Status error;

   82   Status StartTrace(lldb::pid_t pid, lldb::tid_t tid,
   96   static Status GetCPUType(TraceOptions &config);
  102   Status ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
  105   Status ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
  114   Status GetTraceConfig(TraceOptions &config) const;

   70     auto error = ReadMemory(phdr_addr + i * phdr_entry_size, &phdr_entry,
   95     auto error = ReadMemory(dynamic_section_addr + i * sizeof(dynamic_entry),
  115   auto error =
  146   auto status =

   17 static Status
  108     Status error = ParseMemoryRegionInfoFromProcMapsLine(line, region);

   20                            const lldb_private::Status &)> LinuxMapCallback;

 1034     Status error(ReadRegisterValueFromMemory(
 1076     Status error(WriteRegisterValueToMemory(
 1509     Status error;
 1806         Status error = ReadRegisterValueFromMemory(
 1860     Status error;
 1880       Status st;

   95     Status error(WriteRegisterValueToMemory(reg_info, reg_addr,
  107       Status error;
  124       Status error;

  194 Status RegisterContextThreadMemory::ReadRegisterValueFromMemory(
  201   Status error;
  206 Status RegisterContextThreadMemory::WriteRegisterValueToMemory(
  213   Status error;

   78   Status ReadRegisterValueFromMemory(const lldb_private::RegisterInfo *reg_info,
   82   Status WriteRegisterValueToMemory(const lldb_private::RegisterInfo *reg_info,

  103   Status error;
  192   Status error;