From 2f188f7d24554b6ab4791299da694fe135f727a5 Mon Sep 17 00:00:00 2001 From: caolili123 Date: Thu, 27 Jul 2023 14:52:01 +0800 Subject: [PATCH 1/2] issue:https://gitee.com/openharmony/arkcompiler_toolchain/issues/I7OGHR Signed-off-by: caolili123 --- tooling/client/BUILD.gn | 3 +- tooling/client/domain/heapprofiler_client.cpp | 27 ++++++- tooling/client/manager/domain_manager.cpp | 81 +++++++++++++++++++ tooling/client/manager/domain_manager.h | 38 +++++++++ tooling/client/toolchain_cli/cli_command.cpp | 19 ++--- tooling/client/toolchain_cli/cli_command.h | 16 +++- tooling/client/toolchain_cli/main.cpp | 16 +++- tooling/client/websocket/websocket_client.h | 30 ++++++- 8 files changed, 207 insertions(+), 23 deletions(-) create mode 100644 tooling/client/manager/domain_manager.cpp create mode 100644 tooling/client/manager/domain_manager.h diff --git a/tooling/client/BUILD.gn b/tooling/client/BUILD.gn index bf9360f7..9edd148e 100644 --- a/tooling/client/BUILD.gn +++ b/tooling/client/BUILD.gn @@ -56,6 +56,7 @@ ohos_source_set("libark_toolchain_client_set") { sources = [ "websocket/websocket_client.cpp", "domain/heapprofiler_client.cpp", + "manager/domain_manager.cpp", ] deps += [ @@ -63,11 +64,11 @@ ohos_source_set("libark_toolchain_client_set") { "$toolchain_root/tooling:libark_ecma_debugger_set", "$ark_third_party_root/openssl:libcrypto_shared", sdk_libc_secshared_dep, + "//third_party/libuv:uv", ] external_deps += [ "ets_runtime:libark_jsruntime", - "libuv:uv", ] configs += [ diff --git a/tooling/client/domain/heapprofiler_client.cpp b/tooling/client/domain/heapprofiler_client.cpp index 93448e3b..38788aed 100644 --- a/tooling/client/domain/heapprofiler_client.cpp +++ b/tooling/client/domain/heapprofiler_client.cpp @@ -109,18 +109,37 @@ std::string HeapProfilerClient::Disable(int id) return request->Stringify(); } -std::string HeapProfilerClient::Samping([[maybe_unused]] int id) +std::string HeapProfilerClient::Samping(int id) { - return "Samping"; + std::unique_ptr request = PtJson::CreateObject(); + request->Add("id", id); + request->Add("method", "HeapProfiler.startSampling"); + + std::unique_ptr params = PtJson::CreateObject(); + params->Add("samplingInterval", 16384); + request->Add("params", params); + return request->Stringify(); } std::string HeapProfilerClient::SampingStop([[maybe_unused]] int id) { - return "SampingStop"; + std::unique_ptr request = PtJson::CreateObject(); + request->Add("id", id); + request->Add("method", "HeapProfiler.stopSampling"); + + std::unique_ptr params = PtJson::CreateObject(); + request->Add("params", params); + return request->Stringify(); } std::string HeapProfilerClient::CollectGarbage([[maybe_unused]] int id) { - return "CollectGarbage"; + std::unique_ptr request = PtJson::CreateObject(); + request->Add("id", id); + request->Add("method", "HeapProfiler.collectGarbage"); + + std::unique_ptr params = PtJson::CreateObject(); + request->Add("params", params); + return request->Stringify(); } } //OHOS::ArkCompiler::Toolchain \ No newline at end of file diff --git a/tooling/client/manager/domain_manager.cpp b/tooling/client/manager/domain_manager.cpp new file mode 100644 index 00000000..7f167951 --- /dev/null +++ b/tooling/client/manager/domain_manager.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "domain_manager.h" +#include "log_wrapper.h" +#include "pt_json.h" + +using PtJson = panda::ecmascript::tooling::PtJson; +using Result = panda::ecmascript::tooling::Result; +namespace OHOS::ArkCompiler::Toolchain { +void DomainManager::GetReply(ToolchainWebsocket* cliSocket) +{ + while (cliSocket->IsConnected()) { + DispatcherReply(cliSocket); + } +} + +void DomainManager::DispatcherReply(ToolchainWebsocket* cliSocket) +{ + std::string decMessage = cliSocket->Decode(); + std::unique_ptr json = PtJson::Parse(decMessage); + if (json == nullptr) { + LOGE("json parse error"); + return; + } + + if (!json->IsObject()) { + LOGE("json parse format error"); + json->ReleaseRoot(); + return; + } + + std::string domain; + Result ret; + int32_t id; + ret = json->GetInt("id", &id); + if (ret == Result::SUCCESS) { + cliSocket->GetDomainById(id, &domain); + std::lock_guard lock(cliSocket->idDomainMutex_); + cliSocket->RemoveDomainById(id); + } + + std::string wholeMethod; + std::string method; + ret = json->GetString("method", &wholeMethod); + if (ret == Result::SUCCESS) { + std::string::size_type length = wholeMethod.length(); + std::string::size_type indexPoint; + indexPoint = wholeMethod.find_first_of('.', 0); + if (indexPoint == std::string::npos || indexPoint == 0 || indexPoint == length - 1) { + return; + } + domain = wholeMethod.substr(0, indexPoint); + } + + if (domain == "HeapProfiler") { + LOGE("HeapProfiler DispatcherReply: %{public}s", decMessage.c_str()); + }else if(domain == "Profiler") { + LOGE("Profiler DispatcherReply: %{public}s", decMessage.c_str()); + }else if(domain == "Runtime") { + LOGE("Runtime DispatcherReply: %{public}s", decMessage.c_str()); + }else if(domain == "Debugger") { + LOGE("Debugger DispatcherReply: %{public}s", decMessage.c_str()); + } +} +} \ No newline at end of file diff --git a/tooling/client/manager/domain_manager.h b/tooling/client/manager/domain_manager.h new file mode 100644 index 00000000..97f59c0d --- /dev/null +++ b/tooling/client/manager/domain_manager.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ECMASCRIPT_TOOLING_CLIENT_MANAGER_DOMAIN_MANAGER_H +#define ECMASCRIPT_TOOLING_CLIENT_MANAGER_DOMAIN_MANAGER_H + +#include + +#include "toolchain_cli/cli_command.h" + +namespace OHOS::ArkCompiler::Toolchain { +class DomainManager{ +public: + DomainManager() = default; + ~DomainManager() = default; + + //void GetReply(CliCommand* cliCommand); + void GetReply(ToolchainWebsocket* cliSocket); + //void DispatcherReply(std::string decMessage, CliCommand* cliCommand); + void DispatcherReply(ToolchainWebsocket* cliSocket); + +private: + +}; +} //OHOS::ArkCompiler::Toolchain +#endif \ No newline at end of file diff --git a/tooling/client/toolchain_cli/cli_command.cpp b/tooling/client/toolchain_cli/cli_command.cpp index 060e58cc..8f93537f 100644 --- a/tooling/client/toolchain_cli/cli_command.cpp +++ b/tooling/client/toolchain_cli/cli_command.cpp @@ -17,6 +17,8 @@ #include #include #include +#include + #include "cli_command.h" #include "log_wrapper.h" @@ -166,18 +168,15 @@ ErrCode CliCommand::HeapProfilerCommand(const std::string cmd) bool result = false; LOGE("HeapProfilerCommand: %{public}d", id_); result = heapProfilerCli_.DispatcherCmd(id_, cmd, &request); - std::string lastReply = "{\"id\":" + std::to_string(id_) + ",\"result\":{}}"; if (result) { cliSocket_->ClientSendReq(request); - while (cliSocket_->IsConnected()) { - std::string decMessage = cliSocket_->Decode(); - std::cout << decMessage << std::endl; - if (strstr(decMessage.c_str(), lastReply.c_str())) { - break; - } + std::string domain; + std::lock_guard lock(cliSocket_->idDomainMutex_); + if (!cliSocket_->GetDomainById(id_, &domain)) { + cliSocket_->SetDomainById(id_, "HeapProfiler"); } } else { - std::cout << request << std::endl; + return ERR_FAIL; } return ERR_OK; } @@ -214,8 +213,7 @@ ErrCode CliCommand::OnCommand() if (!strcmp(cmdPair.first.c_str(), cmd_.c_str()) ||!strcmp(cmdPair.second.c_str(), cmd_.c_str())) { auto respond = it->second; - respond(); - return ERR_OK; + return respond(); } } @@ -234,5 +232,4 @@ ErrCode CliCommand::OnCommand() return ERR_FAIL; } - } // namespace OHOS::ArkCompiler::Toolchain diff --git a/tooling/client/toolchain_cli/cli_command.h b/tooling/client/toolchain_cli/cli_command.h index 6ff46878..2ea9e2a3 100644 --- a/tooling/client/toolchain_cli/cli_command.h +++ b/tooling/client/toolchain_cli/cli_command.h @@ -16,10 +16,10 @@ #ifndef ECMASCRIPT_TOOLING_CLIENT_TOOLCHAIN_CLI_COMMAND_H #define ECMASCRIPT_TOOLING_CLIENT_TOOLCHAIN_CLI_COMMAND_H -#include -#include #include #include +#include +#include #include "log_wrapper.h" #include "websocket/websocket_client.h" @@ -59,6 +59,16 @@ public: ErrCode RuntimeCommand(const std::string cmd); ErrCode ExecHelpCommand(); + ToolchainWebsocket* GetCliSocket() const + { + return cliSocket_; + } + + uint32_t GetId() const + { + return id_; + } + private: std::string cmd_; VecStr argList_; @@ -66,7 +76,7 @@ private: std::string resultReceiver_ = ""; ToolchainWebsocket* cliSocket_ {nullptr}; HeapProfilerClient heapProfilerCli_; - int id_ = 0; + uint32_t id_ = 0; }; } // namespace OHOS::ArkCompiler::Toolchain diff --git a/tooling/client/toolchain_cli/main.cpp b/tooling/client/toolchain_cli/main.cpp index bc4d42aa..b1a1be72 100644 --- a/tooling/client/toolchain_cli/main.cpp +++ b/tooling/client/toolchain_cli/main.cpp @@ -16,8 +16,10 @@ #include #include #include +#include #include "cli_command.h" +#include "manager/domain_manager.h" namespace OHOS::ArkCompiler::Toolchain{ bool StrToUInt(const char *content, uint32_t *result) @@ -55,7 +57,7 @@ std::vector SplitString(const std::string &str, const std::string & int Main(const int argc, const char** argv) { uint32_t port = 0; - OHOS::ArkCompiler::Toolchain::ToolchainWebsocket cliSocket; + ToolchainWebsocket cliSocket; if(argc < 2) { LOGE("toolchain_cli is missing a parameter"); return -1; @@ -86,9 +88,17 @@ int Main(const int argc, const char** argv) return -1; } + std::thread thread; + DomainManager domainManager; + thread = std::thread(&DomainManager::GetReply, &domainManager, &cliSocket); + if (thread.joinable()) { + thread.detach(); + } + std::cout << ">>> "; std::string inputStr; - int cmdId = 0; + uint32_t cmdId = 0; + while(getline(std::cin, inputStr)) { if((!strcmp(inputStr.c_str(), "quit"))||(!strcmp(inputStr.c_str(), "q"))) { LOGE("toolchain_cli: quit"); @@ -97,7 +107,7 @@ int Main(const int argc, const char** argv) } std::vector cliCmdStr = SplitString(inputStr, " "); cmdId += 1; - OHOS::ArkCompiler::Toolchain::CliCommand cmd(&cliSocket, cliCmdStr, cmdId); + CliCommand cmd(&cliSocket, cliCmdStr, cmdId); if(ERR_FAIL == cmd.ExecCommand()) { cmdId -= 1; } diff --git a/tooling/client/websocket/websocket_client.h b/tooling/client/websocket/websocket_client.h index 5c884009..e4ca528e 100644 --- a/tooling/client/websocket/websocket_client.h +++ b/tooling/client/websocket/websocket_client.h @@ -16,9 +16,11 @@ #ifndef ECMASCRIPT_TOOLING_CLIENT_WEBSOCKET_CLIENT_H #define ECMASCRIPT_TOOLING_CLIENT_WEBSOCKET_CLIENT_H +#include #include #include -#include +#include +#include #include "websocket.h" @@ -54,6 +56,31 @@ public: void Close(); bool SetWebSocketTimeOut(int32_t fd, uint32_t timeoutLimit); bool IsConnected(); + + bool GetDomainById(uint32_t id, std::string* domain) + { + auto iter = idDomainMap_.find(id); + if (iter == idDomainMap_.end()) { + return false; + } + *domain = iter->second; + return true; + } + + void SetDomainById(uint32_t id, std::string domain) + { + idDomainMap_.emplace(id, domain); + } + + void RemoveDomainById(uint32_t id) + { + auto it = idDomainMap_.find(id); + if (it != idDomainMap_.end()) { + idDomainMap_.erase(it); + } + } + + std::mutex idDomainMutex_; private: int32_t client_ {-1}; std::atomic socketState_ {ToolchainSocketState::UNINITED}; @@ -74,6 +101,7 @@ private: static constexpr int32_t PAYLOAD_LEN = 2; static constexpr int32_t EXTEND_PAYLOAD_LEN = 8; static constexpr char MASK_KEY[SOCKET_MASK_LEN + 1] = "abcd"; + std::map idDomainMap_; }; } // namespace OHOS::ArkCompiler::Toolchain -- Gitee From f6bb143b4b1968a3df5a6431b1f952902848f806 Mon Sep 17 00:00:00 2001 From: duning Date: Thu, 17 Aug 2023 16:19:48 +0800 Subject: [PATCH 2/2] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20breakpoint=5Fmanager?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit issue:#I7U056 Signed-off-by: duning Change-Id: I56508301b14274bb885fd0348ba5c44d4527bb90 --- tooling/backend/js_pt_hooks.h | 4 +- tooling/client/domain/heapprofiler_client.cpp | 3 +- tooling/client/domain/heapprofiler_client.h | 1 + tooling/client/manager/breakpoint_manager.cpp | 92 +++++++++ tooling/client/manager/breakpoint_manager.h | 183 ++++++++++++++++++ tooling/client/toolchain_cli/cli_command.cpp | 25 ++- tooling/client/toolchain_cli/cli_command.h | 5 +- tooling/client/toolchain_cli/main.cpp | 2 +- 8 files changed, 307 insertions(+), 8 deletions(-) diff --git a/tooling/backend/js_pt_hooks.h b/tooling/backend/js_pt_hooks.h index 0b57742b..4659dd17 100644 --- a/tooling/backend/js_pt_hooks.h +++ b/tooling/backend/js_pt_hooks.h @@ -28,7 +28,7 @@ class DebuggerImpl; class JSPtHooks : public PtHooks { public: explicit JSPtHooks(DebuggerImpl *debugger) : debugger_(debugger) {} - ~JSPtHooks() override = default; + ~JSPtHooks() = default; void DebuggerStmt(const JSPtLocation &location) override; void Breakpoint(const JSPtLocation &location) override; @@ -36,7 +36,7 @@ public: void Exception(const JSPtLocation &location) override; bool SingleStep(const JSPtLocation &location) override; void NativeCalling(const void *nativeAddress) override; - void PendingJobEntry() override; + void PendingJobEntry(); void VmStart() override {} void VmDeath() override {} diff --git a/tooling/client/domain/heapprofiler_client.cpp b/tooling/client/domain/heapprofiler_client.cpp index 38788aed..b5a4a576 100644 --- a/tooling/client/domain/heapprofiler_client.cpp +++ b/tooling/client/domain/heapprofiler_client.cpp @@ -33,7 +33,7 @@ bool HeapProfilerClient::DispatcherCmd(int id, const std::string cmd, std::strin { "heapprofiler-disable", std::bind(&HeapProfilerClient::Disable, this, id)}, { "sampling", std::bind(&HeapProfilerClient::Samping, this, id)}, { "sampling-stop", std::bind(&HeapProfilerClient::SampingStop, this, id)}, - { "collectgarbage", std::bind(&HeapProfilerClient::CollectGarbage, this, id)} + { "collectgarbage", std::bind(&HeapProfilerClient::CollectGarbage, this, id)}, }; auto entry = dispatcherTable.find(cmd); @@ -48,7 +48,6 @@ bool HeapProfilerClient::DispatcherCmd(int id, const std::string cmd, std::strin return false; } } - std::string HeapProfilerClient::HeapDumpCommand(int id) { std::unique_ptr request = PtJson::CreateObject(); diff --git a/tooling/client/domain/heapprofiler_client.h b/tooling/client/domain/heapprofiler_client.h index 496cd237..6a31905d 100644 --- a/tooling/client/domain/heapprofiler_client.h +++ b/tooling/client/domain/heapprofiler_client.h @@ -33,6 +33,7 @@ public: std::string Samping(int id); std::string SampingStop(int id); std::string CollectGarbage(int id); + std::string abc(int id); private: }; diff --git a/tooling/client/manager/breakpoint_manager.cpp b/tooling/client/manager/breakpoint_manager.cpp index 9703852d..f208ffd8 100644 --- a/tooling/client/manager/breakpoint_manager.cpp +++ b/tooling/client/manager/breakpoint_manager.cpp @@ -12,3 +12,95 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include "domain/heapprofiler_client.h" +#include "pt_json.h" +#include "log_wrapper.h" + +#include +#include +#include + +using PtJson = panda::ecmascript::tooling::PtJson; +namespace OHOS::ArkCompiler::Toolchain { +bool Breaklocation::DispatcherCmd(int id, const std::string cmd, std::string* reqStr,int32_t linenumber) +{ + std::map> dispatcherTable { + { "break", std::bind(&Breaklocation::BreakCom, this, id,linenumber)}, + }; + + auto entry = dispatcherTable.find(cmd); + + if (entry != dispatcherTable.end() && entry->second != nullptr) { + *reqStr = entry->second(); + LOGE("DispatcherCmd reqStr1: %{public}s", reqStr->c_str()); + return true; + } else { + *reqStr = "Unknown commond: " + cmd; + LOGE("DispatcherCmd reqStr2: %{public}s", reqStr->c_str()); + return false; + } +} +std::string Breaklocation::BreakCom(int id,int32_t linenumber) +{ + std::unique_ptr request = PtJson::CreateObject(); + request->Add("id", id); + request->Add("method", "XXX"); + std::unique_ptr params = PtJson::CreateObject(); + params->Add("enabled", true); + params->Add("scriptId",std::to_string(scriptId_).c_str()); + params->Add("lineNumber",lineNumber_); + params->Add("columnNumber", columnNumber_.value()); + params->Add("type", type_->c_str()); + request->Add("params", params); + return request->Stringify(); +} + +std::unique_ptr Breaklocation::Create(const PtJson ¶ms) +{ + std::string error; + auto Breaklocation = std::make_unique(); + Result ret; + + std::string scriptId; + ret = params.GetString("scriptId", &scriptId); + if (ret == Result::SUCCESS) { + Breaklocation->scriptId_ = std::stoi(scriptId); + } else { + error += "Unknown 'scriptId';"; + } + + int32_t lineNumber; + ret = params.GetInt("lineNumber", &lineNumber); + if (ret == Result::SUCCESS) { + Breaklocation->lineNumber_ = lineNumber; + } else { + error += "Unknown 'lineNumber';"; + } + + int32_t columnNumber; + ret = params.GetInt("columnNumber", &columnNumber); + if (ret == Result::SUCCESS) { + Breaklocation->columnNumber_ = columnNumber; + } else if (ret == Result::TYPE_ERROR) { + error += "Unknown 'columnNumber';"; + } + + std::string type; + ret = params.GetString("type", &type); + if (ret == Result::SUCCESS) { + if (BreakType::Valid(type)) { + Breaklocation->type_ = std::move(type); + } else { + error += "'type' is invalid;"; + } + } else if (ret == Result::TYPE_ERROR) { + error += "type 'scriptId';"; + } + + if (!error.empty()) { + LOG_DEBUGGER(ERROR) << "Location::Create " << error; + return nullptr; + } + return Breaklocation; +} +} \ No newline at end of file diff --git a/tooling/client/manager/breakpoint_manager.h b/tooling/client/manager/breakpoint_manager.h index 9703852d..ce9e0c70 100644 --- a/tooling/client/manager/breakpoint_manager.h +++ b/tooling/client/manager/breakpoint_manager.h @@ -12,3 +12,186 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include +#include +#include +namespace OHOS::ArkCompiler::Toolchain { +class Breaklocation final { +public: + Breaklocation() = default; + ~Breaklocation() = default; + + bool DispatcherCmd(int id, const std::string cmd, std::string* reqStr,int linenumber); + std::string Breaklocation::BreakCom(int id); + + NO_COPY_SEMANTIC(Breaklocation); + NO_MOVE_SEMANTIC(Breaklocation); + + static std::unique_ptr Create(const PtJson ¶ms); + std::unique_ptr ToJson() const override; + int32_t GetScriptId() const + { + return scriptId_; + } + + Breaklocation &SetScriptId(int32_t scriptId) + { + scriptId_ = scriptId; + return *this; + } + + int32_t GetLine() const + { + return lineNumber_; + } + + Breaklocation &SetLine(int32_t lineNumber) + { + lineNumber_ = lineNumber; + return *this; + } + + int32_t GetColumn() const + { + return columnNumber_.value_or(-1); + } + + Breaklocation &SetColumn(int32_t columnNumber) + { + columnNumber_ = columnNumber; + return *this; + } + + bool HasColumn() const + { + return columnNumber_.has_value(); + } + + const std::string &GetType() const + { + ASSERT(HasType()); + return type_.value(); + } + + Breaklocation &SetType(const std::string &type) + { + type_ = type; + return *this; + } + + bool HasType() const + { + return type_.has_value(); + } + + struct Type { + static bool Valid(const std::string &type) + { + return type == DebuggerStatement() || type == Call() || type == Return(); + } + static std::string DebuggerStatement() + { + return "debuggerStatement"; + } + static std::string Call() + { + return "call"; + } + static std::string Return() + { + return "return"; + } + }; +private: + int32_t scriptId_ {0}; + int32_t lineNumber_ {0}; + std::optional columnNumber_ {}; + std::optional type_ {}; +}; +class ScriptPosition { +public: + ScriptPosition() = default; + ~ScriptPosition() override = default; + + static std::unique_ptr Create(const PtJson ¶ms); + std::unique_ptr ToJson() const override; + + int32_t GetLine() const + { + return lineNumber_; + } + + ScriptPosition &SetLine(int32_t line) + { + lineNumber_ = line; + return *this; + } + + int32_t GetColumn() const + { + return columnNumber_; + } + + ScriptPosition &SetColumn(int32_t column) + { + columnNumber_ = column; + return *this; + } + +private: + NO_COPY_SEMANTIC(ScriptPosition); + NO_MOVE_SEMANTIC(ScriptPosition); + + int32_t lineNumber_ {0}; + int32_t columnNumber_ {0}; +}; +class LocationRange { +public: + LocationRange() = default; + ~LocationRange() override = default; + + static std::unique_ptr Create(const PtJson ¶ms); + std::unique_ptr ToJson() const override; + + ScriptId GetScriptId() const + { + return scriptId_; + } + + LocationRange &SetScriptId(ScriptId scriptId) + { + scriptId_ = scriptId; + return *this; + } + + ScriptPosition *GetStart() const + { + return start_.get(); + } + + LocationRange &SetStart(std::unique_ptr start) + { + start_ = std::move(start); + return *this; + } + + ScriptPosition *GetEnd() const + { + return end_.get(); + } + + LocationRange &SetEnd(std::unique_ptr end) + { + end_ = std::move(end); + return *this; + } + +private: + NO_COPY_SEMANTIC(LocationRange); + NO_MOVE_SEMANTIC(LocationRange); + + ScriptId scriptId_ {0}; + std::unique_ptr start_ {nullptr}; + std::unique_ptr end_ {nullptr}; +}; +} //OHOS::ArkCompiler::Toolchain \ No newline at end of file diff --git a/tooling/client/toolchain_cli/cli_command.cpp b/tooling/client/toolchain_cli/cli_command.cpp index 8f93537f..c069a357 100644 --- a/tooling/client/toolchain_cli/cli_command.cpp +++ b/tooling/client/toolchain_cli/cli_command.cpp @@ -135,7 +135,7 @@ void CliCommand::CreateCommandMap() std::bind(&CliCommand::CpuProfileCommand, this, "cpuprofile-disable")}, {std::make_pair("runtime-enable","rt-enable"), std::bind(&CliCommand::RuntimeCommand, this, "runtime-enable")}, {std::make_pair("heapusage","hu"), std::bind(&CliCommand::RuntimeCommand, this, "heapusage")}, - {std::make_pair("break","b"), std::bind(&CliCommand::DebuggerCommand, this, "break")}, + {std::make_pair("break","b"), std::bind(&CliCommand::BreakCommand, this, "break")}, {std::make_pair("backtrack","bt"), std::bind(&CliCommand::DebuggerCommand, this, "backtrack")}, {std::make_pair("continue","c"), std::bind(&CliCommand::DebuggerCommand, this, "continue")}, {std::make_pair("delete","d"), std::bind(&CliCommand::DebuggerCommand, this, "delete")}, @@ -180,7 +180,27 @@ ErrCode CliCommand::HeapProfilerCommand(const std::string cmd) } return ERR_OK; } - +ErrCode CliCommand::BreakCommand(const std::string cmd) +{ + std::cout << "exe success, input linenumber:" << cmd << std::endl; + std::string request; + int32_t linenumber; + cin>>linenumber; + bool result = false; + LOGE("BreakCommand: %{public}d", id_); + result = breaklocation_.DispatcherCmd(id_, cmd, &request,linenumber); + if (result) { + cliSocket_->ClientSendReq(request); + std::string domain; + std::lock_guard lock(cliSocket_->idDomainMutex_); + if (!cliSocket_->GetDomainById(id_, &domain)) { + cliSocket_->SetDomainById(id_, "HeapProfiler"); + } + } else { + return ERR_FAIL; + } + return ERR_OK; +} ErrCode CliCommand::CpuProfileCommand(const std::string cmd) { return ERR_OK; @@ -188,6 +208,7 @@ ErrCode CliCommand::CpuProfileCommand(const std::string cmd) ErrCode CliCommand::DebuggerCommand(const std::string cmd) { + return ERR_OK; } diff --git a/tooling/client/toolchain_cli/cli_command.h b/tooling/client/toolchain_cli/cli_command.h index 2ea9e2a3..dc9c3e87 100644 --- a/tooling/client/toolchain_cli/cli_command.h +++ b/tooling/client/toolchain_cli/cli_command.h @@ -24,7 +24,7 @@ #include "log_wrapper.h" #include "websocket/websocket_client.h" #include "domain/heapprofiler_client.h" - +#include "manager/breakpoint_manager.h" namespace OHOS::ArkCompiler::Toolchain{ using ErrCode = int; using StrPair = std::pair; @@ -38,6 +38,7 @@ class CliCommand { public: CliCommand(ToolchainWebsocket* cliSocket, std::vector cliCmdStr, int cmdId) { + cliSocket_ = std::move(cliSocket); id_ = cmdId; cmd_ = cliCmdStr[0]; @@ -58,6 +59,7 @@ public: ErrCode CpuProfileCommand(const std::string cmd); ErrCode RuntimeCommand(const std::string cmd); ErrCode ExecHelpCommand(); + ErrCode BreakCommand(const std::string cmd,const int32_t linenumber); ToolchainWebsocket* GetCliSocket() const { @@ -76,6 +78,7 @@ private: std::string resultReceiver_ = ""; ToolchainWebsocket* cliSocket_ {nullptr}; HeapProfilerClient heapProfilerCli_; + Breaklocation breaklocation_; uint32_t id_ = 0; }; } // namespace OHOS::ArkCompiler::Toolchain diff --git a/tooling/client/toolchain_cli/main.cpp b/tooling/client/toolchain_cli/main.cpp index b1a1be72..89def4b6 100644 --- a/tooling/client/toolchain_cli/main.cpp +++ b/tooling/client/toolchain_cli/main.cpp @@ -121,4 +121,4 @@ int Main(const int argc, const char** argv) int main(int argc, const char **argv) { return OHOS::ArkCompiler::Toolchain::Main(argc, argv); -} +} \ No newline at end of file -- Gitee