feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
126d1d009e64bc39529cd1a118ad8c22e9f7fdfe
qt-creator/src/plugins/baremetal/debugservers/gdb/stlinkutilgdbserverprovider.cpp

320 lines
11 KiB
C++
Raw Normal View History

Use SPDX license identifiers Replace the current license disclaimer in files by a SPDX-License-Identifier. Task-number: QTBUG-67283 Change-Id: I708fd1f9f2b73d60f57cc3568646929117825813 Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2022-08-19 15:59:36 +02:00
// Copyright (C) 2016 Denis Shienkov <denis.shienkov@gmail.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
bare-metal: Refactor the plugin code a bit more * An include files and forward declarations are sorted in an alphabetical order. * Used the 'final' keywords for the methods and classes which not should be overridden. * Used the 'auto' and 'explicit' keywords more. * A class members are initialized in an initializier list. Change-Id: Ia74783e47aff92467d696d471760b5a97bca3d7a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 13:49:19 +03:00
#include "stlinkutilgdbserverprovider.h"
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
#include <baremetal/baremetalconstants.h>
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
#include <baremetal/baremetaltr.h>
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
#include <baremetal/debugserverprovidermanager.h>
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
#include <utils/filepath.h>
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
#include <utils/pathchooser.h>
#include <utils/qtcassert.h>
Utils/ProjectExplorer: Move re-usabled bits of aspects to Utils Classes involved are BaseAspect and some derived classes, LayoutBuilder and VariableChooser. This is mostly mechanical, with various include/using changes to make it compile. Change-Id: I624a457f3555f102e541c4c71e33a9423af32250 Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2020-09-18 12:11:40 +02:00
#include <utils/variablechooser.h>
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
bare-metal: Refactor the plugin code a bit more * An include files and forward declarations are sorted in an alphabetical order. * Used the 'final' keywords for the methods and classes which not should be overridden. * Used the 'auto' and 'explicit' keywords more. * A class members are initialized in an initializier list. Change-Id: Ia74783e47aff92467d696d471760b5a97bca3d7a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 13:49:19 +03:00
#include <QCheckBox>
#include <QComboBox>
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
#include <QFormLayout>
#include <QPlainTextEdit>
bare-metal: Refactor the plugin code a bit more * An include files and forward declarations are sorted in an alphabetical order. * Used the 'final' keywords for the methods and classes which not should be overridden. * Used the 'auto' and 'explicit' keywords more. * A class members are initialized in an initializier list. Change-Id: Ia74783e47aff92467d696d471760b5a97bca3d7a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 13:49:19 +03:00
#include <QSpinBox>
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
using namespace Utils;
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
namespace BareMetal::Internal {
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
BareMetal: Remove qualifiers from setting keys They're pure noise, since there should be no conflicts between base and derived classes, and there can't be multiple classes for the same provider. This maintains compatibility when upgrading from earlier versions, but not for downgrades. Change-Id: I02655410172ff170fca4893f7b37c2fb1f316aff Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: hjk <hjk@qt.io>
2020-10-26 10:38:59 +02:00
const char executableFileKeyC[] = "ExecutableFile";
const char verboseLevelKeyC[] = "VerboseLevel";
const char extendedModeKeyC[] = "ExtendedMode";
const char resetBoardKeyC[] = "ResetBoard";
const char transportLayerKeyC[] = "TransportLayer";
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
const char connectUnderResetKeyC[] = "ConnectUnderReset";
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
bare-metal: Refactor the plugin code a bit more * An include files and forward declarations are sorted in an alphabetical order. * Used the 'final' keywords for the methods and classes which not should be overridden. * Used the 'auto' and 'explicit' keywords more. * A class members are initialized in an initializier list. Change-Id: Ia74783e47aff92467d696d471760b5a97bca3d7a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 13:49:19 +03:00
// StLinkUtilGdbServerProvider
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
StLinkUtilGdbServerProvider::StLinkUtilGdbServerProvider()
BareMetal: Add 'GDBSERVER' prefix to GDB-specific provider identifiers Change-Id: I511664932e2cc102e30ac6a2087f0f8e6db56bc3 Reviewed-by: hjk <hjk@qt.io>
2019-11-27 15:49:55 +03:00
: GdbServerProvider(Constants::GDBSERVER_STLINK_UTIL_PROVIDER_ID)
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
setInitCommands(defaultInitCommands());
setResetCommands(defaultResetCommands());
BareMetal: Share the 'channel' property for all providers Change-Id: I619d0ced6231ab57a4ac556f50030112295c58ea Reviewed-by: hjk <hjk@qt.io>
2019-11-28 16:20:38 +03:00
setChannel("localhost", 4242);
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
setTypeDisplayName(Tr::tr("ST-LINK Utility"));
BareMetal: De-virtualize IDebugServerProvider::createConfigWidget There is no change in functionality intended. The original version is good in principle, but Creator core has been moving to use this 'setFoo(std::function<>)' pattern during the last year, greatly reducing the need for boilerplate on the "user" side. The effect isn't as significant here, but generally I don't want to use too many different patterns being used. Change-Id: I3ec8c677c19c1ed3f8145e0c3cba337dff7ce1cf Reviewed-by: Christian Stenger <christian.stenger@qt.io> Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com>
2019-12-12 17:41:43 +01:00
setConfigurationWidgetCreator([this] { return new StLinkUtilGdbServerProviderConfigWidget(this); });
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
QString StLinkUtilGdbServerProvider::defaultInitCommands()
{
Baremetal: Fix compile for gcc 5.3 Change-Id: I6ea72b878039229f9f6f00df7eedf997cae3a4a7 Reviewed-by: David Schulz <david.schulz@qt.io> Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com>
2019-11-05 10:06:31 +01:00
return {"load\n"};
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
QString StLinkUtilGdbServerProvider::defaultResetCommands()
{
bare-metal: Return initializier lists instead of ctors Change-Id: Ifc764130ca9c20f77ae1e1549fddba41a900150a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 14:42:54 +03:00
return {};
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
QString StLinkUtilGdbServerProvider::channelString() const
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
switch (startupMode()) {
case StartupOnNetwork:
// Just return as "host:port" form.
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
return GdbServerProvider::channelString();
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
case StartupOnPipe:
// Unsupported mode
bare-metal: Return initializier lists instead of ctors Change-Id: Ifc764130ca9c20f77ae1e1549fddba41a900150a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 14:42:54 +03:00
return {};
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
default: // wrong
bare-metal: Return initializier lists instead of ctors Change-Id: Ifc764130ca9c20f77ae1e1549fddba41a900150a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 14:42:54 +03:00
return {};
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
}
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
CommandLine StLinkUtilGdbServerProvider::command() const
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
CommandLine cmd{m_executableFile, {}};
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
if (m_extendedMode)
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
cmd.addArg("--multi");
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
if (!m_resetBoard)
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
cmd.addArg("--no-reset");
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
BareMetal: Allow stlink_version to stay unspecified Fixes: QTCREATORBUG-26928 Change-Id: Ia6dedb62c1e41472e176d8d247c7967fe5a430ee Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2022-01-26 10:19:53 +01:00
if (m_transport != UnspecifiedTransport)
cmd.addArg("--stlink_version=" + QString::number(m_transport));
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
if (m_connectUnderReset)
cmd.addArg("--connect-under-reset");
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
cmd.addArg("--listen_port=" + QString::number(channel().port()));
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
cmd.addArg("--verbose=" + QString::number(m_verboseLevel));
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
BareMetal: Use Utils::CommandLine for gdbserver things Change-Id: Idf0793636d58b1c6f93a64c94ce5c2b11e4694ce Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-06-04 10:17:06 +02:00
return cmd;
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
BareMetal: Get rid of GdbServerProvider::NoStartup mode This mode is useless, has not sense, and complicates a code handling. A more useful equivalent for this mode is "Debug->Start Debugging->Attach to Running Debug Server". Change-Id: I863dbc5c41ca82db52792a3ff2a1eae16f8e7afd Reviewed-by: hjk <hjk@qt.io>
2019-11-26 17:41:39 +03:00
QSet<GdbServerProvider::StartupMode>
StLinkUtilGdbServerProvider::supportedStartupModes() const
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
BareMetal: Get rid of GdbServerProvider::NoStartup mode This mode is useless, has not sense, and complicates a code handling. A more useful equivalent for this mode is "Debug->Start Debugging->Attach to Running Debug Server". Change-Id: I863dbc5c41ca82db52792a3ff2a1eae16f8e7afd Reviewed-by: hjk <hjk@qt.io>
2019-11-26 17:41:39 +03:00
return {StartupOnNetwork};
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
bool StLinkUtilGdbServerProvider::isValid() const
{
if (!GdbServerProvider::isValid())
return false;
const StartupMode m = startupMode();
BareMetal: Get rid of GdbServerProvider::NoStartup mode This mode is useless, has not sense, and complicates a code handling. A more useful equivalent for this mode is "Debug->Start Debugging->Attach to Running Debug Server". Change-Id: I863dbc5c41ca82db52792a3ff2a1eae16f8e7afd Reviewed-by: hjk <hjk@qt.io>
2019-11-26 17:41:39 +03:00
if (m == StartupOnNetwork) {
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
if (channel().host().isEmpty())
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
return false;
}
if (m == StartupOnNetwork) {
if (m_executableFile.isEmpty())
return false;
}
return true;
}
QVariantMap StLinkUtilGdbServerProvider::toMap() const
{
QVariantMap data = GdbServerProvider::toMap();
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
data.insert(executableFileKeyC, m_executableFile.toVariant());
data.insert(verboseLevelKeyC, m_verboseLevel);
data.insert(extendedModeKeyC, m_extendedMode);
data.insert(resetBoardKeyC, m_resetBoard);
data.insert(transportLayerKeyC, m_transport);
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
data.insert(connectUnderResetKeyC, m_connectUnderReset);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
return data;
}
bool StLinkUtilGdbServerProvider::fromMap(const QVariantMap &data)
{
if (!GdbServerProvider::fromMap(data))
return false;
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
m_executableFile = FilePath::fromVariant(data.value(executableFileKeyC));
m_verboseLevel = data.value(verboseLevelKeyC).toInt();
m_extendedMode = data.value(extendedModeKeyC).toBool();
m_resetBoard = data.value(resetBoardKeyC).toBool();
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_transport = static_cast<TransportLayer>(
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
data.value(transportLayerKeyC).toInt());
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
m_connectUnderReset = data.value(connectUnderResetKeyC).toBool();
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
return true;
}
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
bool StLinkUtilGdbServerProvider::operator==(const IDebugServerProvider &other) const
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
if (!GdbServerProvider::operator==(other))
return false;
const auto p = static_cast<const StLinkUtilGdbServerProvider *>(&other);
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
return m_executableFile == p->m_executableFile
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
&& m_verboseLevel == p->m_verboseLevel
&& m_extendedMode == p->m_extendedMode
&& m_resetBoard == p->m_resetBoard
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
&& m_transport == p->m_transport
&& m_connectUnderReset == p->m_connectUnderReset;
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
bare-metal: Refactor the plugin code a bit more * An include files and forward declarations are sorted in an alphabetical order. * Used the 'final' keywords for the methods and classes which not should be overridden. * Used the 'auto' and 'explicit' keywords more. * A class members are initialized in an initializier list. Change-Id: Ia74783e47aff92467d696d471760b5a97bca3d7a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 13:49:19 +03:00
// StLinkUtilGdbServerProviderFactory
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
StLinkUtilGdbServerProviderFactory::StLinkUtilGdbServerProviderFactory()
{
BareMetal: Add 'GDBSERVER' prefix to GDB-specific provider identifiers Change-Id: I511664932e2cc102e30ac6a2087f0f8e6db56bc3 Reviewed-by: hjk <hjk@qt.io>
2019-11-27 15:49:55 +03:00
setId(Constants::GDBSERVER_STLINK_UTIL_PROVIDER_ID);
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
setDisplayName(Tr::tr("ST-LINK Utility"));
BareMetal: De-virtualize IDebugServerProviderFactory::create() Change-Id: I09a1953cf542f6c2cd68d05bb0f171b327d56cae Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2019-12-12 18:01:53 +01:00
setCreator([] { return new StLinkUtilGdbServerProvider; });
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
bare-metal: Refactor the plugin code a bit more * An include files and forward declarations are sorted in an alphabetical order. * Used the 'final' keywords for the methods and classes which not should be overridden. * Used the 'auto' and 'explicit' keywords more. * A class members are initialized in an initializier list. Change-Id: Ia74783e47aff92467d696d471760b5a97bca3d7a Reviewed-by: hjk <hjk@qt.io>
2019-05-08 13:49:19 +03:00
// StLinkUtilGdbServerProviderConfigWidget
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
StLinkUtilGdbServerProviderConfigWidget::StLinkUtilGdbServerProviderConfigWidget(
StLinkUtilGdbServerProvider *p)
: GdbServerProviderConfigWidget(p)
{
Q_ASSERT(p);
m_hostWidget = new HostWidget(this);
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_mainLayout->addRow(Tr::tr("Host:"), m_hostWidget);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_executableFileChooser = new Utils::PathChooser;
m_executableFileChooser->setExpectedKind(Utils::PathChooser::ExistingCommand);
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_mainLayout->addRow(Tr::tr("Executable file:"), m_executableFileChooser);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_verboseLevelSpinBox = new QSpinBox;
m_verboseLevelSpinBox->setRange(0, 99);
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_verboseLevelSpinBox->setToolTip(Tr::tr("Specify the verbosity level (0..99)."));
m_mainLayout->addRow(Tr::tr("Verbosity level:"), m_verboseLevelSpinBox);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_extendedModeCheckBox = new QCheckBox;
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_extendedModeCheckBox->setToolTip(Tr::tr("Continue listening for connections "
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
"after disconnect."));
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_mainLayout->addRow(Tr::tr("Extended mode:"), m_extendedModeCheckBox);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_resetBoardCheckBox = new QCheckBox;
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_resetBoardCheckBox->setToolTip(Tr::tr("Reset board on connection."));
m_mainLayout->addRow(Tr::tr("Reset on connection:"), m_resetBoardCheckBox);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
m_resetOnConnectCheckBox = new QCheckBox;
m_resetOnConnectCheckBox->setToolTip(Tr::tr("Connects to the board before "
"executing any instructions."));
m_mainLayout->addRow(Tr::tr("Connect under reset:"), m_resetOnConnectCheckBox);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_transportLayerComboBox = new QComboBox;
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_transportLayerComboBox->setToolTip(Tr::tr("Transport layer type."));
m_mainLayout->addRow(Tr::tr("Version:"), m_transportLayerComboBox);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_initCommandsTextEdit = new QPlainTextEdit(this);
m_initCommandsTextEdit->setToolTip(defaultInitCommandsTooltip());
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_mainLayout->addRow(Tr::tr("Init commands:"), m_initCommandsTextEdit);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_resetCommandsTextEdit = new QPlainTextEdit(this);
m_resetCommandsTextEdit->setToolTip(defaultResetCommandsTooltip());
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_mainLayout->addRow(Tr::tr("Reset commands:"), m_resetCommandsTextEdit);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
populateTransportLayers();
addErrorLabel();
setFromProvider();
Utils/ProjectExplorer: Move re-usabled bits of aspects to Utils Classes involved are BaseAspect and some derived classes, LayoutBuilder and VariableChooser. This is mostly mechanical, with various include/using changes to make it compile. Change-Id: I624a457f3555f102e541c4c71e33a9423af32250 Reviewed-by: Eike Ziller <eike.ziller@qt.io>
2020-09-18 12:11:40 +02:00
const auto chooser = new VariableChooser(this);
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
chooser->addSupportedWidget(m_initCommandsTextEdit);
chooser->addSupportedWidget(m_resetCommandsTextEdit);
baremetal: add variable chooser to gdb server provider dialogs Change-Id: Iaefbebaed43afb73f8b0c7ade4de38c7e33719ff Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2015-02-04 08:12:01 +01:00
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
connect(m_hostWidget, &HostWidget::dataChanged,
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
this, &GdbServerProviderConfigWidget::dirty);
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
connect(m_executableFileChooser, &Utils::PathChooser::rawPathChanged,
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
this, &GdbServerProviderConfigWidget::dirty);
Drop Qt5: BareMetal: Get rid of QOverload Change-Id: I023dee34b3b3556376c3cad5cbff919e6a85769c Reviewed-by: hjk <hjk@qt.io>
2022-07-19 22:46:47 +02:00
connect(m_verboseLevelSpinBox, &QSpinBox::valueChanged,
BareMetal: Modernize connections Change-Id: I1d504da25b44dc60be7dca2b07f5eadbc437826c Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Christian Stenger <christian.stenger@theqtcompany.com>
2015-06-09 10:46:54 +02:00
this, &GdbServerProviderConfigWidget::dirty);
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
connect(m_extendedModeCheckBox, &QAbstractButton::clicked,
BareMetal: Modernize connections Change-Id: I1d504da25b44dc60be7dca2b07f5eadbc437826c Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Christian Stenger <christian.stenger@theqtcompany.com>
2015-06-09 10:46:54 +02:00
this, &GdbServerProviderConfigWidget::dirty);
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
connect(m_resetBoardCheckBox, &QAbstractButton::clicked,
BareMetal: Modernize connections Change-Id: I1d504da25b44dc60be7dca2b07f5eadbc437826c Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Christian Stenger <christian.stenger@theqtcompany.com>
2015-06-09 10:46:54 +02:00
this, &GdbServerProviderConfigWidget::dirty);
Drop Qt5: BareMetal: Get rid of QOverload Change-Id: I023dee34b3b3556376c3cad5cbff919e6a85769c Reviewed-by: hjk <hjk@qt.io>
2022-07-19 22:46:47 +02:00
connect(m_transportLayerComboBox, &QComboBox::currentIndexChanged,
BareMetal: Modernize connections Change-Id: I1d504da25b44dc60be7dca2b07f5eadbc437826c Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Christian Stenger <christian.stenger@theqtcompany.com>
2015-06-09 10:46:54 +02:00
this, &GdbServerProviderConfigWidget::dirty);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
connect(m_initCommandsTextEdit, &QPlainTextEdit::textChanged,
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
this, &GdbServerProviderConfigWidget::dirty);
BareMetal: Do not use QPointer if it is not required Change-Id: Ib7162ae6b40d06bfb54705fd4b53bde2ce78083c Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com> Reviewed-by: Tim Sander <tim@krieglstein.org> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-11-29 18:38:21 +03:00
connect(m_resetCommandsTextEdit, &QPlainTextEdit::textChanged,
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
this, &GdbServerProviderConfigWidget::dirty);
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
connect(m_resetOnConnectCheckBox, &QAbstractButton::clicked,
this, &GdbServerProviderConfigWidget::dirty);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
void StLinkUtilGdbServerProviderConfigWidget::apply()
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
const auto p = static_cast<StLinkUtilGdbServerProvider *>(m_provider);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
Q_ASSERT(p);
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
p->setChannel(m_hostWidget->channel());
Utils: Rename PathChooser::{f,setF}ileName() to {f,setF}ilePath() It's returning a FilePath, so it's a better fit. Keep the old versions as inline function now to ease downstream migration. Change-Id: I535887928018f42b92895c8b0c82527f0d55e5ca Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: André Hartmann <aha_1980@gmx.de>
2020-04-09 11:05:50 +02:00
p->m_executableFile = m_executableFileChooser->filePath();
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
p->m_verboseLevel = m_verboseLevelSpinBox->value();
p->m_extendedMode = m_extendedModeCheckBox->isChecked();
p->m_resetBoard = m_resetBoardCheckBox->isChecked();
p->m_transport = transportLayer();
p->setInitCommands(m_initCommandsTextEdit->toPlainText());
p->setResetCommands(m_resetCommandsTextEdit->toPlainText());
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
p->m_connectUnderReset = m_resetOnConnectCheckBox->isChecked();
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
GdbServerProviderConfigWidget::apply();
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
void StLinkUtilGdbServerProviderConfigWidget::discard()
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
{
setFromProvider();
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
GdbServerProviderConfigWidget::discard();
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
StLinkUtilGdbServerProvider::TransportLayer
StLinkUtilGdbServerProviderConfigWidget::transportLayerFromIndex(int idx) const
{
return static_cast<StLinkUtilGdbServerProvider::TransportLayer>(
m_transportLayerComboBox->itemData(idx).toInt());
}
StLinkUtilGdbServerProvider::TransportLayer
StLinkUtilGdbServerProviderConfigWidget::transportLayer() const
{
const int idx = m_transportLayerComboBox->currentIndex();
return transportLayerFromIndex(idx);
}
void StLinkUtilGdbServerProviderConfigWidget::setTransportLayer(
StLinkUtilGdbServerProvider::TransportLayer tl)
{
for (int idx = 0; idx < m_transportLayerComboBox->count(); ++idx) {
if (tl == transportLayerFromIndex(idx)) {
m_transportLayerComboBox->setCurrentIndex(idx);
break;
}
}
}
void StLinkUtilGdbServerProviderConfigWidget::populateTransportLayers()
{
m_transportLayerComboBox->insertItem(
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_transportLayerComboBox->count(), Tr::tr("ST-LINK/V1"),
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
StLinkUtilGdbServerProvider::ScsiOverUsb);
m_transportLayerComboBox->insertItem(
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_transportLayerComboBox->count(), Tr::tr("ST-LINK/V2"),
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
StLinkUtilGdbServerProvider::RawUsb);
BareMetal: Allow stlink_version to stay unspecified Fixes: QTCREATORBUG-26928 Change-Id: Ia6dedb62c1e41472e176d8d247c7967fe5a430ee Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2022-01-26 10:19:53 +01:00
m_transportLayerComboBox->insertItem(
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
m_transportLayerComboBox->count(), Tr::tr("Keep unspecified"),
BareMetal: Allow stlink_version to stay unspecified Fixes: QTCREATORBUG-26928 Change-Id: Ia6dedb62c1e41472e176d8d247c7967fe5a430ee Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2022-01-26 10:19:53 +01:00
StLinkUtilGdbServerProvider::UnspecifiedTransport);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
void StLinkUtilGdbServerProviderConfigWidget::setFromProvider()
{
BareMetal: Minimize dependency from GDB engine The problem is that this plugin was originally developed only for working with the GDB debugging engine. This hard dependency penetrates to all plugin logic, that excludes an easy addition of other types of a debugger engines. This patch tries to minimize the GDB dependency and improves code a bit in the following way: * A code that belongs to the GDB engine moved to the separate debugservers/gdb directory. * A classes having a common functionality are renamed with 'Debug' suffixes instead of 'Gdb' suffixes. * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget} whih are used as a base for all derived debug servers providers (e.g. for the OpenOCD, STLink and etc). * The IDebugServerProvider interface has a new virtual engineType() method to show a supported debugger engine by a specific debugger server provider. This method is used in BareMetalDebugSupport class to detect a provider engine for an additional initialization (which depends on an used debugger engine). * The IDebugServerProvider interface has a new virtual hasProcess() method. E.g. this is required for a future debug server providers which has not a remote processes. In this case the BareMetalDevice::canCreateProcess() will report about that in a right way. Thus, this approach allowed us to preserve a previous behavior of an already implemented GDB providers. Also it makes possible to add a new providers in a future with a minimized costs. Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f Reviewed-by: hjk <hjk@qt.io>
2019-11-04 00:51:58 +03:00
const auto p = static_cast<StLinkUtilGdbServerProvider *>(m_provider);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
Q_ASSERT(p);
bare-metal: Add missed 'const' keywords Change-Id: I109a4df799a06f11381a49a32bdd7a56c4d9dff1 Reviewed-by: hjk <hjk@qt.io>
2019-05-08 16:18:16 +03:00
const QSignalBlocker blocker(this);
BareMetal: Streamline GdbServerProvider code Combine host and port values in a url object which is elsewhere typically used, and move the member to the base class as all current providers have something like that. Base typeDisplayName on a datamember, and provide a reusable base implementation of channelString() Change-Id: Iedac09bb80d0bc1818cd88b0de99794e951999b8 Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com> Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-07-23 16:29:33 +02:00
m_hostWidget->setChannel(p->channel());
Utils: Rename PathChooser::{f,setF}ileName() to {f,setF}ilePath() It's returning a FilePath, so it's a better fit. Keep the old versions as inline function now to ease downstream migration. Change-Id: I535887928018f42b92895c8b0c82527f0d55e5ca Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: André Hartmann <aha_1980@gmx.de>
2020-04-09 11:05:50 +02:00
m_executableFileChooser->setFilePath(p->m_executableFile);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
m_verboseLevelSpinBox->setValue(p->m_verboseLevel);
m_extendedModeCheckBox->setChecked(p->m_extendedMode);
m_resetBoardCheckBox->setChecked(p->m_resetBoard);
setTransportLayer(p->m_transport);
m_initCommandsTextEdit->setPlainText(p->initCommands());
m_resetCommandsTextEdit->setPlainText(p->resetCommands());
Baremetal: Add st-util --connect-under-reset option Task-number: QTCREATORBUG-26958 Change-Id: I39d39204f2fc848e653b8df1a19c8810325ba8a1 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu> Reviewed-by: hjk <hjk@qt.io>
2022-11-01 14:14:31 +01:00
m_resetOnConnectCheckBox->setChecked(p->m_connectUnderReset);
BareMetal: Allow to manage configurations of HW GDB servers The user has only one possibility to setup of the remote GDB server when a new device is created (or to modify it for existing device). It is possible only in the host/port fields for connection to the GDB server. It is a little inconvenient for the user. If the user wants to use other configuration of the GDB server, then need every time to edit the current configuration. Improving this it is introduction a new concept with a new entity named as "GDB server provider". Now to the device debugging purpose the user can choose any of the GDB provider from the list (by analogy with toolchain and so on). Each configuration of GDB provider is created by the user manually on the new "GDB Server Provider" options page. This can be made before or after creation of device. A GDB server provider can work in three startup modes (depends on implementation of concrete provider): 1) NoStartup mode. This means that we do not want to startup a provider, we just trying to connect to the already started GDB provider server. This mode uses the TCP/IP connection with manually specifying of remote host and port. 2) StartupOnNetwork mode. This means that we want to launch of the GDB provider automatically before connect to it in process of remote debugging. This mode also uses the TCP/IP protocol. In addition to it, a GDB provider can has additional options which are contains a paths to provider executable file, to configuration files and so on (it is depends on concrete provider implementation). This mode (with NoStartup) covers about 90% of usecase, and is supported by most set of the GDB server providers. 3) StartupOnPipe mode. This is similar to StartupOnNetwork mode and we also automatically starts the GDB server provider before debugging. But in this case is used the Pipe mode instead of TCP/IP. Not each of the GDB provider can support debugging via pipes. This patch has concrete implementations for a following set of the GDB server providers: * "Default" provider which supports only the NoStartup mode. * "Open On-Chip Debugger" (http://openocd.sourceforge.net/) provider which supports all modes. * "STLinkUtil" (https://github.com/texane/stlink) provider which supports NoStartup and StartupOnNetwork modes. Tested on Windows and Linux with: * target HW: ARM Stm32F4Discovery board with HW debugger STLink-v2 * provider: OpenOCD v0.8.0 (tested on Windows and Linux) * provider: STLink-Util (tested on Linux only) * toolchain: ARM GCC v4.9.2 * debugger: GDB v7.8.1 (with Python support) * QtCreator with QBS project Task-number: QTCREATORBUG-13686 Change-Id: I59c775d91b0a4227d931188879850c536290e1ba Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: hjk <hjk@theqtcompany.com>
2014-12-20 19:10:02 +00:00
}
BareMetal: Convert to Tr::tr Change-Id: I7ac423c13d95b33cad332d2ce9fafb4f658980bc Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
2022-10-10 14:36:17 +02:00
} // ProjectExplorer::Internal
Copy Permalink