[1/2] helper: fix compilation with warnings

Message ID 1483029648-16521-1-git-send-email-maxim.uvarov@linaro.org
State New
Headers show

Commit Message

Maxim Uvarov Dec. 29, 2016, 4:40 p.m.
After turning on lost CFLAGS for checking errors,
following things needs to be corrected to make code
compile.

Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org>

---
 helper/chksum.c      |  4 ++--
 helper/hashtable.c   | 42 ++++++++++++++++++++++++++----------------
 helper/lineartable.c | 27 +++++++++++++++++----------
 helper/linux.c       |  2 +-
 4 files changed, 46 insertions(+), 29 deletions(-)

-- 
2.7.1.250.gff4ea60

Comments

Maxim Uvarov Jan. 9, 2017, 2:24 p.m. | #1
ping, please review.

Maxim.

On 12/29/16 19:40, Maxim Uvarov wrote:
> After turning on lost CFLAGS for checking errors,

> following things needs to be corrected to make code

> compile.

> 

> Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org>

> ---

>  helper/chksum.c      |  4 ++--

>  helper/hashtable.c   | 42 ++++++++++++++++++++++++++----------------

>  helper/lineartable.c | 27 +++++++++++++++++----------

>  helper/linux.c       |  2 +-

>  4 files changed, 46 insertions(+), 29 deletions(-)

> 

> 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;

>
Mike Holmes Jan. 9, 2017, 6:10 p.m. | #2
On 29 December 2016 at 11:40, Maxim Uvarov <maxim.uvarov@linaro.org> wrote:

> After turning on lost CFLAGS for checking errors,

> following things needs to be corrected to make code

> compile.

>


Which cflags ? I looked in 2/2 and  assume it was debug print, but that was
not lost just hard wired to 1, was this a bug when debug print was = 0 ?


> Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org>

> ---

>  helper/chksum.c      |  4 ++--

>  helper/hashtable.c   | 42 ++++++++++++++++++++++++++----------------

>  helper/lineartable.c | 27 +++++++++++++++++----------

>  helper/linux.c       |  2 +-

>  4 files changed, 46 insertions(+), 29 deletions(-)

>

> 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;

> --

> 2.7.1.250.gff4ea60

>

>



-- 
Mike Holmes
Program Manager - Linaro Networking Group
Linaro.org <http://www.linaro.org/> *│ *Open source software for ARM SoCs
"Work should be fun and collaborative, the rest follows"
Maxim Uvarov Jan. 9, 2017, 6:37 p.m. | #3
On 01/09/17 21:10, Mike Holmes wrote:
> 

> 

> On 29 December 2016 at 11:40, Maxim Uvarov <maxim.uvarov@linaro.org

> <mailto:maxim.uvarov@linaro.org>> wrote:

> 

>     After turning on lost CFLAGS for checking errors,

>     following things needs to be corrected to make code

>     compile.

> 

> 

> Which cflags ? I looked in 2/2 and  assume it was debug print, but that

> was not lost just hard wired to 1, was this a bug when debug print was = 0 ?

> 


patch 2/2 passes all cflags to helper with:
-AM_CFLAGS  = -I$(srcdir)/include
+AM_CFLAGS += -I$(srcdir)/include

with configured option -DODPH_DEBUG_PRINT=0

but passing cflags triggers a lot of gcc warnings which we threat as
errors. So patch 1 is needed before patch 2.

Maxim.



> 

>     Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org

>     <mailto:maxim.uvarov@linaro.org>>

>     ---

>      helper/chksum.c      |  4 ++--

>      helper/hashtable.c   | 42 ++++++++++++++++++++++++++----------------

>      helper/lineartable.c | 27 +++++++++++++++++----------

>      helper/linux.c       |  2 +-

>      4 files changed, 46 insertions(+), 29 deletions(-)

> 

>     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;

>     --

>     2.7.1.250.gff4ea60

> 

> 

> 

> 

> -- 

> Mike Holmes

> Program Manager - Linaro Networking Group

> Linaro.org <http://www.linaro.org/>* **│ *Open source software for ARM SoCs

> "Work should be fun and collaborative, the rest follows"

> 

> __

> 

>
Mike Holmes Jan. 20, 2017, 7 p.m. | #4
I think this needs a rebase, latest master has brought new issues with
the extra flags

 f2e960d :2016-12-29 - (HEAD -> master) configure.ac: helper: print
debug config option <Maxim Uvarov>
* de503c9 :2016-12-29 - helper: fix compilation with warnings <Maxim Uvarov>
* 3875d6e :2017-01-13 - (tag: v1.13.0.0, origin/master, origin/HEAD)
update API version number from v1.12.0.0 to v1.13.0.0 <Ma

cuckootable.c: In function ‘odph_cuckoo_table_destroy’:
cuckootable.c:331:16: error: comparison between signed and unsigned
integer expressions [-Werror=sign-compare]
  for (i = 0; i < impl->num_buckets; i++) {
                ^
cuckootable.c: In function ‘odph_cuckoo_table_get_value’:
cuckootable.c:656:55: error: unused parameter ‘buffer_size’
[-Werror=unused-parameter]
   odph_table_t tbl, void *key, void *buffer, uint32_t buffer_size)
                                                       ^~~~~~~~~~~
iplookuptable.c: In function ‘odph_iplookup_table_create’:
iplookuptable.c:439:30: error: unused parameter ‘ODP_IGNORED_1’
[-Werror=unused-parameter]
   const char *name, uint32_t ODP_IGNORED_1,
                              ^~~~~~~~~~~~~
iplookuptable.c:440:12: error: unused parameter ‘ODP_IGNORED_2’
[-Werror=unused-parameter]
   uint32_t ODP_IGNORED_2, uint32_t value_size)
            ^~~~~~~~~~~~~
iplookuptable.c: In function ‘odph_iplookup_table_get_value’:
iplookuptable.c:709:55: error: unused parameter ‘buffer_size’
[-Werror=unused-parameter]
   odph_table_t tbl, void *key, void *buffer, uint32_t buffer_size)
                                                       ^~~~~~~~~~~
iplookuptable.c: In function ‘odph_iplookup_table_remove_value’:
iplookuptable.c:891:19: error: comparison is always false due to
limited range of data type [-Werror=type-limits]
  if (prefix->cidr < 0)
                   ^
cc1: all warnings being treated as errors
cc1: all warnings being treated as errors



On 9 January 2017 at 13:37, Maxim Uvarov <maxim.uvarov@linaro.org> wrote:
> On 01/09/17 21:10, Mike Holmes wrote:

>>

>>

>> On 29 December 2016 at 11:40, Maxim Uvarov <maxim.uvarov@linaro.org

>> <mailto:maxim.uvarov@linaro.org>> wrote:

>>

>>     After turning on lost CFLAGS for checking errors,

>>     following things needs to be corrected to make code

>>     compile.

>>

>>

>> Which cflags ? I looked in 2/2 and  assume it was debug print, but that

>> was not lost just hard wired to 1, was this a bug when debug print was = 0 ?

>>

>

> patch 2/2 passes all cflags to helper with:

> -AM_CFLAGS  = -I$(srcdir)/include

> +AM_CFLAGS += -I$(srcdir)/include

>

> with configured option -DODPH_DEBUG_PRINT=0

>

> but passing cflags triggers a lot of gcc warnings which we threat as

> errors. So patch 1 is needed before patch 2.

>

> Maxim.

>

>

>

>>

>>     Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org

>>     <mailto:maxim.uvarov@linaro.org>>

>>     ---

>>      helper/chksum.c      |  4 ++--

>>      helper/hashtable.c   | 42 ++++++++++++++++++++++++++----------------

>>      helper/lineartable.c | 27 +++++++++++++++++----------

>>      helper/linux.c       |  2 +-

>>      4 files changed, 46 insertions(+), 29 deletions(-)

>>

>>     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;

>>     --

>>     2.7.1.250.gff4ea60

>>

>>

>>

>>

>> --

>> Mike Holmes

>> Program Manager - Linaro Networking Group

>> Linaro.org <http://www.linaro.org/>* **│ *Open source software for ARM SoCs

>> "Work should be fun and collaborative, the rest follows"

>>

>> __

>>

>>

>




-- 
Mike Holmes
Program Manager - Linaro Networking Group
Linaro.org │ Open source software for ARM SoCs
"Work should be fun and collaborative, the rest follows"

Patch

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;