X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fserver%2Fgdb_server.c;h=f5eb71da449d2a3ef6ca758434cd7beee5b870d6;hp=4d20a7dfee1fb22f4d1081efdbfa98508d9ab1cc;hb=7bf1a86e473a12882bf6f71cb4d0d416394b69d4;hpb=53bfd73591037044b391dd9a849e77284a7932d1

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 4d20a7dfee..f5eb71da44 100644
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -27,11 +27,12 @@
 #include "config.h"
 #endif
 
-#include "gdb_server.h"
+#include "breakpoints.h"
 #include "target_request.h"
 #include "register.h"
 #include "server.h"
 #include "flash.h"
+#include "gdb_server.h"
 #include "image.h"
 #include "jtag.h"
 
@@ -45,7 +46,7 @@ static struct gdb_connection *current_gdb_connection;
 static int gdb_breakpoint_override;
 static enum breakpoint_type gdb_breakpoint_override_type;
 
-extern int gdb_error(connection_t *connection, int retval);
+extern int gdb_error(struct connection *connection, int retval);
 static unsigned short gdb_port = 3333;
 static const char *DIGITS = "0123456789abcdef";
 
@@ -67,7 +68,7 @@ int gdb_flash_program = 1;
  * see the code in gdb_read_memory_packet() for further explanations */
 int gdb_report_data_abort = 0;
 
-int gdb_last_signal(target_t *target)
+int gdb_last_signal(struct target *target)
 {
 	switch (target->debug_reason)
 	{
@@ -87,7 +88,7 @@ int gdb_last_signal(target_t *target)
 	}
 }
 
-int check_pending(connection_t *connection, int timeout_s, int *got_data)
+int check_pending(struct connection *connection, int timeout_s, int *got_data)
 {
 	/* a non-blocking socket will block if there is 0 bytes available on the socket,
 	 * but return with as many bytes as are available immediately
@@ -128,7 +129,7 @@ int check_pending(connection_t *connection, int timeout_s, int *got_data)
 	return ERROR_OK;
 }
 
-int gdb_get_char(connection_t *connection, int* next_char)
+int gdb_get_char(struct connection *connection, int* next_char)
 {
 	struct gdb_connection *gdb_con = connection->priv;
 	int retval = ERROR_OK;
@@ -236,7 +237,7 @@ int gdb_get_char(connection_t *connection, int* next_char)
 	return retval;
 }
 
-int gdb_putback_char(connection_t *connection, int last_char)
+int gdb_putback_char(struct connection *connection, int last_char)
 {
 	struct gdb_connection *gdb_con = connection->priv;
 
@@ -256,7 +257,7 @@ int gdb_putback_char(connection_t *connection, int last_char)
 /* The only way we can detect that the socket is closed is the first time
  * we write to it, we will fail. Subsequent write operations will
  * succeed. Shudder! */
-int gdb_write(connection_t *connection, void *data, int len)
+int gdb_write(struct connection *connection, void *data, int len)
 {
 	struct gdb_connection *gdb_con = connection->priv;
 	if (gdb_con->closed)
@@ -281,7 +282,7 @@ int gdb_write(connection_t *connection, void *data, int len)
 	return ERROR_SERVER_REMOTE_CLOSED;
 }
 
-int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
+int gdb_put_packet_inner(struct connection *connection, char *buffer, int len)
 {
 	int i;
 	unsigned char my_checksum = 0;
@@ -422,7 +423,7 @@ int gdb_put_packet_inner(connection_t *connection, char *buffer, int len)
 	return ERROR_OK;
 }
 
-int gdb_put_packet(connection_t *connection, char *buffer, int len)
+int gdb_put_packet(struct connection *connection, char *buffer, int len)
 {
 	struct gdb_connection *gdb_con = connection->priv;
 	gdb_con->busy = 1;
@@ -435,7 +436,7 @@ int gdb_put_packet(connection_t *connection, char *buffer, int len)
 	return retval;
 }
 
-static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, int noack, int *len, char *buffer)
+static __inline__ int fetch_packet(struct connection *connection, int *checksum_ok, int noack, int *len, char *buffer)
 {
 	unsigned char my_checksum = 0;
 	char checksum[3];
@@ -544,7 +545,7 @@ static __inline__ int fetch_packet(connection_t *connection, int *checksum_ok, i
 	return ERROR_OK;
 }
 
-int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
+int gdb_get_packet_inner(struct connection *connection, char *buffer, int *len)
 {
 	int character;
 	int retval;
@@ -619,7 +620,7 @@ int gdb_get_packet_inner(connection_t *connection, char *buffer, int *len)
 	return ERROR_OK;
 }
 
-int gdb_get_packet(connection_t *connection, char *buffer, int *len)
+int gdb_get_packet(struct connection *connection, char *buffer, int *len)
 {
 	struct gdb_connection *gdb_con = connection->priv;
 	gdb_con->busy = 1;
@@ -628,7 +629,7 @@ int gdb_get_packet(connection_t *connection, char *buffer, int *len)
 	return retval;
 }
 
-int gdb_output_con(connection_t *connection, const char* line)
+int gdb_output_con(struct connection *connection, const char* line)
 {
 	char *hex_buffer;
 	int i, bin_size;
@@ -650,7 +651,7 @@ int gdb_output_con(connection_t *connection, const char* line)
 	return retval;
 }
 
-int gdb_output(struct command_context_s *context, const char* line)
+int gdb_output(struct command_context *context, const char* line)
 {
 	/* this will be dumped to the log and also sent as an O packet if possible */
 	LOG_USER_N("%s", line);
@@ -658,7 +659,7 @@ int gdb_output(struct command_context_s *context, const char* line)
 }
 
 
-static void gdb_frontend_halted(struct target_s *target, connection_t *connection)
+static void gdb_frontend_halted(struct target *target, struct connection *connection)
 {
 	struct gdb_connection *gdb_connection = connection->priv;
 
@@ -695,10 +696,10 @@ static void gdb_frontend_halted(struct target_s *target, connection_t *connectio
 	}
 }
 
-int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
+int gdb_target_callback_event_handler(struct target *target, enum target_event event, void *priv)
 {
 	int retval;
-	connection_t *connection = priv;
+	struct connection *connection = priv;
 
 	target_handle_event(target, event);
 	switch (event)
@@ -723,10 +724,10 @@ int gdb_target_callback_event_handler(struct target_s *target, enum target_event
 	return ERROR_OK;
 }
 
-int gdb_new_connection(connection_t *connection)
+int gdb_new_connection(struct connection *connection)
 {
 	struct gdb_connection *gdb_connection = malloc(sizeof(struct gdb_connection));
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
 	int retval;
 	int initial_ack;
 
@@ -779,9 +780,9 @@ int gdb_new_connection(connection_t *connection)
 	return ERROR_OK;
 }
 
-int gdb_connection_closed(connection_t *connection)
+int gdb_connection_closed(struct connection *connection)
 {
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
 	struct gdb_connection *gdb_connection = connection->priv;
 
 	/* we're done forwarding messages. Tear down callback before
@@ -826,14 +827,14 @@ int gdb_connection_closed(connection_t *connection)
 	return ERROR_OK;
 }
 
-void gdb_send_error(connection_t *connection, uint8_t the_error)
+void gdb_send_error(struct connection *connection, uint8_t the_error)
 {
 	char err[4];
 	snprintf(err, 4, "E%2.2X", the_error);
 	gdb_put_packet(connection, err, 3);
 }
 
-int gdb_last_signal_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
+int gdb_last_signal_packet(struct connection *connection, struct target *target, char* packet, int packet_size)
 {
 	char sig_reply[4];
 	int signal;
@@ -846,7 +847,7 @@ int gdb_last_signal_packet(connection_t *connection, target_t *target, char* pac
 	return ERROR_OK;
 }
 
-static int gdb_reg_pos(target_t *target, int pos, int len)
+static int gdb_reg_pos(struct target *target, int pos, int len)
 {
 	if (target->endianness == TARGET_LITTLE_ENDIAN)
 		return pos;
@@ -863,14 +864,14 @@ static int gdb_reg_pos(target_t *target, int pos, int len)
  * The format of reg->value is little endian
  *
  */
-void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
+void gdb_str_to_target(struct target *target, char *tstr, struct reg *reg)
 {
 	int i;
 
 	uint8_t *buf;
 	int buf_len;
 	buf = reg->value;
-	buf_len = CEIL(reg->size, 8);
+	buf_len = DIV_ROUND_UP(reg->size, 8);
 
 	for (i = 0; i < buf_len; i++)
 	{
@@ -896,7 +897,7 @@ static int hextoint(char c)
 }
 
 /* copy over in register buffer */
-void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
+void gdb_target_to_reg(struct target *target, char *tstr, int str_len, uint8_t *bin)
 {
 	if (str_len % 2)
 	{
@@ -915,9 +916,9 @@ void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
 	}
 }
 
-int gdb_get_registers_packet(connection_t *connection, target_t *target, char* packet, int packet_size)
+int gdb_get_registers_packet(struct connection *connection, struct target *target, char* packet, int packet_size)
 {
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
 	int reg_packet_size = 0;
@@ -939,25 +940,25 @@ int gdb_get_registers_packet(connection_t *connection, target_t *target, char* p
 		reg_packet_size += reg_list[i]->size;
 	}
 
-	reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
+	reg_packet = malloc(DIV_ROUND_UP(reg_packet_size, 8) * 2);
 	reg_packet_p = reg_packet;
 
 	for (i = 0; i < reg_list_size; i++)
 	{
 		gdb_str_to_target(target, reg_packet_p, reg_list[i]);
-		reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
+		reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
 	}
 
 #ifdef _DEBUG_GDB_IO_
 	{
 		char *reg_packet_p;
-		reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
+		reg_packet_p = strndup(reg_packet, DIV_ROUND_UP(reg_packet_size, 8) * 2);
 		LOG_DEBUG("reg_packet: %s", reg_packet_p);
 		free(reg_packet_p);
 	}
 #endif
 
-	gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
+	gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_packet_size, 8) * 2);
 	free(reg_packet);
 
 	free(reg_list);
@@ -965,10 +966,10 @@ int gdb_get_registers_packet(connection_t *connection, target_t *target, char* p
 	return ERROR_OK;
 }
 
-int gdb_set_registers_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_registers_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	int i;
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
 	char *packet_p;
@@ -996,21 +997,17 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 	for (i = 0; i < reg_list_size; i++)
 	{
 		uint8_t *bin_buf;
-		int chars = (CEIL(reg_list[i]->size, 8) * 2);
+		int chars = (DIV_ROUND_UP(reg_list[i]->size, 8) * 2);
 
 		if (packet_p + chars > packet + packet_size)
 		{
 			LOG_ERROR("BUG: register packet is too small for registers");
 		}
 
-		reg_arch_type_t *arch_type;
-		bin_buf = malloc(CEIL(reg_list[i]->size, 8));
+		bin_buf = malloc(DIV_ROUND_UP(reg_list[i]->size, 8));
 		gdb_target_to_reg(target, packet_p, chars, bin_buf);
 
-		/* get register arch_type, and call set method */
-		arch_type = register_get_arch_type(reg_list[i]->arch_type);
-
-		arch_type->set(reg_list[i], bin_buf);
+		reg_list[i]->type->set(reg_list[i], bin_buf);
 
 		/* advance packet pointer */
 		packet_p += chars;
@@ -1019,7 +1016,7 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 		free(bin_buf);
 	}
 
-	/* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
+	/* free struct reg *reg_list[] array allocated by get_gdb_reg_list */
 	free(reg_list);
 
 	gdb_put_packet(connection, "OK", 2);
@@ -1027,11 +1024,11 @@ int gdb_set_registers_packet(connection_t *connection, target_t *target, char *p
 	return ERROR_OK;
 }
 
-int gdb_get_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_get_register_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	char *reg_packet;
 	int reg_num = strtoul(packet + 1, NULL, 16);
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
 
@@ -1050,11 +1047,11 @@ int gdb_get_register_packet(connection_t *connection, target_t *target, char *pa
 		exit(-1);
 	}
 
-	reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
+	reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
 	gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
 
-	gdb_put_packet(connection, reg_packet, CEIL(reg_list[reg_num]->size, 8) * 2);
+	gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
 	free(reg_list);
 	free(reg_packet);
@@ -1062,15 +1059,14 @@ int gdb_get_register_packet(connection_t *connection, target_t *target, char *pa
 	return ERROR_OK;
 }
 
-int gdb_set_register_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_register_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint8_t *bin_buf;
 	int reg_num = strtoul(packet + 1, &separator, 16);
-	reg_t **reg_list;
+	struct reg **reg_list;
 	int reg_list_size;
 	int retval;
-	reg_arch_type_t *arch_type;
 
 	LOG_DEBUG("-");
 
@@ -1092,16 +1088,14 @@ int gdb_set_register_packet(connection_t *connection, target_t *target, char *pa
 	}
 
 	/* convert from GDB-string (target-endian) to hex-string (big-endian) */
-	bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));
-	int chars = (CEIL(reg_list[reg_num]->size, 8) * 2);
+	bin_buf = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8));
+	int chars = (DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
 	/* fix!!! add some sanity checks on packet size here */
 
 	gdb_target_to_reg(target, separator + 1, chars, bin_buf);
 
-		/* get register arch_type, and call set method */
-	arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);
-	arch_type->set(reg_list[reg_num], bin_buf);
+	reg_list[reg_num]->type->set(reg_list[reg_num], bin_buf);
 
 	gdb_put_packet(connection, "OK", 2);
 
@@ -1111,7 +1105,7 @@ int gdb_set_register_packet(connection_t *connection, target_t *target, char *pa
 	return ERROR_OK;
 }
 
-int gdb_error(connection_t *connection, int retval)
+int gdb_error(struct connection *connection, int retval)
 {
 	switch (retval)
 	{
@@ -1142,7 +1136,7 @@ int gdb_error(connection_t *connection, int retval)
  *
  * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
  */
-int gdb_read_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_read_memory_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1216,7 +1210,7 @@ int gdb_read_memory_packet(connection_t *connection, target_t *target, char *pac
 	return retval;
 }
 
-int gdb_write_memory_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1273,7 +1267,7 @@ int gdb_write_memory_packet(connection_t *connection, target_t *target, char *pa
 	return retval;
 }
 
-int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_binary_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	char *separator;
 	uint32_t addr = 0;
@@ -1321,7 +1315,7 @@ int gdb_write_memory_binary_packet(connection_t *connection, target_t *target, c
 	return ERROR_OK;
 }
 
-int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_step_continue_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	int current = 0;
 	uint32_t address = 0x0;
@@ -1354,7 +1348,7 @@ int gdb_step_continue_packet(connection_t *connection, target_t *target, char *p
 	return retval;
 }
 
-int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_breakpoint_watchpoint_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	int type;
 	enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
@@ -1520,7 +1514,7 @@ static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len
 	return 0;
 }
 
-int gdb_calc_blocksize(flash_bank_t *bank)
+int gdb_calc_blocksize(struct flash_bank *bank)
 {
 	uint32_t i;
 	uint32_t block_size = 0xffffffff;
@@ -1538,9 +1532,9 @@ int gdb_calc_blocksize(flash_bank_t *bank)
 
 static int compare_bank (const void * a, const void * b)
 {
-	flash_bank_t *b1, *b2;
-	b1=*((flash_bank_t **)a);
-	b2=*((flash_bank_t **)b);
+	struct flash_bank *b1, *b2;
+	b1=*((struct flash_bank **)a);
+	b2=*((struct flash_bank **)b);
 
 	if (b1->base == b2->base)
 	{
@@ -1554,9 +1548,9 @@ static int compare_bank (const void * a, const void * b)
 	}
 }
 
-int gdb_query_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_query_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
-	command_context_t *cmd_ctx = connection->cmd_ctx;
+	struct command_context *cmd_ctx = connection->cmd_ctx;
 	struct gdb_connection *gdb_connection = connection->priv;
 
 	if (strstr(packet, "qRcmd,"))
@@ -1661,7 +1655,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 		 * Normally we only execute this code once, but no big deal if we
 		 * have to regenerate it a couple of times. */
 
-		flash_bank_t *p;
+		struct flash_bank *p;
 		char *xml = NULL;
 		int size = 0;
 		int pos = 0;
@@ -1685,7 +1679,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 		read/write) by default for GDB.
 		GDB does not have a concept of non-cacheable read/write memory.
 		 */
-		flash_bank_t **banks = malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
+		struct flash_bank **banks = malloc(sizeof(struct flash_bank *)*flash_get_bank_count());
 		int i;
 
 		for (i = 0; i < flash_get_bank_count(); i++)
@@ -1701,7 +1695,7 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 			banks[i]=p;
 		}
 
-		qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
+		qsort(banks, flash_get_bank_count(), sizeof(struct flash_bank *), compare_bank);
 
 		uint32_t ram_start = 0;
 		for (i = 0; i < flash_get_bank_count(); i++)
@@ -1810,10 +1804,10 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 	return ERROR_OK;
 }
 
-int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_v_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
 	struct gdb_connection *gdb_connection = connection->priv;
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
 	int result;
 
 	/* if flash programming disabled - send a empty reply */
@@ -1899,7 +1893,7 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
 		/* create a new image if there isn't already one */
 		if (gdb_connection->vflash_image == NULL)
 		{
-			gdb_connection->vflash_image = malloc(sizeof(image_t));
+			gdb_connection->vflash_image = malloc(sizeof(struct image));
 			image_open(gdb_connection->vflash_image, "", "build");
 		}
 
@@ -1947,9 +1941,9 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
 	return ERROR_OK;
 }
 
-int gdb_detach(connection_t *connection, target_t *target)
+int gdb_detach(struct connection *connection, struct target *target)
 {
-	gdb_service_t *gdb_service = connection->service->priv;
+	struct gdb_service *gdb_service = connection->service->priv;
 
 	target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_DETACH);
 
@@ -1959,7 +1953,7 @@ int gdb_detach(connection_t *connection, target_t *target)
 static void gdb_log_callback(void *priv, const char *file, unsigned line,
 		const char *function, const char *string)
 {
-	connection_t *connection = priv;
+	struct connection *connection = priv;
 	struct gdb_connection *gdb_con = connection->priv;
 
 	if (gdb_con->busy)
@@ -1974,7 +1968,7 @@ static void gdb_log_callback(void *priv, const char *file, unsigned line,
 /* Do not allocate this on the stack */
 char gdb_packet_buffer[GDB_BUFFER_SIZE];
 
-static void gdb_sig_halted(connection_t *connection)
+static void gdb_sig_halted(struct connection *connection)
 {
 	char sig_reply[4];
 	snprintf(sig_reply, 4, "T%2.2x", 2);
@@ -1982,10 +1976,10 @@ static void gdb_sig_halted(connection_t *connection)
 
 }
 
-int gdb_input_inner(connection_t *connection)
+int gdb_input_inner(struct connection *connection)
 {
-	gdb_service_t *gdb_service = connection->service->priv;
-	target_t *target = gdb_service->target;
+	struct gdb_service *gdb_service = connection->service->priv;
+	struct target *target = gdb_service->target;
 	char *packet = gdb_packet_buffer;
 	int packet_size;
 	int retval;
@@ -2180,7 +2174,7 @@ int gdb_input_inner(connection_t *connection)
 	return ERROR_OK;
 }
 
-int gdb_input(connection_t *connection)
+int gdb_input(struct connection *connection)
 {
 	int retval = gdb_input_inner(connection);
 	struct gdb_connection *gdb_con = connection->priv;
@@ -2197,8 +2191,8 @@ int gdb_input(connection_t *connection)
 
 int gdb_init(void)
 {
-	gdb_service_t *gdb_service;
-	target_t *target = all_targets;
+	struct gdb_service *gdb_service;
+	struct target *target = all_targets;
 
 	if (!target)
 	{
@@ -2216,7 +2210,7 @@ int gdb_init(void)
 	{
 		/* only a single gdb connection when using a pipe */
 
-		gdb_service = malloc(sizeof(gdb_service_t));
+		gdb_service = malloc(sizeof(struct gdb_service));
 		gdb_service->target = target;
 
 		add_service("gdb", CONNECTION_PIPE, 0, 1, gdb_new_connection, gdb_input, gdb_connection_closed, gdb_service);
@@ -2230,7 +2224,7 @@ int gdb_init(void)
 
 		while (target)
 		{
-			gdb_service = malloc(sizeof(gdb_service_t));
+			gdb_service = malloc(sizeof(struct gdb_service));
 			gdb_service->target = target;
 
 			add_service("gdb", CONNECTION_TCP,
@@ -2251,7 +2245,7 @@ int gdb_init(void)
 
 COMMAND_HANDLER(handle_gdb_sync_command)
 {
-	if (argc != 0)
+	if (CMD_ARGC != 0)
 	{
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
@@ -2276,7 +2270,7 @@ COMMAND_HANDLER(handle_gdb_port_command)
 
 COMMAND_HANDLER(handle_gdb_memory_map_command)
 {
-	if (argc == 1)
+	if (CMD_ARGC == 1)
 	{
 		if (strcmp(args[0], "enable") == 0)
 		{
@@ -2297,7 +2291,7 @@ COMMAND_HANDLER(handle_gdb_memory_map_command)
 
 COMMAND_HANDLER(handle_gdb_flash_program_command)
 {
-	if (argc == 1)
+	if (CMD_ARGC == 1)
 	{
 		if (strcmp(args[0], "enable") == 0)
 		{
@@ -2318,7 +2312,7 @@ COMMAND_HANDLER(handle_gdb_flash_program_command)
 
 COMMAND_HANDLER(handle_gdb_report_data_abort_command)
 {
-	if (argc == 1)
+	if (CMD_ARGC == 1)
 	{
 		if (strcmp(args[0], "enable") == 0)
 		{
@@ -2340,10 +2334,10 @@ COMMAND_HANDLER(handle_gdb_report_data_abort_command)
 /* gdb_breakpoint_override */
 COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
 {
-	if (argc == 0)
+	if (CMD_ARGC == 0)
 	{
 
-	} else if (argc == 1)
+	} else if (CMD_ARGC == 1)
 	{
 		gdb_breakpoint_override = 1;
 		if (strcmp(args[0], "hard") == 0)
@@ -2371,7 +2365,7 @@ COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
 	return ERROR_OK;
 }
 
-int gdb_register_commands(command_context_t *command_context)
+int gdb_register_commands(struct command_context *command_context)
 {
 	register_command(command_context, NULL, "gdb_sync",
 			handle_gdb_sync_command, COMMAND_ANY,