diff --git a/helper/chksum.c b/helper/chksum.c
index b7eef67..f740618 100644
--- a/helper/chksum.c
+++ b/helper/chksum.c
@@ -49,7 +49,7 @@ static uint32_t data_seg_sum(uint8_t   *data8_ptr,
 		data_len--;
 	}
 
-	data16_ptr = (uint16_t *)data8_ptr;
+	data16_ptr = (uint16_t *)(void *)data8_ptr;
 
 	/* The following code tries to gain a modest performance enhancement by
 	 * unrolling the normal 16 bits at a time loop eight times.  Even
@@ -216,7 +216,7 @@ static inline int odph_process_l3_hdr(odp_packet_t odp_pkt,
 			ipv6_hdr_ptr = &ipv6_hdr;
 		}
 
-		addrs_ptr        = (uint16_t *)&ipv6_hdr_ptr->src_addr;
+		addrs_ptr        = (uint16_t *)(void *)&ipv6_hdr_ptr->src_addr;
 		addrs_len        = 2 * ODPH_IPV6ADDR_LEN;
 		protocol         = ipv6_hdr_ptr->next_hdr;
 		ipv6_payload_len = odp_be_to_cpu_16(ipv6_hdr_ptr->payload_len);
diff --git a/helper/hashtable.c b/helper/hashtable.c
index 8bb1ae5..0b652b3 100644
--- a/helper/hashtable.c
+++ b/helper/hashtable.c
@@ -101,9 +101,9 @@ odph_table_t odph_hash_table_create(const char *name, uint32_t capacity,
 	 * the last part is the element node pool
 	 */
 
-	tbl->lock_pool = (odp_rwlock_t *)((char *)tbl
+	tbl->lock_pool = (odp_rwlock_t *)(void *)((char *)tbl
 			+ sizeof(odph_hash_table_imp));
-	tbl->list_head_pool = (odph_list_head *)((char *)tbl->lock_pool
+	tbl->list_head_pool = (odph_list_head *)(void *)((char *)tbl->lock_pool
 			+ ODPH_MAX_BUCKET_NUM * sizeof(odp_rwlock_t));
 
 	node_mem = tbl->init_cap - sizeof(odph_hash_table_imp)
@@ -112,8 +112,9 @@ odph_table_t odph_hash_table_create(const char *name, uint32_t capacity,
 
 	node_num = node_mem / (sizeof(odph_hash_node) + key_size + value_size);
 	tbl->hash_node_num = node_num;
-	tbl->hash_node_pool = (odph_hash_node *)((char *)tbl->list_head_pool
-				+ ODPH_MAX_BUCKET_NUM * sizeof(odph_list_head));
+	tbl->hash_node_pool =
+		(odph_hash_node *)(void *)((char *)tbl->list_head_pool
+		+ ODPH_MAX_BUCKET_NUM * sizeof(odph_list_head));
 
 	/* init every list head and rw lock */
 	for (i = 0; i < ODPH_MAX_BUCKET_NUM; i++) {
@@ -130,8 +131,9 @@ int odph_hash_table_destroy(odph_table_t table)
 	int ret;
 
 	if (table != NULL) {
-		odph_hash_table_imp *hash_tbl = (odph_hash_table_imp *)table;
+		odph_hash_table_imp *hash_tbl;
 
+		hash_tbl = (odph_hash_table_imp *)(void *)table;
 		if (hash_tbl->magicword != ODPH_HASH_TABLE_MAGIC_WORD)
 			return ODPH_FAIL;
 
@@ -164,7 +166,7 @@ odph_table_t odph_hash_table_lookup(const char *name)
  * This hash algorithm is the most simple one, so we choose it as an DEMO
  * User can use any other algorithm, like CRC...
  */
-uint16_t odp_key_hash(void *key, uint32_t key_size)
+static uint16_t odp_key_hash(void *key, uint32_t key_size)
 {
 	register uint32_t hash = 0;
 	uint32_t idx = (key_size == 0 ? 1 : key_size);
@@ -181,18 +183,19 @@ uint16_t odp_key_hash(void *key, uint32_t key_size)
 /**
  * Get an available node from pool
  */
-odph_hash_node *odp_hashnode_take(odph_table_t table)
+static odph_hash_node *hashnode_take(odph_table_t table)
 {
-	odph_hash_table_imp *tbl = (odph_hash_table_imp *)table;
+	odph_hash_table_imp *tbl;
 	uint32_t idx;
 	odph_hash_node *node;
 
+	tbl = (odph_hash_table_imp *)(void *)table;
 	for (idx = 0; idx < tbl->hash_node_num; idx++) {
 		/** notice: memory of one hash_node is
 		 * not only sizeof(odph_hash_node)
 		 * should add the size of Flexible Array
 		 */
-		node = (odph_hash_node *)((char *)tbl->hash_node_pool
+		node = (odph_hash_node *)(void *)((char *)tbl->hash_node_pool
 				+ idx * (sizeof(odph_hash_node)
 						+ tbl->key_size
 						+ tbl->value_size));
@@ -208,13 +211,15 @@ odph_hash_node *odp_hashnode_take(odph_table_t table)
 /**
  * Release an node to the pool
  */
-void odp_hashnode_give(odph_table_t table, odph_hash_node *node)
+static void hashnode_give(odph_table_t table, odph_hash_node *node)
 {
-	odph_hash_table_imp *tbl = (odph_hash_table_imp *)table;
+	odph_hash_table_imp *tbl;
 
 	if (node == NULL)
 		return;
 
+	tbl = (odph_hash_table_imp *)(void *)table;
+
 	odph_list_del(&node->list_node);
 	memset(node, 0,
 	       (sizeof(odph_hash_node) + tbl->key_size + tbl->value_size));
@@ -223,7 +228,7 @@ void odp_hashnode_give(odph_table_t table, odph_hash_node *node)
 /* should make sure the input table exists and is available */
 int odph_hash_put_value(odph_table_t table, void *key, void *value)
 {
-	odph_hash_table_imp *tbl = (odph_hash_table_imp *)table;
+	odph_hash_table_imp *tbl;
 	uint16_t hash = 0;
 	odph_hash_node *node = NULL;
 	char *tmp = NULL;
@@ -231,6 +236,7 @@ int odph_hash_put_value(odph_table_t table, void *key, void *value)
 	if (table == NULL || key == NULL || value == NULL)
 		return ODPH_FAIL;
 
+	tbl = (odph_hash_table_imp *)(void *)table;
 	/* hash value is just the index of the list head in pool */
 	hash = odp_key_hash(key, tbl->key_size);
 
@@ -249,7 +255,7 @@ int odph_hash_put_value(odph_table_t table, void *key, void *value)
 	}
 
 	/*if the key is a new one, get a new hash node form the pool */
-	node = odp_hashnode_take(table);
+	node = hashnode_take(table);
 	if (node == NULL) {
 		odp_rwlock_write_unlock(&tbl->lock_pool[hash]);
 		return ODPH_FAIL;
@@ -271,11 +277,13 @@ int odph_hash_put_value(odph_table_t table, void *key, void *value)
 int odph_hash_get_value(odph_table_t table, void *key, void *buffer,
 			uint32_t buffer_size)
 {
-	odph_hash_table_imp *tbl = (odph_hash_table_imp *)table;
+	odph_hash_table_imp *tbl;
 	uint16_t hash = 0;
 	odph_hash_node *node;
 	char *tmp = NULL;
 
+	tbl = (odph_hash_table_imp *)(void *)table;
+
 	if (table == NULL || key == NULL || buffer == NULL ||
 	    buffer_size < tbl->value_size)
 		return ODPH_FAIL;
@@ -308,13 +316,15 @@ int odph_hash_get_value(odph_table_t table, void *key, void *buffer,
 /* should make sure the input table exists and is available */
 int odph_hash_remove_value(odph_table_t table, void *key)
 {
-	odph_hash_table_imp *tbl = (odph_hash_table_imp *)table;
+	odph_hash_table_imp *tbl;
 	uint16_t hash = 0;
 	odph_hash_node *node;
 
 	if (table == NULL || key == NULL)
 		return ODPH_FAIL;
 
+	tbl = (odph_hash_table_imp *)(void *)table;
+
 	/* hash value is just the index of the list head in pool */
 	hash = odp_key_hash(key, tbl->key_size);
 
@@ -324,7 +334,7 @@ int odph_hash_remove_value(odph_table_t table, void *key)
 			   list_node)
 	{
 		if (memcmp(node->content, key, tbl->key_size) == 0) {
-			odp_hashnode_give(table, node);
+			hashnode_give(table, node);
 			odp_rwlock_write_unlock(&tbl->lock_pool[hash]);
 			return ODPH_SUCCESS;
 		}
diff --git a/helper/lineartable.c b/helper/lineartable.c
index e82c165..b46e027 100644
--- a/helper/lineartable.c
+++ b/helper/lineartable.c
@@ -41,9 +41,10 @@ typedef struct {
  */
 
 odph_table_t odph_linear_table_create(const char *name, uint32_t capacity,
-				      uint32_t ODP_IGNORED, uint32_t value_size)
+				      uint32_t un ODPH_UNUSED,
+				      uint32_t value_size)
 {
-	int idx;
+	uint32_t idx;
 	uint32_t node_num;
 	odp_shm_t shmem;
 	odph_linear_table_imp *tbl;
@@ -90,8 +91,10 @@ odph_table_t odph_linear_table_create(const char *name, uint32_t capacity,
 
 	/* initialize rwlock*/
 	for (idx = 0; idx < tbl->node_sum; idx++) {
-		odp_rwlock_t *lock = (odp_rwlock_t *)((char *)tbl->value_array
-				+ idx * tbl->value_size);
+		odp_rwlock_t *lock;
+
+		lock = (odp_rwlock_t *)(void *)((char *)tbl->value_array
+		       + idx * tbl->value_size);
 		odp_rwlock_init(lock);
 	}
 
@@ -106,7 +109,7 @@ int odph_linear_table_destroy(odph_table_t table)
 	odph_linear_table_imp *linear_tbl = NULL;
 
 	if (table != NULL) {
-		linear_tbl = (odph_linear_table_imp *)table;
+		linear_tbl = (odph_linear_table_imp *)(void *)table;
 
 		/* check magicword, make sure the memory is used by a table */
 		if (linear_tbl->magicword != ODPH_LINEAR_TABLE_MAGIC_WORD)
@@ -142,9 +145,10 @@ odph_table_t odph_linear_table_lookup(const char *name)
 }
 
 /* should make sure the input table exists and is available */
-int odph_lineartable_put_value(odph_table_t table, void *key, void *value)
+static int odph_lineartable_put_value(odph_table_t table,
+				      void *key, void *value)
 {
-	odph_linear_table_imp *tbl = (odph_linear_table_imp *)table;
+	odph_linear_table_imp *tbl;
 	uint32_t ikey = 0;
 	void *entry = NULL;
 	odp_rwlock_t *lock = NULL;
@@ -152,6 +156,7 @@ int odph_lineartable_put_value(odph_table_t table, void *key, void *value)
 	if (table == NULL || key == NULL || value == NULL)
 		return ODPH_FAIL;
 
+	tbl = (odph_linear_table_imp *)(void *)table;
 	ikey = *(uint32_t *)key;
 	if (ikey >= tbl->node_sum)
 		return ODPH_FAIL;
@@ -170,10 +175,11 @@ int odph_lineartable_put_value(odph_table_t table, void *key, void *value)
 }
 
 /* should make sure the input table exists and is available */
-int odph_lineartable_get_value(odph_table_t table, void *key, void *buffer,
-			       uint32_t buffer_size)
+static int odph_lineartable_get_value(odph_table_t table,
+				      void *key, void *buffer,
+				      uint32_t buffer_size ODPH_UNUSED)
 {
-	odph_linear_table_imp *tbl = (odph_linear_table_imp *)table;
+	odph_linear_table_imp *tbl;
 	uint32_t ikey = 0;
 	void *entry = NULL;
 	odp_rwlock_t *lock = NULL;
@@ -181,6 +187,7 @@ int odph_lineartable_get_value(odph_table_t table, void *key, void *buffer,
 	if (table == NULL || key == NULL || buffer == NULL)
 		return ODPH_FAIL;
 
+	tbl = (odph_linear_table_imp *)(void *)table;
 	ikey = *(uint32_t *)key;
 	if (ikey >= tbl->node_sum)
 		return ODPH_FAIL;
diff --git a/helper/linux.c b/helper/linux.c
index 1f009cd..d729046 100644
--- a/helper/linux.c
+++ b/helper/linux.c
@@ -639,7 +639,7 @@ int odph_parse_options(int argc, char *argv[],
 		{0, 0, 0, 0}
 		};
 
-	static char *helper_short_options = "";
+	static const char *helper_short_options = "";
 
 	/* defaults: */
 	helper_options.proc = false;
