Don't cast return value of [cm]alloc

Change-Id: I0028a5b6757b1ba00031893d9a2a1725f915a0d5
Signed-off-by: Andreas Fritiofson <andreas.fritiofson@gmail.com>
Reviewed-on: http://openocd.zylin.com/2069
Tested-by: jenkins
Reviewed-by: Jörg Wunsch <openocd@uriah.heep.sax.de>
Reviewed-by: Spencer Oliver <spen@spen-soft.co.uk>

src/helper/replacements.c

@@ -123,7 +123,7 @@ size_t strnlen(const char *s, size_t maxlen)
 char *strndup(const char *s, size_t n)
 {
 	size_t len = strnlen(s, n);
-	char *new = (char *) malloc(len + 1);
+	char *new = malloc(len + 1);
 
 	if (new == NULL)
 		return NULL;

src/jtag/drivers/versaloon/versaloon.c

@@ -139,7 +139,7 @@ RESULT versaloon_add_want_pos(uint16_t offset, uint16_t size, uint8_t *buff)
 {
 	struct versaloon_want_pos_t *new_pos = NULL;
 
-	new_pos = (struct versaloon_want_pos_t *)malloc(sizeof(*new_pos));
+	new_pos = malloc(sizeof(*new_pos));
 	if (NULL == new_pos) {
 		LOG_ERROR(ERRMSG_NOT_ENOUGH_MEMORY);
 		return ERRCODE_NOT_ENOUGH_MEMORY;

src/rtos/ChibiOS.c

@@ -347,17 +347,17 @@ static int ChibiOS_update_threads(struct rtos *rtos)
 		const char tmp_thread_name[] = "Current Execution";
 		const char tmp_thread_extra_info[] = "No RTOS thread";
 
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail));
 		rtos->thread_details->threadid = 1;
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 
-		rtos->thread_details->extra_info_str = (char *) malloc(
+		rtos->thread_details->extra_info_str = malloc(
 				sizeof(tmp_thread_extra_info));
 		strcpy(rtos->thread_details->extra_info_str, tmp_thread_extra_info);
 
-		rtos->thread_details->thread_name_str = (char *) malloc(
+		rtos->thread_details->thread_name_str = malloc(
 				sizeof(tmp_thread_name));
 		strcpy(rtos->thread_details->thread_name_str, tmp_thread_name);
 
@@ -367,7 +367,7 @@ static int ChibiOS_update_threads(struct rtos *rtos)
 	}
 
 	/* create space for new thread details */
-	rtos->thread_details = (struct thread_detail *) malloc(
+	rtos->thread_details = malloc(
 			sizeof(struct thread_detail) * tasks_found);
 	if (!rtos->thread_details) {
 		LOG_ERROR("Could not allocate space for thread details");
@@ -416,7 +416,7 @@ static int ChibiOS_update_threads(struct rtos *rtos)
 		if (tmp_str[0] == '\x00')
 			strcpy(tmp_str, "No Name");
 
-		curr_thrd_details->thread_name_str = (char *)malloc(
+		curr_thrd_details->thread_name_str = malloc(
 				strlen(tmp_str) + 1);
 		strcpy(curr_thrd_details->thread_name_str, tmp_str);
 
@@ -437,7 +437,7 @@ static int ChibiOS_update_threads(struct rtos *rtos)
 		else
 			state_desc = "Unknown state";
 
-		curr_thrd_details->extra_info_str = (char *)malloc(strlen(
+		curr_thrd_details->extra_info_str = malloc(strlen(
 					state_desc)+1);
 		strcpy(curr_thrd_details->extra_info_str, state_desc);
 
@@ -498,7 +498,7 @@ static int ChibiOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, cha
 static int ChibiOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc(
+	*symbol_list = malloc(
 			sizeof(symbol_table_elem_t) * ARRAY_SIZE(ChibiOS_symbol_list));
 
 	for (i = 0; i < ARRAY_SIZE(ChibiOS_symbol_list); i++)

src/rtos/FreeRTOS.c

@@ -192,7 +192,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 		char tmp_str[] = "Current Execution";
 		thread_list_size++;
 		tasks_found++;
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail) * thread_list_size);
 		if (!rtos->thread_details) {
 			LOG_ERROR("Error allocating memory for %d threads", thread_list_size);
@@ -202,7 +202,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 		rtos->thread_details->extra_info_str = NULL;
-		rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+		rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
 		strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
 		if (thread_list_size == 1) {
@@ -211,7 +211,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 		}
 	} else {
 		/* create space for new thread details */
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail) * thread_list_size);
 		if (!rtos->thread_details) {
 			LOG_ERROR("Error allocating memory for %d threads", thread_list_size);
@@ -234,7 +234,7 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 	}
 
 	symbol_address_t *list_of_lists =
-		(symbol_address_t *)malloc(sizeof(symbol_address_t) *
+		malloc(sizeof(symbol_address_t) *
 			(max_used_priority+1 + 5));
 	if (!list_of_lists) {
 		LOG_ERROR("Error allocating memory for %" PRId64 " priorities", max_used_priority);
@@ -320,14 +320,14 @@ static int FreeRTOS_update_threads(struct rtos *rtos)
 				strcpy(tmp_str, "No Name");
 
 			rtos->thread_details[tasks_found].thread_name_str =
-				(char *)malloc(strlen(tmp_str)+1);
+				malloc(strlen(tmp_str)+1);
 			strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 			rtos->thread_details[tasks_found].display_str = NULL;
 			rtos->thread_details[tasks_found].exists = true;
 
 			if (rtos->thread_details[tasks_found].threadid == rtos->current_thread) {
 				char running_str[] = "Running";
-				rtos->thread_details[tasks_found].extra_info_str = (char *) malloc(
+				rtos->thread_details[tasks_found].extra_info_str = malloc(
 						sizeof(running_str));
 				strcpy(rtos->thread_details[tasks_found].extra_info_str,
 					running_str);
@@ -390,7 +390,7 @@ static int FreeRTOS_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, ch
 static int FreeRTOS_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc(
+	*symbol_list = malloc(
 			sizeof(symbol_table_elem_t) * ARRAY_SIZE(FreeRTOS_symbol_list));
 
 	for (i = 0; i < ARRAY_SIZE(FreeRTOS_symbol_list); i++)
@@ -439,7 +439,7 @@ static int FreeRTOS_get_thread_ascii_info(struct rtos *rtos, threadid_t thread_i
 	if (tmp_str[0] == '\x00')
 		strcpy(tmp_str, "No Name");
 
-	*info = (char *)malloc(strlen(tmp_str)+1);
+	*info = malloc(strlen(tmp_str)+1);
 	strcpy(*info, tmp_str);
 	return 0;
 }

src/rtos/ThreadX.c

@@ -175,13 +175,13 @@ static int ThreadX_update_threads(struct rtos *rtos)
 		char tmp_str[] = "Current Execution";
 		thread_list_size++;
 		tasks_found++;
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail) * thread_list_size);
 		rtos->thread_details->threadid = 1;
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 		rtos->thread_details->extra_info_str = NULL;
-		rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+		rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
 		strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
 		if (thread_list_size == 0) {
@@ -190,7 +190,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
 		}
 	} else {
 		/* create space for new thread details */
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail) * thread_list_size);
 	}
 
@@ -243,7 +243,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
 			strcpy(tmp_str, "No Name");
 
 		rtos->thread_details[tasks_found].thread_name_str =
-			(char *)malloc(strlen(tmp_str)+1);
+			malloc(strlen(tmp_str)+1);
 		strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 
 		/* Read the thread status */
@@ -268,7 +268,7 @@ static int ThreadX_update_threads(struct rtos *rtos)
 		else
 			state_desc = "Unknown state";
 
-		rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
+		rtos->thread_details[tasks_found].extra_info_str = malloc(strlen(
 					state_desc)+1);
 		strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
 
@@ -331,7 +331,7 @@ static int ThreadX_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, cha
 static int ThreadX_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc(
+	*symbol_list = malloc(
 			sizeof(symbol_table_elem_t) * ARRAY_SIZE(ThreadX_symbol_list));
 
 	for (i = 0; i < ARRAY_SIZE(ThreadX_symbol_list); i++)
@@ -412,7 +412,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
 	if (tmp_str[0] == '\x00')
 		strcpy(tmp_str, "No Name");
 
-	detail->thread_name_str = (char *)malloc(strlen(tmp_str)+1);
+	detail->thread_name_str = malloc(strlen(tmp_str)+1);
 
 	/* Read the thread status */
 	int64_t thread_status = 0;
@@ -437,7 +437,7 @@ static int ThreadX_get_thread_detail(struct rtos *rtos,
 	else
 		state_desc = "Unknown state";
 
-	detail->extra_info_str = (char *)malloc(strlen(state_desc)+1);
+	detail->extra_info_str = malloc(strlen(state_desc)+1);
 
 	detail->exists = true;
 

src/rtos/eCos.c

@@ -170,13 +170,13 @@ static int eCos_update_threads(struct rtos *rtos)
 		char tmp_str[] = "Current Execution";
 		thread_list_size++;
 		tasks_found++;
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail) * thread_list_size);
 		rtos->thread_details->threadid = 1;
 		rtos->thread_details->exists = true;
 		rtos->thread_details->display_str = NULL;
 		rtos->thread_details->extra_info_str = NULL;
-		rtos->thread_details->thread_name_str = (char *) malloc(sizeof(tmp_str));
+		rtos->thread_details->thread_name_str = malloc(sizeof(tmp_str));
 		strcpy(rtos->thread_details->thread_name_str, tmp_str);
 
 		if (thread_list_size == 0) {
@@ -185,7 +185,7 @@ static int eCos_update_threads(struct rtos *rtos)
 		}
 	} else {
 		/* create space for new thread details */
-		rtos->thread_details = (struct thread_detail *) malloc(
+		rtos->thread_details = malloc(
 				sizeof(struct thread_detail) * thread_list_size);
 	}
 
@@ -237,7 +237,7 @@ static int eCos_update_threads(struct rtos *rtos)
 			strcpy(tmp_str, "No Name");
 
 		rtos->thread_details[tasks_found].thread_name_str =
-			(char *)malloc(strlen(tmp_str)+1);
+			malloc(strlen(tmp_str)+1);
 		strcpy(rtos->thread_details[tasks_found].thread_name_str, tmp_str);
 
 		/* Read the thread status */
@@ -263,7 +263,7 @@ static int eCos_update_threads(struct rtos *rtos)
 		else
 			state_desc = "Unknown state";
 
-		rtos->thread_details[tasks_found].extra_info_str = (char *)malloc(strlen(
+		rtos->thread_details[tasks_found].extra_info_str = malloc(strlen(
 					state_desc)+1);
 		strcpy(rtos->thread_details[tasks_found].extra_info_str, state_desc);
 
@@ -359,7 +359,7 @@ static int eCos_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, char *
 static int eCos_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc(
+	*symbol_list = malloc(
 			sizeof(symbol_table_elem_t) * ARRAY_SIZE(eCos_symbol_list));
 
 	for (i = 0; i < ARRAY_SIZE(eCos_symbol_list); i++)

src/rtos/embKernel.c

@@ -169,7 +169,7 @@ static int embKernel_get_tasks_details(struct rtos *rtos, int64_t iterable, cons
 			(uint8_t *) &priority);
 	if (retval != ERROR_OK)
 		return retval;
-	details->extra_info_str = (char *) malloc(EMBKERNEL_MAX_THREAD_NAME_STR_SIZE);
+	details->extra_info_str = malloc(EMBKERNEL_MAX_THREAD_NAME_STR_SIZE);
 	if (task == rtos->current_thread) {
 		snprintf(details->extra_info_str, EMBKERNEL_MAX_THREAD_NAME_STR_SIZE, "Pri=%u, Running",
 				(unsigned int) priority);
@@ -233,7 +233,7 @@ static int embKernel_update_threads(struct rtos *rtos)
 	}
 
 	/* create space for new thread details */
-	rtos->thread_details = (struct thread_detail *) malloc(sizeof(struct thread_detail) * thread_list_size);
+	rtos->thread_details = malloc(sizeof(struct thread_detail) * thread_list_size);
 	if (!rtos->thread_details) {
 		LOG_ERROR("Error allocating memory for %d threads", thread_list_size);
 		return ERROR_FAIL;
@@ -335,7 +335,7 @@ static int embKernel_get_thread_reg_list(struct rtos *rtos, int64_t thread_id, c
 static int embKernel_get_symbol_list_to_lookup(symbol_table_elem_t *symbol_list[])
 {
 	unsigned int i;
-	*symbol_list = (symbol_table_elem_t *) malloc(sizeof(symbol_table_elem_t) * ARRAY_SIZE(embKernel_symbol_list));
+	*symbol_list = malloc(sizeof(symbol_table_elem_t) * ARRAY_SIZE(embKernel_symbol_list));
 
 	for (i = 0; i < ARRAY_SIZE(embKernel_symbol_list); i++)
 		(*symbol_list)[i].symbol_name = embKernel_symbol_list[i];

src/rtos/linux.c

@@ -254,7 +254,7 @@ static int linux_os_thread_reg_list(struct rtos *rtos,
 
 	} else {
 		struct threads *temp = linux_os->thread_list;
-		*hex_reg_list = (char *)calloc(1, 500 * sizeof(char));
+		*hex_reg_list = calloc(1, 500 * sizeof(char));
 		hex_string = *hex_reg_list;
 
 		for (i = 0; i < 16; i++)
@@ -1136,7 +1136,7 @@ int linux_gdb_thread_packet(struct target *target,
 	if (retval != ERROR_OK)
 		return ERROR_TARGET_FAILURE;
 
-	char *out_str = (char *)calloc(1, 350 * sizeof(int64_t));
+	char *out_str = calloc(1, 350 * sizeof(int64_t));
 	char *tmp_str = out_str;
 	tmp_str += sprintf(tmp_str, "m");
 	struct threads *temp = linux_os->thread_list;
@@ -1172,7 +1172,7 @@ int linux_gdb_thread_update(struct target *target,
 
 	if (found == 1) {
 		/*LOG_INFO("INTO GDB THREAD UPDATE FOUNDING START TASK");*/
-		char *out_strr = (char *)calloc(1, 350 * sizeof(int64_t));
+		char *out_strr = calloc(1, 350 * sizeof(int64_t));
 		char *tmp_strr = out_strr;
 		tmp_strr += sprintf(tmp_strr, "m");
 		/*LOG_INFO("CHAR MALLOC & M DONE");*/
@@ -1216,7 +1216,7 @@ int linux_thread_extra_info(struct target *target,
 			char *pid_current = "*PID: ";
 			char *name = "NAME: ";
 			int str_size = strlen(pid) + strlen(name);
-			char *tmp_str = (char *)calloc(1, str_size + 50);
+			char *tmp_str = calloc(1, str_size + 50);
 			char *tmp_str_ptr = tmp_str;
 
 			/*  discriminate current task */
@@ -1231,7 +1231,7 @@ int linux_thread_extra_info(struct target *target,
 			tmp_str_ptr += sprintf(tmp_str_ptr, "%s", " | ");
 			sprintf(tmp_str_ptr, "%s", name);
 			sprintf(tmp_str_ptr, "%s", temp->name);
-			char *hex_str = (char *)calloc(1, strlen(tmp_str) * 2 + 1);
+			char *hex_str = calloc(1, strlen(tmp_str) * 2 + 1);
 			int pkt_len = hexify(hex_str, tmp_str, 0, strlen(tmp_str) * 2 + 1);
 			gdb_put_packet(connection, hex_str, pkt_len);
 			free(hex_str);

src/rtos/rtos.c

@@ -289,7 +289,7 @@ int rtos_thread_packet(struct connection *connection, char const *packet, int pa
 			if (detail->extra_info_str != NULL)
 				str_size += strlen(detail->extra_info_str);
 
-			char *tmp_str = (char *) malloc(str_size + 7);
+			char *tmp_str = malloc(str_size + 7);
 			char *tmp_str_ptr = tmp_str;
 
 			if (detail->display_str != NULL)
@@ -309,7 +309,7 @@ int rtos_thread_packet(struct connection *connection, char const *packet, int pa
 			assert(strlen(tmp_str) ==
 				(size_t) (tmp_str_ptr - tmp_str));
 
-			char *hex_str = (char *) malloc(strlen(tmp_str) * 2 + 1);
+			char *hex_str = malloc(strlen(tmp_str) * 2 + 1);
 			int pkt_len = hexify(hex_str, tmp_str, 0, strlen(tmp_str) * 2 + 1);
 
 			gdb_put_packet(connection, hex_str, pkt_len);
@@ -334,7 +334,7 @@ int rtos_thread_packet(struct connection *connection, char const *packet, int pa
 				gdb_put_packet(connection, "l", 1);
 			} else {
 				/*thread id are 16 char +1 for ',' */
-				char *out_str = (char *) malloc(17 * target->rtos->thread_count + 1);
+				char *out_str = malloc(17 * target->rtos->thread_count + 1);
 				char *tmp_str = out_str;
 				for (i = 0; i < target->rtos->thread_count; i++) {
 					tmp_str += sprintf(tmp_str, "%c%016" PRIx64, i == 0 ? 'm' : ',',
@@ -437,7 +437,7 @@ int rtos_generic_stack_read(struct target *target,
 		return -5;
 	}
 	/* Read the stack */
-	uint8_t *stack_data = (uint8_t *) malloc(stacking->stack_registers_size);
+	uint8_t *stack_data = malloc(stacking->stack_registers_size);
 	uint32_t address = stack_ptr;
 
 	if (stacking->stack_growth_direction == 1)
@@ -456,7 +456,7 @@ int rtos_generic_stack_read(struct target *target,
 #endif
 	for (i = 0; i < stacking->num_output_registers; i++)
 		list_size += stacking->register_offsets[i].width_bits/8;
-	*hex_reg_list = (char *)malloc(list_size*2 + 1);
+	*hex_reg_list = malloc(list_size*2 + 1);
 	tmp_str_ptr = *hex_reg_list;
 	new_stack_ptr = stack_ptr - stacking->stack_growth_direction *
 		stacking->stack_registers_size;

src/svf/svf.c

@@ -383,19 +383,19 @@ COMMAND_HANDLER(handle_svf_command)
 	/* in case current command cannot be committed, and next command is a bit scan command */
 	/* here is 32K bits for this big scan command, it should be enough */
 	/* buffer will be reallocated if buffer size is not enough */
-	svf_tdi_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
+	svf_tdi_buffer = malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
 	if (NULL == svf_tdi_buffer) {
 		LOG_ERROR("not enough memory");
 		ret = ERROR_FAIL;
 		goto free_all;
 	}
-	svf_tdo_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
+	svf_tdo_buffer = malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
 	if (NULL == svf_tdo_buffer) {
 		LOG_ERROR("not enough memory");
 		ret = ERROR_FAIL;
 		goto free_all;
 	}
-	svf_mask_buffer = (uint8_t *)malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
+	svf_mask_buffer = malloc(2 * SVF_MAX_BUFFER_SIZE_TO_COMMIT);
 	if (NULL == svf_mask_buffer) {
 		LOG_ERROR("not enough memory");
 		ret = ERROR_FAIL;
@@ -561,7 +561,7 @@ static int svf_getline(char **lineptr, size_t *n, FILE *stream)
 
 	if (*lineptr == NULL) {
 		*n = MIN_CHUNK;
-		*lineptr = (char *)malloc(*n);
+		*lineptr = malloc(*n);
 		if (!*lineptr)
 			return -1;
 	}
@@ -733,7 +733,7 @@ static int svf_adjust_array_length(uint8_t **arr, int orig_bit_len, int new_bit_
 			free(*arr);
 			*arr = NULL;
 		}
-		*arr = (uint8_t *)malloc(new_byte_len);
+		*arr = malloc(new_byte_len);
 		if (NULL == *arr) {
 			LOG_ERROR("not enough memory");
 			return ERROR_FAIL;
@@ -1086,7 +1086,7 @@ XXR_common:
 					uint8_t *buffer_tmp;
 
 					/* reallocate buffer */
-					buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
+					buffer_tmp = malloc(svf_buffer_index + ((i + 7) >> 3));
 					if (NULL == buffer_tmp) {
 						LOG_ERROR("not enough memory");
 						return ERROR_FAIL;
@@ -1096,7 +1096,7 @@ XXR_common:
 					free(svf_tdi_buffer);
 					svf_tdi_buffer = buffer_tmp;
 
-					buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
+					buffer_tmp = malloc(svf_buffer_index + ((i + 7) >> 3));
 					if (NULL == buffer_tmp) {
 						LOG_ERROR("not enough memory");
 						return ERROR_FAIL;
@@ -1106,7 +1106,7 @@ XXR_common:
 					free(svf_tdo_buffer);
 					svf_tdo_buffer = buffer_tmp;
 
-					buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
+					buffer_tmp = malloc(svf_buffer_index + ((i + 7) >> 3));
 					if (NULL == buffer_tmp) {
 						LOG_ERROR("not enough memory");
 						return ERROR_FAIL;
@@ -1213,7 +1213,7 @@ XXR_common:
 					uint8_t *buffer_tmp;
 
 					/* reallocate buffer */
-					buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
+					buffer_tmp = malloc(svf_buffer_index + ((i + 7) >> 3));
 					if (NULL == buffer_tmp) {
 						LOG_ERROR("not enough memory");
 						return ERROR_FAIL;
@@ -1223,7 +1223,7 @@ XXR_common:
 					free(svf_tdi_buffer);
 					svf_tdi_buffer = buffer_tmp;
 
-					buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
+					buffer_tmp = malloc(svf_buffer_index + ((i + 7) >> 3));
 					if (NULL == buffer_tmp) {
 						LOG_ERROR("not enough memory");
 						return ERROR_FAIL;
@@ -1233,7 +1233,7 @@ XXR_common:
 					free(svf_tdo_buffer);
 					svf_tdo_buffer = buffer_tmp;
 
-					buffer_tmp = (uint8_t *)malloc(svf_buffer_index + ((i + 7) >> 3));
+					buffer_tmp = malloc(svf_buffer_index + ((i + 7) >> 3));
 					if (NULL == buffer_tmp) {
 						LOG_ERROR("not enough memory");
 						return ERROR_FAIL;
@@ -1456,7 +1456,7 @@ XXR_common:
 			}
 			if (num_of_argu > 2) {
 				/* STATE pathstate1 ... stable_state */
-				path = (tap_state_t *)malloc((num_of_argu - 1) * sizeof(tap_state_t));
+				path = malloc((num_of_argu - 1) * sizeof(tap_state_t));
 				if (NULL == path) {
 					LOG_ERROR("not enough memory");
 					return ERROR_FAIL;

src/target/arm11_dbgtap.c

@@ -591,7 +591,7 @@ int arm11_run_instr_data_to_core_noack_inner_default(struct jtag_tap *tap,
 	unsigned readiesNum = count;
 	unsigned bytes = sizeof(*Readies)*readiesNum;
 
-	Readies = (uint8_t *) malloc(bytes);
+	Readies = malloc(bytes);
 	if (Readies == NULL) {
 		LOG_ERROR("Out of memory allocating %u bytes", bytes);
 		return ERROR_FAIL;

src/target/nds32.c

@@ -2330,14 +2330,14 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 
 	switch (syscall_id) {
 		case NDS32_SYSCALL_EXIT:
-			fileio_info->identifier = (char *)malloc(5);
+			fileio_info->identifier = malloc(5);
 			sprintf(fileio_info->identifier, "exit");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			break;
 		case NDS32_SYSCALL_OPEN:
 			{
 				uint8_t filename[256];
-				fileio_info->identifier = (char *)malloc(5);
+				fileio_info->identifier = malloc(5);
 				sprintf(fileio_info->identifier, "open");
 				nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 				/* reserve fileio_info->param_2 for length of path */
@@ -2350,26 +2350,26 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 			}
 			break;
 		case NDS32_SYSCALL_CLOSE:
-			fileio_info->identifier = (char *)malloc(6);
+			fileio_info->identifier = malloc(6);
 			sprintf(fileio_info->identifier, "close");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			break;
 		case NDS32_SYSCALL_READ:
-			fileio_info->identifier = (char *)malloc(5);
+			fileio_info->identifier = malloc(5);
 			sprintf(fileio_info->identifier, "read");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			nds32_get_mapped_reg(nds32, R1, &(fileio_info->param_2));
 			nds32_get_mapped_reg(nds32, R2, &(fileio_info->param_3));
 			break;
 		case NDS32_SYSCALL_WRITE:
-			fileio_info->identifier = (char *)malloc(6);
+			fileio_info->identifier = malloc(6);
 			sprintf(fileio_info->identifier, "write");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			nds32_get_mapped_reg(nds32, R1, &(fileio_info->param_2));
 			nds32_get_mapped_reg(nds32, R2, &(fileio_info->param_3));
 			break;
 		case NDS32_SYSCALL_LSEEK:
-			fileio_info->identifier = (char *)malloc(6);
+			fileio_info->identifier = malloc(6);
 			sprintf(fileio_info->identifier, "lseek");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			nds32_get_mapped_reg(nds32, R1, &(fileio_info->param_2));
@@ -2378,7 +2378,7 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 		case NDS32_SYSCALL_UNLINK:
 			{
 				uint8_t filename[256];
-				fileio_info->identifier = (char *)malloc(7);
+				fileio_info->identifier = malloc(7);
 				sprintf(fileio_info->identifier, "unlink");
 				nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 				/* reserve fileio_info->param_2 for length of path */
@@ -2391,7 +2391,7 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 		case NDS32_SYSCALL_RENAME:
 			{
 				uint8_t filename[256];
-				fileio_info->identifier = (char *)malloc(7);
+				fileio_info->identifier = malloc(7);
 				sprintf(fileio_info->identifier, "rename");
 				nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 				/* reserve fileio_info->param_2 for length of old path */
@@ -2408,7 +2408,7 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 			}
 			break;
 		case NDS32_SYSCALL_FSTAT:
-			fileio_info->identifier = (char *)malloc(6);
+			fileio_info->identifier = malloc(6);
 			sprintf(fileio_info->identifier, "fstat");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			nds32_get_mapped_reg(nds32, R1, &(fileio_info->param_2));
@@ -2416,7 +2416,7 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 		case NDS32_SYSCALL_STAT:
 			{
 				uint8_t filename[256];
-				fileio_info->identifier = (char *)malloc(5);
+				fileio_info->identifier = malloc(5);
 				sprintf(fileio_info->identifier, "stat");
 				nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 				/* reserve fileio_info->param_2 for length of old path */
@@ -2428,20 +2428,20 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 			}
 			break;
 		case NDS32_SYSCALL_GETTIMEOFDAY:
-			fileio_info->identifier = (char *)malloc(13);
+			fileio_info->identifier = malloc(13);
 			sprintf(fileio_info->identifier, "gettimeofday");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			nds32_get_mapped_reg(nds32, R1, &(fileio_info->param_2));
 			break;
 		case NDS32_SYSCALL_ISATTY:
-			fileio_info->identifier = (char *)malloc(7);
+			fileio_info->identifier = malloc(7);
 			sprintf(fileio_info->identifier, "isatty");
 			nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 			break;
 		case NDS32_SYSCALL_SYSTEM:
 			{
 				uint8_t command[256];
-				fileio_info->identifier = (char *)malloc(7);
+				fileio_info->identifier = malloc(7);
 				sprintf(fileio_info->identifier, "system");
 				nds32_get_mapped_reg(nds32, R0, &(fileio_info->param_1));
 				/* reserve fileio_info->param_2 for length of old path */
@@ -2452,12 +2452,12 @@ int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fil
 			}
 			break;
 		case NDS32_SYSCALL_ERRNO:
-			fileio_info->identifier = (char *)malloc(6);
+			fileio_info->identifier = malloc(6);
 			sprintf(fileio_info->identifier, "errno");
 			nds32_set_mapped_reg(nds32, R0, nds32->virtual_hosting_errno);
 			break;
 		default:
-			fileio_info->identifier = (char *)malloc(8);
+			fileio_info->identifier = malloc(8);
 			sprintf(fileio_info->identifier, "unknown");
 			break;
 	}

src/target/target.c

@@ -3190,7 +3190,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 				if (diffs == 0)
 					LOG_ERROR("checksum mismatch - attempting binary compare");
 
-				data = (uint8_t *)malloc(buf_cnt);
+				data = malloc(buf_cnt);
 
 				/* Can we use 32bit word accesses? */
 				int size = 1;
@@ -5102,7 +5102,7 @@ static int target_create(Jim_GetOptInfo *goi)
 	target->target_number = new_target_number();
 
 	/* allocate memory for each unique target type */
-	target->type = (struct target_type *)calloc(1, sizeof(struct target_type));
+	target->type = calloc(1, sizeof(struct target_type));
 
 	memcpy(target->type, target_types[x], sizeof(struct target_type));
 
@@ -5488,7 +5488,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	image_size = 0x0;
 	retval = ERROR_OK;
 	fastload_num = image.num_sections;
-	fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
+	fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
 	if (fastload == NULL) {
 		command_print(CMD_CTX, "out of memory");
 		image_close(&image);

src/transport/transport.c

@@ -206,7 +206,7 @@ COMMAND_HELPER(transport_list_parse, char ***vector)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	/* our return vector must be NULL terminated */
-	argv = (char **) calloc(n + 1, sizeof(char *));
+	argv = calloc(n + 1, sizeof(char *));
 	if (argv == NULL)
 		return ERROR_FAIL;