Lines Matching +defs:start +defs:file +defs:process
108 // and get the packet history dumped to a file.
110 auto file = FileSystem::Instance().Open(
112 if (!file) {
113 llvm::consumeError(file.takeError());
116 StreamFile stream(std::move(file.get()));
227 // For now we are just making sure the file exists for a given module
258 m_async_broadcaster(nullptr, "lldb.process.gdb-remote.async-broadcaster"),
260 Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
302 // We need to call finalize on the process before destroying ourselves to
308 // The general Finalize is going to try to destroy the process and that
390 // 1 - Use the target definition python file if one is specified.
404 // See if we can get register definitions from a python file
408 Debugger::ReportError("target description file " +
418 // Use the process' architecture instead of the host arch, if available
542 // We don't have a valid process ID, so note that we are connected and
543 // could now request to launch or attach, or get remote process listings...
546 // We have a valid process
591 // Prefer the *process'* architecture over that of the *host*, if
662 // the inferior will be reading stdin from the specified file or stdio is
682 // set to /dev/null unless redirected to a file above
874 // Then dispatch any process commands:
885 // qProcessInfo as it will be more specific to our process.
890 LLDB_LOG(log, "gdb-remote had process architecture, using {0} {1}",
896 "gdb-remote did not have process architecture, using gdb-remote "
925 "remote process is ARM/Apple, "
1010 // force load into the process -- a firmware type situation
1472 const size_t start = thread_pcs_pos + strlen(";thread-pcs:");
1473 const size_t end = stop_info_str.find(';', start);
1475 std::string value = stop_info_str.substr(start, end - start);
1482 const size_t start = threads_pos + strlen(";threads:");
1483 const size_t end = stop_info_str.find(';', start);
1485 std::string value = stop_info_str.substr(start, end - start);
1801 // \a wp_addr which is the original start address that
2172 // Our first stop, make sure we have a process ID, and also make sure we
2191 false; // says if locals below that start with "queue_" are valid
2224 // process that includes the thread for this stop reply packet
2276 // memory that can populate the L1 memory cache in the process so that
2399 // process exited
2415 // list of all thread IDs in the current process, so m_thread_ids might get
2447 // file handle and debugserver will go away, but with remote proxies, it
2475 // Sleep for one second to let the process get all detached...
2501 // Platform, then hand the process off to debugserver, which becomes
2502 // the parent process through "PT_ATTACH". Then when we go to kill
2503 // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then
2506 // the process, but instead it is left around as a Zombie. Probably
2507 // the kernel is in the process of switching ownership back to lldb
2679 // for this target/process/address.
2698 // for this target/process.
3092 // The process of setting a hardware breakpoint is much the same as above.
3138 // placed into the process memory using memory write packets.
3289 // process.
3328 // order for the watchpoint object to intelligently process this action.
3482 // Our process spawned correctly, we can now set our connection to use
3494 LLDB_LOGF(log, "failed to start debugserver process: %s",
3500 // Finish the connection process by doing the handshake without
3513 int exit_status // Exit value of process if signal is zero
3515 // "debugserver_pid" argument passed in is the process ID for debugserver
3525 LLDB_LOGF(log, "ProcessGDBRemote::%s(process = %p)", __FUNCTION__,
3530 // Sleep for a half a second to make sure our inferior process has time to
3532 // and the inferior process shut down.
3535 // If our process hasn't yet exited, debugserver might have died. If the
3536 // process did exit, then we are reaping it.
3585 "Properties for the gdb-remote process plug-in.", is_global_setting);
3600 ThreadLauncher::LaunchThread("<lldb.process.gdb-remote.async>", [this] {
3648 // have decided the process has exited. There are some
3650 // process and the interrupt fails, where another packet might
3651 // get delivered after we've decided to give up on the process.
3652 // But once we've decided we are done with the process we will
3701 // packet to the process using the
3737 // the process is not debuggable. Return a slightly more
3741 SetExitStatus(-1, "cannot attach to process due to "
3799 // // process and ask it for the list of processes. But if we are local, we
3914 "Sending events is not supported for this process.");
4363 std::optional<unsigned> start;
4367 field_node.ForEachAttribute([&name, &start, &end, &type, max_start_bit,
4378 } else if (attr_name == "start") {
4383 "ProcessGDBRemote::ParseFlagsFields Invalid start {0} in "
4388 start = parsed_start;
4392 "ProcessGDBRemote::ParseFlagsFields Invalid start \"{0}\" in "
4426 if (name && start && end) {
4427 if (*start > *end)
4432 *start, *end, name->data());
4434 if (RegisterFlags::Field::GetSizeInBits(*start, *end) > 64)
4450 RegisterFlags::Field::GetMaxValue(*start, *end);
4474 RegisterFlags::Field(name->str(), *start, *end, enum_type));
4569 "{0} (start: {1} end: {2}) and {3} (start: {4} end: {5}) "
4766 // This method fetches a register description feature xml file from
4768 // information to the current process. It will call itself recursively
4770 // to fetch and parse an xml file.
4774 // request the target xml file
4786 // The top level feature XML file will start with a <target> tag.
4827 // In an included XML feature file, we're already "inside" the <target>
4828 // tag of the initial XML file; this included file will likely only have
4848 // or process architecture. If that is the case, attempt to use
4937 // GetGDBServerRegisterInfoXMLAndProcess will recurse to fetch and process.
4973 // parse the xml file in memory
5118 lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
5126 return loader->LoadModuleAtAddress(file, link_map, base_addr,
5157 FileSpec file(mod_name);
5158 FileSystem::Instance().Resolve(file);
5160 LoadModuleAtAddress(file, link_map, mod_base, mod_base_is_offset);
5211 Status ProcessGDBRemote::GetFileLoadAddress(const FileSpec &file,
5217 std::string file_path = file.GetPath(false);
5219 return Status::FromErrorString("Empty file name specified");
5232 // The file is not loaded into the inferior
5239 "Fetching file load address from remote server returned an error");
5401 // process the response
5412 // now transfer the core file
5418 // NB: we unlink the file on error too
5481 : CommandObjectParsed(interpreter, "process plugin packet speed-test",
5517 ProcessGDBRemote *process =
5520 if (process) {
5534 process->GetGDBRemote().TestPacketSpeed(
5559 : CommandObjectParsed(interpreter, "process plugin packet history",
5565 ProcessGDBRemote *process =
5567 if (process) {
5568 process->DumpPluginHistory(result.GetOutputStream());
5581 interpreter, "process plugin packet xfer-size",
5599 ProcessGDBRemote *process =
5601 if (process) {
5606 process->SetUserSpecifiedMaxMemoryTransferSize(user_specified_max);
5619 : CommandObjectParsed(interpreter, "process plugin packet send",
5640 ProcessGDBRemote *process =
5642 if (process) {
5646 process->GetGDBRemote().SendPacketAndWaitForResponse(
5647 packet_cstr, response, process->GetInterruptTimeout());
5654 response_str = process->HarmonizeThreadIdsForProfileData(response);
5670 : CommandObjectRaw(interpreter, "process plugin packet monitor",
5687 ProcessGDBRemote *process =
5689 if (process) {
5696 process->GetGDBRemote().SendPacketAndReceiveResponseWithOutputSupport(
5697 packet.GetString(), response, process->GetInterruptTimeout(),
5715 : CommandObjectMultiword(interpreter, "process plugin packet",
5745 interpreter, "process plugin",
5746 "Commands for operating on a ProcessGDBRemote process.",
5747 "process plugin <subcommand> [<subcommand-options>]") {
5822 // Switch to the process that is going to be detached.
5828 // Disable all software breakpoints in the forked process.
5832 // Remove hardware breakpoints / watchpoints from parent process if we're
5837 // Switch to the process that is going to be followed
5844 LLDB_LOG(log, "Detaching process {0}", detach_pid);
5888 // Switch to the parent process before detaching it.
5894 // Remove hardware breakpoints / watchpoints from the parent process.
5897 // Switch to the child process.
5906 LLDB_LOG(log, "Detaching process {0}", detach_pid);