diff --git a/lib/librte_acl/acl_bld.c b/lib/librte_acl/acl_bld.c
index 4d8a62f..e6f4530 100644
--- a/lib/librte_acl/acl_bld.c
+++ b/lib/librte_acl/acl_bld.c
@@ -120,10 +120,6 @@ static int acl_merge_trie(struct acl_build_context *context,
 	struct rte_acl_node *node_a, struct rte_acl_node *node_b,
 	uint32_t level, struct rte_acl_node **node_c);
 
-static int acl_merge(struct acl_build_context *context,
-	struct rte_acl_node *node_a, struct rte_acl_node *node_b,
-	int move, int a_subset, int level);
-
 static void
 acl_deref_ptr(struct acl_build_context *context,
 	struct rte_acl_node *node, int index);
@@ -415,58 +411,6 @@ acl_intersect_type(const struct rte_acl_bitset *a_bits,
 }
 
 /*
- * Check if all bits in the bitset are on
- */
-static int
-acl_full(struct rte_acl_node *node)
-{
-	uint32_t n;
-	bits_t all_bits = -1;
-
-	for (n = 0; n < RTE_ACL_BIT_SET_SIZE; n++)
-		all_bits &= node->values.bits[n];
-	return all_bits == -1;
-}
-
-/*
- * Check if all bits in the bitset are off
- */
-static int
-acl_empty(struct rte_acl_node *node)
-{
-	uint32_t n;
-
-	if (node->ref_count == 0) {
-		for (n = 0; n < RTE_ACL_BIT_SET_SIZE; n++) {
-			if (0 != node->values.bits[n])
-				return 0;
-		}
-		return 1;
-	} else {
-		return 0;
-	}
-}
-
-/*
- * Compute intersection of A and B
- * return 1 if there is an intersection else 0.
- */
-static int
-acl_intersect(struct rte_acl_bitset *a_bits,
-	struct rte_acl_bitset *b_bits,
-	struct rte_acl_bitset *intersect)
-{
-	uint32_t n;
-	bits_t all_bits = 0;
-
-	for (n = 0; n < RTE_ACL_BIT_SET_SIZE; n++) {
-		intersect->bits[n] = a_bits->bits[n] & b_bits->bits[n];
-		all_bits |= intersect->bits[n];
-	}
-	return all_bits != 0;
-}
-
-/*
  * Duplicate a node
  */
 static struct rte_acl_node *
@@ -534,63 +478,6 @@ acl_deref_ptr(struct acl_build_context *context,
 }
 
 /*
- * Exclude bitset from a node pointer
- * returns  0 if poiter was deref'd
- *          1 otherwise.
- */
-static int
-acl_exclude_ptr(struct acl_build_context *context,
-	struct rte_acl_node *node,
-	int index,
-	struct rte_acl_bitset *b_bits)
-{
-	int retval = 1;
-
-	/*
-	 * remove bitset from node pointer and deref
-	 * if the bitset becomes empty.
-	 */
-	if (!acl_exclude(&node->ptrs[index].values,
-			&node->ptrs[index].values,
-			b_bits)) {
-		acl_deref_ptr(context, node, index);
-		node->ptrs[index].ptr = NULL;
-		retval = 0;
-	}
-
-	/* exclude bits from the composite bits for the node */
-	acl_exclude(&node->values, &node->values, b_bits);
-	return retval;
-}
-
-/*
- * Remove a bitset from src ptr and move remaining ptr to dst
- */
-static int
-acl_move_ptr(struct acl_build_context *context,
-	struct rte_acl_node *dst,
-	struct rte_acl_node *src,
-	int index,
-	struct rte_acl_bitset *b_bits)
-{
-	int rc;
-
-	if (b_bits != NULL)
-		if (!acl_exclude_ptr(context, src, index, b_bits))
-			return 0;
-
-	/* add src pointer to dst node */
-	rc = acl_add_ptr(context, dst, src->ptrs[index].ptr,
-			&src->ptrs[index].values);
-	if (rc < 0)
-		return rc;
-
-	/* remove ptr from src */
-	acl_exclude_ptr(context, src, index, &src->ptrs[index].values);
-	return 1;
-}
-
-/*
  * acl_exclude rte_acl_bitset from src and copy remaining pointer to dst
  */
 static int
@@ -650,203 +537,6 @@ acl_compact_node_ptrs(struct rte_acl_node *node_a)
 	}
 }
 
-/*
- * acl_merge helper routine.
- */
-static int
-acl_merge_intersect(struct acl_build_context *context,
-	struct rte_acl_node *node_a, uint32_t idx_a,
-	struct rte_acl_node *node_b, uint32_t idx_b,
-	int next_move, int level,
-	struct rte_acl_bitset *intersect_ptr)
-{
-	struct rte_acl_node *node_c;
-
-	/* Duplicate A for intersection */
-	node_c = acl_dup_node(context, node_a->ptrs[idx_a].ptr);
-
-	/* Remove intersection from A */
-	acl_exclude_ptr(context, node_a, idx_a, intersect_ptr);
-
-	/*
-	 * Added link from A to C for all transitions
-	 * in the intersection
-	 */
-	if (acl_add_ptr(context, node_a, node_c, intersect_ptr) < 0)
-		return -1;
-
-	/* merge B->node into C */
-	return acl_merge(context, node_c, node_b->ptrs[idx_b].ptr, next_move,
-		0, level + 1);
-}
-
-
-/*
- * Merge the children of nodes A and B together.
- *
- * if match node
- *	For each category
- *		node A result = highest priority result
- * if any pointers in A intersect with any in B
- *	For each intersection
- *		C = copy of node that A points to
- *		remove intersection from A pointer
- *		add a pointer to A that points to C for the intersection
- *		Merge C and node that B points to
- * Compact the pointers in A and B
- * if move flag
- *	If B has only one reference
- *		Move B pointers to A
- *	else
- *		Copy B pointers to A
- */
-static int
-acl_merge(struct acl_build_context *context,
-	struct rte_acl_node *node_a, struct rte_acl_node *node_b,
-	int move, int a_subset, int level)
-{
-	uint32_t n, m, ptrs_a, ptrs_b;
-	uint32_t min_add_a, min_add_b;
-	int intersect_type;
-	int node_intersect_type;
-	int b_full, next_move, rc;
-	struct rte_acl_bitset intersect_values;
-	struct rte_acl_bitset intersect_ptr;
-
-	min_add_a = 0;
-	min_add_b = 0;
-	intersect_type = 0;
-	node_intersect_type = 0;
-
-	if (level == 0)
-		a_subset = 1;
-
-	/*
-	 *  Resolve match priorities
-	 */
-	if (node_a->match_flag != 0 || node_b->match_flag != 0) {
-
-		if (node_a->match_flag == 0 || node_b->match_flag == 0)
-			RTE_LOG(ERR, ACL, "Not both matches\n");
-
-		if (node_b->match_flag < node_a->match_flag)
-			RTE_LOG(ERR, ACL, "Not same match\n");
-
-		for (n = 0; n < context->cfg.num_categories; n++) {
-			if (node_a->mrt->priority[n] <
-					node_b->mrt->priority[n]) {
-				node_a->mrt->priority[n] =
-					node_b->mrt->priority[n];
-				node_a->mrt->results[n] =
-					node_b->mrt->results[n];
-			}
-		}
-	}
-
-	/*
-	 * If the two node transitions intersect then merge the transitions.
-	 * Check intersection for entire node (all pointers)
-	 */
-	node_intersect_type = acl_intersect_type(&node_a->values,
-		&node_b->values,
-		&intersect_values);
-
-	if (node_intersect_type & ACL_INTERSECT) {
-
-		b_full = acl_full(node_b);
-
-		min_add_b = node_b->min_add;
-		node_b->min_add = node_b->num_ptrs;
-		ptrs_b = node_b->num_ptrs;
-
-		min_add_a = node_a->min_add;
-		node_a->min_add = node_a->num_ptrs;
-		ptrs_a = node_a->num_ptrs;
-
-		for (n = 0; n < ptrs_a; n++) {
-			for (m = 0; m < ptrs_b; m++) {
-
-				if (node_a->ptrs[n].ptr == NULL ||
-						node_b->ptrs[m].ptr == NULL ||
-						node_a->ptrs[n].ptr ==
-						node_b->ptrs[m].ptr)
-						continue;
-
-				intersect_type = acl_intersect_type(
-					&node_a->ptrs[n].values,
-					&node_b->ptrs[m].values,
-					&intersect_ptr);
-
-				/* If this node is not a 'match' node */
-				if ((intersect_type & ACL_INTERSECT) &&
-					(context->cfg.num_categories != 1 ||
-					!(node_a->ptrs[n].ptr->match_flag))) {
-
-					/*
-					 * next merge is a 'move' pointer,
-					 * if this one is and B is a
-					 * subset of the intersection.
-					 */
-					next_move = move &&
-						(intersect_type &
-						ACL_INTERSECT_B) == 0;
-
-					if (a_subset && b_full) {
-						rc = acl_merge(context,
-							node_a->ptrs[n].ptr,
-							node_b->ptrs[m].ptr,
-							next_move,
-							1, level + 1);
-						if (rc != 0)
-							return rc;
-					} else {
-						rc = acl_merge_intersect(
-							context, node_a, n,
-							node_b, m, next_move,
-							level, &intersect_ptr);
-						if (rc != 0)
-							return rc;
-					}
-				}
-			}
-		}
-	}
-
-	/* Compact pointers */
-	node_a->min_add = min_add_a;
-	acl_compact_node_ptrs(node_a);
-	node_b->min_add = min_add_b;
-	acl_compact_node_ptrs(node_b);
-
-	/*
-	 *  Either COPY or MOVE pointers from B to A
-	 */
-	acl_intersect(&node_a->values, &node_b->values, &intersect_values);
-
-	if (move && node_b->ref_count == 1) {
-		for (m = 0; m < node_b->num_ptrs; m++) {
-			if (node_b->ptrs[m].ptr != NULL &&
-					acl_move_ptr(context, node_a, node_b, m,
-					&intersect_values) < 0)
-				return -1;
-		}
-	} else {
-		for (m = 0; m < node_b->num_ptrs; m++) {
-			if (node_b->ptrs[m].ptr != NULL &&
-					acl_copy_ptr(context, node_a, node_b, m,
-					&intersect_values) < 0)
-				return -1;
-		}
-	}
-
-	/*
-	 *  Free node if its empty (no longer used)
-	 */
-	if (acl_empty(node_b))
-		acl_free_node(context, node_b);
-	return 0;
-}
-
 static int
 acl_resolve_leaf(struct acl_build_context *context,
 	struct rte_acl_node *node_a,
