all: rework ATTR_DIFF() macros to not generate attribute names

I find macros that stitch together names like "FAMILY_ATTR_##ATTR"
very confusing, because we no longer see where a certain name is used.
It breaks grepping for symbols, and it breaks cscope.

Yes, it's more verbose to not do that. If you really think that those
names are too verbose, then maybe they should get a shorter name. And
not use macros to make them palatable.

24 files changed, 483 insertions, 450 deletions

diff --git a/include/netlink-private/object-api.h b/include/netlink-private/object-api.h
index a2838fd4..a539e37d 100644
--- a/include/netlink-private/object-api.h
+++ b/include/netlink-private/object-api.h
@@ -149,12 +149,12 @@ extern "C" {
  * 	// We help ourselves in defining our own DIFF macro which will
  *	// call ATTR_DIFF() on both objects which will make sure to only
  *	// compare the attributes if required.
- * 	#define MY_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, MY_ATTR_##ATTR, a, b, EXPR)
+ * 	#define MY_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
  *
  * 	// Call our own diff macro for each attribute to build a bitmask
  *	// representing the attributes which mismatch.
- * 	diff |= MY_DIFF(FOO, a->foo != b->foo)
- * 	diff |= MY_DIFF(BAR, strcmp(a->bar, b->bar))
+ * 	diff |= MY_DIFF(MY_ATTR_FOO, a->foo != b->foo)
+ * 	diff |= MY_DIFF(MY_ATTR_BAR, strcmp(a->bar, b->bar))
  *
  * 	return diff;
  * }
diff --git a/lib/fib_lookup/request.c b/lib/fib_lookup/request.c
index 0773c3b0..aca7b1fc 100644
--- a/lib/fib_lookup/request.c
+++ b/lib/fib_lookup/request.c
@@ -57,15 +57,13 @@ static uint64_t request_compare(struct nl_object *_a, struct nl_object *_b,
 	struct flnl_request *b = (struct flnl_request *) _b;
 	uint64_t diff = 0;
 
-#define REQ_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, REQUEST_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= REQ_DIFF(FWMARK,	a->lr_fwmark != b->lr_fwmark);
-	diff |= REQ_DIFF(TOS,		a->lr_tos != b->lr_tos);
-	diff |= REQ_DIFF(SCOPE,		a->lr_scope != b->lr_scope);
-	diff |= REQ_DIFF(TABLE,		a->lr_table != b->lr_table);
-	diff |= REQ_DIFF(ADDR,		nl_addr_cmp(a->lr_addr, b->lr_addr));
-
-#undef REQ_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(REQUEST_ATTR_FWMARK, a->lr_fwmark != b->lr_fwmark);
+	diff |= _DIFF(REQUEST_ATTR_TOS, a->lr_tos != b->lr_tos);
+	diff |= _DIFF(REQUEST_ATTR_SCOPE, a->lr_scope != b->lr_scope);
+	diff |= _DIFF(REQUEST_ATTR_TABLE, a->lr_table != b->lr_table);
+	diff |= _DIFF(REQUEST_ATTR_ADDR, nl_addr_cmp(a->lr_addr, b->lr_addr));
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/genl/family.c b/lib/genl/family.c
index e8e0c9e0..14f586d3 100644
--- a/lib/genl/family.c
+++ b/lib/genl/family.c
@@ -153,15 +153,13 @@ static uint64_t family_compare(struct nl_object *_a, struct nl_object *_b,
 	struct genl_family *b = (struct genl_family *) _b;
 	uint64_t diff = 0;
 
-#define FAM_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, FAMILY_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= FAM_DIFF(ID,		a->gf_id != b->gf_id);
-	diff |= FAM_DIFF(VERSION,	a->gf_version != b->gf_version);
-	diff |= FAM_DIFF(HDRSIZE,	a->gf_hdrsize != b->gf_hdrsize);
-	diff |= FAM_DIFF(MAXATTR,	a->gf_maxattr != b->gf_maxattr);
-	diff |= FAM_DIFF(NAME,		strcmp(a->gf_name, b->gf_name));
-
-#undef FAM_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(FAMILY_ATTR_ID, a->gf_id != b->gf_id);
+	diff |= _DIFF(FAMILY_ATTR_VERSION, a->gf_version != b->gf_version);
+	diff |= _DIFF(FAMILY_ATTR_HDRSIZE, a->gf_hdrsize != b->gf_hdrsize);
+	diff |= _DIFF(FAMILY_ATTR_MAXATTR, a->gf_maxattr != b->gf_maxattr);
+	diff |= _DIFF(FAMILY_ATTR_NAME, strcmp(a->gf_name, b->gf_name));
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/idiag/idiag_msg_obj.c b/lib/idiag/idiag_msg_obj.c
index f42bd59d..0300b760 100644
--- a/lib/idiag/idiag_msg_obj.c
+++ b/lib/idiag/idiag_msg_obj.c
@@ -864,30 +864,45 @@ static uint64_t idiagnl_compare(struct nl_object *_a, struct nl_object *_b,
 	struct idiagnl_msg *b = (struct idiagnl_msg *) _b;
 	uint64_t diff = 0;
 
-#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, IDIAGNL_ATTR_##ATTR, a, b, EXPR)
-	diff |= _DIFF(FAMILY,    a->idiag_family != b->idiag_family);
-	diff |= _DIFF(STATE,     a->idiag_state != b->idiag_state);
-	diff |= _DIFF(TIMER,     a->idiag_timer != b->idiag_timer);
-	diff |= _DIFF(RETRANS,   a->idiag_retrans != b->idiag_retrans);
-	diff |= _DIFF(SPORT,     a->idiag_sport != b->idiag_sport);
-	diff |= _DIFF(DPORT,     a->idiag_dport != b->idiag_dport);
-	diff |= _DIFF(SRC,       nl_addr_cmp (a->idiag_src, b->idiag_src));
-	diff |= _DIFF(DST,       nl_addr_cmp (a->idiag_dst, b->idiag_dst));
-	diff |= _DIFF(IFINDEX,   a->idiag_ifindex != b->idiag_ifindex);
-	diff |= _DIFF(EXPIRES,   a->idiag_expires != b->idiag_expires);
-	diff |= _DIFF(RQUEUE,    a->idiag_rqueue != b->idiag_rqueue);
-	diff |= _DIFF(WQUEUE,    a->idiag_wqueue != b->idiag_wqueue);
-	diff |= _DIFF(UID,       a->idiag_uid != b->idiag_uid);
-	diff |= _DIFF(INODE,     a->idiag_inode != b->idiag_inode);
-	diff |= _DIFF(TOS,       a->idiag_tos != b->idiag_tos);
-	diff |= _DIFF(TCLASS,    a->idiag_tclass != b->idiag_tclass);
-	diff |= _DIFF(SHUTDOWN,  a->idiag_shutdown != b->idiag_shutdown);
-	diff |= _DIFF(CONG,      strcmp(a->idiag_cong, b->idiag_cong));
-	diff |= _DIFF(MEMINFO,   nl_object_diff((struct nl_object *) a->idiag_meminfo, (struct nl_object *) b->idiag_meminfo));
-	diff |= _DIFF(VEGASINFO, nl_object_diff((struct nl_object *) a->idiag_vegasinfo, (struct nl_object *) b->idiag_vegasinfo));
-	diff |= _DIFF(TCPINFO,   memcmp(&a->idiag_tcpinfo, &b->idiag_tcpinfo, sizeof(a->idiag_tcpinfo)));
-	diff |= _DIFF(SKMEMINFO, memcmp(a->idiag_skmeminfo, b->idiag_skmeminfo, sizeof(a->idiag_skmeminfo)));
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(IDIAGNL_ATTR_FAMILY, a->idiag_family != b->idiag_family);
+	diff |= _DIFF(IDIAGNL_ATTR_STATE, a->idiag_state != b->idiag_state);
+	diff |= _DIFF(IDIAGNL_ATTR_TIMER, a->idiag_timer != b->idiag_timer);
+	diff |= _DIFF(IDIAGNL_ATTR_RETRANS,
+		      a->idiag_retrans != b->idiag_retrans);
+	diff |= _DIFF(IDIAGNL_ATTR_SPORT, a->idiag_sport != b->idiag_sport);
+	diff |= _DIFF(IDIAGNL_ATTR_DPORT, a->idiag_dport != b->idiag_dport);
+	diff |= _DIFF(IDIAGNL_ATTR_SRC,
+		      nl_addr_cmp(a->idiag_src, b->idiag_src));
+	diff |= _DIFF(IDIAGNL_ATTR_DST,
+		      nl_addr_cmp(a->idiag_dst, b->idiag_dst));
+	diff |= _DIFF(IDIAGNL_ATTR_IFINDEX,
+		      a->idiag_ifindex != b->idiag_ifindex);
+	diff |= _DIFF(IDIAGNL_ATTR_EXPIRES,
+		      a->idiag_expires != b->idiag_expires);
+	diff |= _DIFF(IDIAGNL_ATTR_RQUEUE, a->idiag_rqueue != b->idiag_rqueue);
+	diff |= _DIFF(IDIAGNL_ATTR_WQUEUE, a->idiag_wqueue != b->idiag_wqueue);
+	diff |= _DIFF(IDIAGNL_ATTR_UID, a->idiag_uid != b->idiag_uid);
+	diff |= _DIFF(IDIAGNL_ATTR_INODE, a->idiag_inode != b->idiag_inode);
+	diff |= _DIFF(IDIAGNL_ATTR_TOS, a->idiag_tos != b->idiag_tos);
+	diff |= _DIFF(IDIAGNL_ATTR_TCLASS, a->idiag_tclass != b->idiag_tclass);
+	diff |= _DIFF(IDIAGNL_ATTR_SHUTDOWN,
+		      a->idiag_shutdown != b->idiag_shutdown);
+	diff |= _DIFF(IDIAGNL_ATTR_CONG, strcmp(a->idiag_cong, b->idiag_cong));
+	diff |= _DIFF(IDIAGNL_ATTR_MEMINFO,
+		      nl_object_diff((struct nl_object *)a->idiag_meminfo,
+				     (struct nl_object *)b->idiag_meminfo));
+	diff |= _DIFF(IDIAGNL_ATTR_VEGASINFO,
+		      nl_object_diff((struct nl_object *)a->idiag_vegasinfo,
+				     (struct nl_object *)b->idiag_vegasinfo));
+	diff |= _DIFF(IDIAGNL_ATTR_TCPINFO,
+		      memcmp(&a->idiag_tcpinfo, &b->idiag_tcpinfo,
+			     sizeof(a->idiag_tcpinfo)));
+	diff |= _DIFF(IDIAGNL_ATTR_SKMEMINFO,
+		      memcmp(a->idiag_skmeminfo, b->idiag_skmeminfo,
+			     sizeof(a->idiag_skmeminfo)));
 #undef _DIFF
+
 	return diff;
 }
 
diff --git a/lib/netfilter/ct_obj.c b/lib/netfilter/ct_obj.c
index 86cbc17c..c0303205 100644
--- a/lib/netfilter/ct_obj.c
+++ b/lib/netfilter/ct_obj.c
@@ -304,48 +304,46 @@ static uint64_t ct_compare(struct nl_object *_a, struct nl_object *_b,
 	struct nfnl_ct *b = (struct nfnl_ct *) _b;
 	uint64_t diff = 0;
 
-#define CT_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, CT_ATTR_##ATTR, a, b, EXPR)
-#define CT_DIFF_VAL(ATTR, FIELD) CT_DIFF(ATTR, a->FIELD != b->FIELD)
-#define CT_DIFF_ADDR(ATTR, FIELD) \
-	((flags & LOOSE_COMPARISON) \
-		? CT_DIFF(ATTR, nl_addr_cmp_prefix(a->FIELD, b->FIELD)) \
-		: CT_DIFF(ATTR, nl_addr_cmp(a->FIELD, b->FIELD)))
-
-	diff |= CT_DIFF_VAL(FAMILY,		ct_family);
-	diff |= CT_DIFF_VAL(PROTO,		ct_proto);
-	diff |= CT_DIFF_VAL(TCP_STATE,		ct_protoinfo.tcp.state);
-	diff |= CT_DIFF_VAL(TIMEOUT,		ct_timeout);
-	diff |= CT_DIFF_VAL(MARK,		ct_mark);
-	diff |= CT_DIFF_VAL(USE,		ct_use);
-	diff |= CT_DIFF_VAL(ID,			ct_id);
-	diff |= CT_DIFF_ADDR(ORIG_SRC,		ct_orig.src);
-	diff |= CT_DIFF_ADDR(ORIG_DST,		ct_orig.dst);
-	diff |= CT_DIFF_VAL(ORIG_SRC_PORT,	ct_orig.proto.port.src);
-	diff |= CT_DIFF_VAL(ORIG_DST_PORT,	ct_orig.proto.port.dst);
-	diff |= CT_DIFF_VAL(ORIG_ICMP_ID,	ct_orig.proto.icmp.id);
-	diff |= CT_DIFF_VAL(ORIG_ICMP_TYPE,	ct_orig.proto.icmp.type);
-	diff |= CT_DIFF_VAL(ORIG_ICMP_CODE,	ct_orig.proto.icmp.code);
-	diff |= CT_DIFF_VAL(ORIG_PACKETS,	ct_orig.packets);
-	diff |= CT_DIFF_VAL(ORIG_BYTES,		ct_orig.bytes);
-	diff |= CT_DIFF_ADDR(REPL_SRC,		ct_repl.src);
-	diff |= CT_DIFF_ADDR(REPL_DST,		ct_repl.dst);
-	diff |= CT_DIFF_VAL(REPL_SRC_PORT,	ct_repl.proto.port.src);
-	diff |= CT_DIFF_VAL(REPL_DST_PORT,	ct_repl.proto.port.dst);
-	diff |= CT_DIFF_VAL(REPL_ICMP_ID,	ct_repl.proto.icmp.id);
-	diff |= CT_DIFF_VAL(REPL_ICMP_TYPE,	ct_repl.proto.icmp.type);
-	diff |= CT_DIFF_VAL(REPL_ICMP_CODE,	ct_repl.proto.icmp.code);
-	diff |= CT_DIFF_VAL(REPL_PACKETS,	ct_repl.packets);
-	diff |= CT_DIFF_VAL(REPL_BYTES,		ct_repl.bytes);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+#define _DIFF_VAL(ATTR, FIELD) _DIFF(ATTR, a->FIELD != b->FIELD)
+#define _DIFF_ADDR(ATTR, FIELD)                                                \
+	((flags & LOOSE_COMPARISON) ?                                          \
+		 _DIFF(ATTR, nl_addr_cmp_prefix(a->FIELD, b->FIELD)) :         \
+		 _DIFF(ATTR, nl_addr_cmp(a->FIELD, b->FIELD)))
+	diff |= _DIFF_VAL(CT_ATTR_FAMILY, ct_family);
+	diff |= _DIFF_VAL(CT_ATTR_PROTO, ct_proto);
+	diff |= _DIFF_VAL(CT_ATTR_TCP_STATE, ct_protoinfo.tcp.state);
+	diff |= _DIFF_VAL(CT_ATTR_TIMEOUT, ct_timeout);
+	diff |= _DIFF_VAL(CT_ATTR_MARK, ct_mark);
+	diff |= _DIFF_VAL(CT_ATTR_USE, ct_use);
+	diff |= _DIFF_VAL(CT_ATTR_ID, ct_id);
+	diff |= _DIFF_ADDR(CT_ATTR_ORIG_SRC, ct_orig.src);
+	diff |= _DIFF_ADDR(CT_ATTR_ORIG_DST, ct_orig.dst);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_SRC_PORT, ct_orig.proto.port.src);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_DST_PORT, ct_orig.proto.port.dst);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_ICMP_ID, ct_orig.proto.icmp.id);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_ICMP_TYPE, ct_orig.proto.icmp.type);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_ICMP_CODE, ct_orig.proto.icmp.code);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_PACKETS, ct_orig.packets);
+	diff |= _DIFF_VAL(CT_ATTR_ORIG_BYTES, ct_orig.bytes);
+	diff |= _DIFF_ADDR(CT_ATTR_REPL_SRC, ct_repl.src);
+	diff |= _DIFF_ADDR(CT_ATTR_REPL_DST, ct_repl.dst);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_SRC_PORT, ct_repl.proto.port.src);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_DST_PORT, ct_repl.proto.port.dst);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_ICMP_ID, ct_repl.proto.icmp.id);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_ICMP_TYPE, ct_repl.proto.icmp.type);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_ICMP_CODE, ct_repl.proto.icmp.code);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_PACKETS, ct_repl.packets);
+	diff |= _DIFF_VAL(CT_ATTR_REPL_BYTES, ct_repl.bytes);
 
 	if (flags & LOOSE_COMPARISON)
-		diff |= CT_DIFF(STATUS, (a->ct_status ^ b->ct_status) &
-					b->ct_status_mask);
+		diff |= _DIFF(CT_ATTR_STATUS, (a->ct_status ^ b->ct_status) &
+						      b->ct_status_mask);
 	else
-		diff |= CT_DIFF(STATUS, a->ct_status != b->ct_status);
-
-#undef CT_DIFF
-#undef CT_DIFF_VAL
-#undef CT_DIFF_ADDR
+		diff |= _DIFF(CT_ATTR_STATUS, a->ct_status != b->ct_status);
+#undef _DIFF
+#undef _DIFF_VAL
+#undef _DIFF_ADDR
 
 	return diff;
 }
diff --git a/lib/netfilter/exp_obj.c b/lib/netfilter/exp_obj.c
index 21311c98..57f7b615 100644
--- a/lib/netfilter/exp_obj.c
+++ b/lib/netfilter/exp_obj.c
@@ -309,59 +309,67 @@ static uint64_t exp_compare(struct nl_object *_a, struct nl_object *_b,
 	struct nfnl_exp *b = (struct nfnl_exp *) _b;
 	uint64_t diff = 0;
 
-#define EXP_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, EXP_ATTR_##ATTR, a, b, EXPR)
-#define EXP_DIFF_VAL(ATTR, FIELD) EXP_DIFF(ATTR, a->FIELD != b->FIELD)
-#define EXP_DIFF_STRING(ATTR, FIELD) EXP_DIFF(ATTR, (strcmp(a->FIELD, b->FIELD) != 0))
-#define EXP_DIFF_ADDR(ATTR, FIELD) \
-		((flags & LOOSE_COMPARISON) \
-		? EXP_DIFF(ATTR, nl_addr_cmp_prefix(a->FIELD, b->FIELD)) \
-		: EXP_DIFF(ATTR, nl_addr_cmp(a->FIELD, b->FIELD)))
-#define EXP_DIFF_L4PROTO_PORTS(ATTR, FIELD) \
-		EXP_DIFF(ATTR, exp_cmp_l4proto_ports(&(a->FIELD), &(b->FIELD)))
-#define EXP_DIFF_L4PROTO_ICMP(ATTR, FIELD) \
-		EXP_DIFF(ATTR, exp_cmp_l4proto_icmp(&(a->FIELD), &(b->FIELD)))
-
-		diff |= EXP_DIFF_VAL(FAMILY,			exp_family);
-		diff |= EXP_DIFF_VAL(TIMEOUT,			exp_timeout);
-		diff |= EXP_DIFF_VAL(ID,			exp_id);
-		diff |= EXP_DIFF_VAL(ZONE,			exp_zone);
-		diff |= EXP_DIFF_VAL(CLASS,			exp_class);
-		diff |= EXP_DIFF_VAL(FLAGS,			exp_flags);
-		diff |= EXP_DIFF_VAL(NAT_DIR,			exp_nat_dir);
-
-		diff |= EXP_DIFF_STRING(FN,			exp_fn);
-		diff |= EXP_DIFF_STRING(HELPER_NAME,		exp_helper_name);
-
-		diff |= EXP_DIFF_ADDR(EXPECT_IP_SRC,			exp_expect.src);
-		diff |= EXP_DIFF_ADDR(EXPECT_IP_DST,			exp_expect.dst);
-		diff |= EXP_DIFF_VAL(EXPECT_L4PROTO_NUM,		exp_expect.proto.l4protonum);
-		diff |= EXP_DIFF_L4PROTO_PORTS(EXPECT_L4PROTO_PORTS,	exp_expect.proto.l4protodata);
-		diff |= EXP_DIFF_L4PROTO_ICMP(EXPECT_L4PROTO_ICMP,	exp_expect.proto.l4protodata);
-
-		diff |= EXP_DIFF_ADDR(MASTER_IP_SRC,			exp_master.src);
-		diff |= EXP_DIFF_ADDR(MASTER_IP_DST,			exp_master.dst);
-		diff |= EXP_DIFF_VAL(MASTER_L4PROTO_NUM,		exp_master.proto.l4protonum);
-		diff |= EXP_DIFF_L4PROTO_PORTS(MASTER_L4PROTO_PORTS,	exp_master.proto.l4protodata);
-		diff |= EXP_DIFF_L4PROTO_ICMP(MASTER_L4PROTO_ICMP,	exp_master.proto.l4protodata);
-
-		diff |= EXP_DIFF_ADDR(MASK_IP_SRC,			exp_mask.src);
-		diff |= EXP_DIFF_ADDR(MASK_IP_DST,			exp_mask.dst);
-		diff |= EXP_DIFF_VAL(MASK_L4PROTO_NUM,			exp_mask.proto.l4protonum);
-		diff |= EXP_DIFF_L4PROTO_PORTS(MASK_L4PROTO_PORTS,	exp_mask.proto.l4protodata);
-		diff |= EXP_DIFF_L4PROTO_ICMP(MASK_L4PROTO_ICMP,	exp_mask.proto.l4protodata);
-
-		diff |= EXP_DIFF_ADDR(NAT_IP_SRC,			exp_nat.src);
-		diff |= EXP_DIFF_ADDR(NAT_IP_DST,			exp_nat.dst);
-		diff |= EXP_DIFF_VAL(NAT_L4PROTO_NUM,			exp_nat.proto.l4protonum);
-		diff |= EXP_DIFF_L4PROTO_PORTS(NAT_L4PROTO_PORTS,	exp_nat.proto.l4protodata);
-		diff |= EXP_DIFF_L4PROTO_ICMP(NAT_L4PROTO_ICMP,		exp_nat.proto.l4protodata);
-
-#undef EXP_DIFF
-#undef EXP_DIFF_VAL
-#undef EXP_DIFF_STRING
-#undef EXP_DIFF_ADDR
-#undef EXP_DIFF_L4PROTO_PORTS
-#undef EXP_DIFF_L4PROTO_ICMP
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+#define _DIFF_VAL(ATTR, FIELD) _DIFF(ATTR, a->FIELD != b->FIELD)
+#define _DIFF_STRING(ATTR, FIELD) _DIFF(ATTR, (strcmp(a->FIELD, b->FIELD) != 0))
+#define _DIFF_ADDR(ATTR, FIELD)                                                \
+	((flags & LOOSE_COMPARISON) ?                                          \
+		 _DIFF(ATTR, nl_addr_cmp_prefix(a->FIELD, b->FIELD)) :         \
+		 _DIFF(ATTR, nl_addr_cmp(a->FIELD, b->FIELD)))
+#define _DIFF_L4PROTO_PORTS(ATTR, FIELD)                                       \
+	_DIFF(ATTR, exp_cmp_l4proto_ports(&(a->FIELD), &(b->FIELD)))
+#define _DIFF_L4PROTO_ICMP(ATTR, FIELD)                                        \
+	_DIFF(ATTR, exp_cmp_l4proto_icmp(&(a->FIELD), &(b->FIELD)))
+	diff |= _DIFF_VAL(EXP_ATTR_FAMILY, exp_family);
+	diff |= _DIFF_VAL(EXP_ATTR_TIMEOUT, exp_timeout);
+	diff |= _DIFF_VAL(EXP_ATTR_ID, exp_id);
+	diff |= _DIFF_VAL(EXP_ATTR_ZONE, exp_zone);
+	diff |= _DIFF_VAL(EXP_ATTR_CLASS, exp_class);
+	diff |= _DIFF_VAL(EXP_ATTR_FLAGS, exp_flags);
+	diff |= _DIFF_VAL(EXP_ATTR_NAT_DIR, exp_nat_dir);
+
+	diff |= _DIFF_STRING(EXP_ATTR_FN, exp_fn);
+	diff |= _DIFF_STRING(EXP_ATTR_HELPER_NAME, exp_helper_name);
+
+	diff |= _DIFF_ADDR(EXP_ATTR_EXPECT_IP_SRC, exp_expect.src);
+	diff |= _DIFF_ADDR(EXP_ATTR_EXPECT_IP_DST, exp_expect.dst);
+	diff |= _DIFF_VAL(EXP_ATTR_EXPECT_L4PROTO_NUM,
+			  exp_expect.proto.l4protonum);
+	diff |= _DIFF_L4PROTO_PORTS(EXP_ATTR_EXPECT_L4PROTO_PORTS,
+				    exp_expect.proto.l4protodata);
+	diff |= _DIFF_L4PROTO_ICMP(EXP_ATTR_EXPECT_L4PROTO_ICMP,
+				   exp_expect.proto.l4protodata);
+
+	diff |= _DIFF_ADDR(EXP_ATTR_MASTER_IP_SRC, exp_master.src);
+	diff |= _DIFF_ADDR(EXP_ATTR_MASTER_IP_DST, exp_master.dst);
+	diff |= _DIFF_VAL(EXP_ATTR_MASTER_L4PROTO_NUM,
+			  exp_master.proto.l4protonum);
+	diff |= _DIFF_L4PROTO_PORTS(EXP_ATTR_MASTER_L4PROTO_PORTS,
+				    exp_master.proto.l4protodata);
+	diff |= _DIFF_L4PROTO_ICMP(EXP_ATTR_MASTER_L4PROTO_ICMP,
+				   exp_master.proto.l4protodata);
+
+	diff |= _DIFF_ADDR(EXP_ATTR_MASK_IP_SRC, exp_mask.src);
+	diff |= _DIFF_ADDR(EXP_ATTR_MASK_IP_DST, exp_mask.dst);
+	diff |= _DIFF_VAL(EXP_ATTR_MASK_L4PROTO_NUM, exp_mask.proto.l4protonum);
+	diff |= _DIFF_L4PROTO_PORTS(EXP_ATTR_MASK_L4PROTO_PORTS,
+				    exp_mask.proto.l4protodata);
+	diff |= _DIFF_L4PROTO_ICMP(EXP_ATTR_MASK_L4PROTO_ICMP,
+				   exp_mask.proto.l4protodata);
+
+	diff |= _DIFF_ADDR(EXP_ATTR_NAT_IP_SRC, exp_nat.src);
+	diff |= _DIFF_ADDR(EXP_ATTR_NAT_IP_DST, exp_nat.dst);
+	diff |= _DIFF_VAL(EXP_ATTR_NAT_L4PROTO_NUM, exp_nat.proto.l4protonum);
+	diff |= _DIFF_L4PROTO_PORTS(EXP_ATTR_NAT_L4PROTO_PORTS,
+				    exp_nat.proto.l4protodata);
+	diff |= _DIFF_L4PROTO_ICMP(EXP_ATTR_NAT_L4PROTO_ICMP,
+				   exp_nat.proto.l4protodata);
+#undef _DIFF
+#undef _DIFF_VAL
+#undef _DIFF_STRING
+#undef _DIFF_ADDR
+#undef _DIFF_L4PROTO_PORTS
+#undef _DIFF_L4PROTO_ICMP
 
 	return diff;
 }
diff --git a/lib/netfilter/log_obj.c b/lib/netfilter/log_obj.c
index e26e5bd9..01b50f97 100644
--- a/lib/netfilter/log_obj.c
+++ b/lib/netfilter/log_obj.c
@@ -237,17 +237,15 @@ static uint64_t nfnl_log_compare(struct nl_object *_a, struct nl_object *_b,
 	uint64_t diff = 0;
 
 #define NFNL_LOG_DIFF(ATTR, EXPR) \
-	ATTR_DIFF(attrs, LOG_ATTR_##ATTR, a, b, EXPR)
+	ATTR_DIFF(attrs, ATTR, a, b, EXPR)
 #define NFNL_LOG_DIFF_VAL(ATTR, FIELD) \
 	NFNL_LOG_DIFF(ATTR, a->FIELD != b->FIELD)
-
-	diff |= NFNL_LOG_DIFF_VAL(GROUP,		log_group);
-	diff |= NFNL_LOG_DIFF_VAL(COPY_MODE,		log_copy_mode);
-	diff |= NFNL_LOG_DIFF_VAL(COPY_RANGE,		log_copy_range);
-	diff |= NFNL_LOG_DIFF_VAL(FLUSH_TIMEOUT,	log_flush_timeout);
-	diff |= NFNL_LOG_DIFF_VAL(ALLOC_SIZE,		log_alloc_size);
-	diff |= NFNL_LOG_DIFF_VAL(QUEUE_THRESHOLD,	log_queue_threshold);
-
+	diff |= NFNL_LOG_DIFF_VAL(LOG_ATTR_GROUP,		log_group);
+	diff |= NFNL_LOG_DIFF_VAL(LOG_ATTR_COPY_MODE,		log_copy_mode);
+	diff |= NFNL_LOG_DIFF_VAL(LOG_ATTR_COPY_RANGE,		log_copy_range);
+	diff |= NFNL_LOG_DIFF_VAL(LOG_ATTR_FLUSH_TIMEOUT,	log_flush_timeout);
+	diff |= NFNL_LOG_DIFF_VAL(LOG_ATTR_ALLOC_SIZE,		log_alloc_size);
+	diff |= NFNL_LOG_DIFF_VAL(LOG_ATTR_QUEUE_THRESHOLD,	log_queue_threshold);
 #undef NFNL_LOG_DIFF
 #undef NFNL_LOG_DIFF_VAL
 
diff --git a/lib/netfilter/queue_obj.c b/lib/netfilter/queue_obj.c
index 1ea461d8..d1003f6a 100644
--- a/lib/netfilter/queue_obj.c
+++ b/lib/netfilter/queue_obj.c
@@ -162,18 +162,14 @@ static uint64_t nfnl_queue_compare(struct nl_object *_a, struct nl_object *_b,
 	struct nfnl_queue *b = (struct nfnl_queue *) _b;
 	uint64_t diff = 0;
 
-#define NFNL_QUEUE_DIFF(ATTR, EXPR) \
-	ATTR_DIFF(attrs, QUEUE_ATTR_##ATTR, a, b, EXPR)
-#define NFNL_QUEUE_DIFF_VAL(ATTR, FIELD) \
-	NFNL_QUEUE_DIFF(ATTR, a->FIELD != b->FIELD)
-
-	diff |= NFNL_QUEUE_DIFF_VAL(GROUP,	queue_group);
-	diff |= NFNL_QUEUE_DIFF_VAL(MAXLEN,	queue_maxlen);
-	diff |= NFNL_QUEUE_DIFF_VAL(COPY_MODE,	queue_copy_mode);
-	diff |= NFNL_QUEUE_DIFF_VAL(COPY_RANGE,	queue_copy_range);
-
-#undef NFNL_QUEUE_DIFF
-#undef NFNL_QUEUE_DIFF_VAL
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+#define _DIFF_VAL(ATTR, FIELD) _DIFF(ATTR, a->FIELD != b->FIELD)
+	diff |= _DIFF_VAL(QUEUE_ATTR_GROUP, queue_group);
+	diff |= _DIFF_VAL(QUEUE_ATTR_MAXLEN, queue_maxlen);
+	diff |= _DIFF_VAL(QUEUE_ATTR_COPY_MODE, queue_copy_mode);
+	diff |= _DIFF_VAL(QUEUE_ATTR_COPY_RANGE, queue_copy_range);
+#undef _DIFF
+#undef _DIFF_VAL
 
 	return diff;
 }
diff --git a/lib/route/addr.c b/lib/route/addr.c
index 5d9c3539..aef3039a 100644
--- a/lib/route/addr.c
+++ b/lib/route/addr.c
@@ -493,12 +493,12 @@ static uint64_t addr_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_addr *b = (struct rtnl_addr *) _b;
 	uint64_t diff = 0;
 
-#define ADDR_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ADDR_ATTR_##ATTR, a, b, EXPR)
+#define ADDR_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
 
-	diff |= ADDR_DIFF(IFINDEX,	a->a_ifindex != b->a_ifindex);
-	diff |= ADDR_DIFF(FAMILY,	a->a_family != b->a_family);
-	diff |= ADDR_DIFF(SCOPE,	a->a_scope != b->a_scope);
-	diff |= ADDR_DIFF(LABEL,	strcmp(a->a_label, b->a_label));
+	diff |= ADDR_DIFF(ADDR_ATTR_IFINDEX,	a->a_ifindex != b->a_ifindex);
+	diff |= ADDR_DIFF(ADDR_ATTR_FAMILY,	a->a_family != b->a_family);
+	diff |= ADDR_DIFF(ADDR_ATTR_SCOPE,	a->a_scope != b->a_scope);
+	diff |= ADDR_DIFF(ADDR_ATTR_LABEL,	strcmp(a->a_label, b->a_label));
 	if (attrs & ADDR_ATTR_PEER) {
 		if (   (flags & ID_COMPARISON)
 		    && a->a_family == AF_INET
@@ -509,23 +509,23 @@ static uint64_t addr_compare(struct nl_object *_a, struct nl_object *_b,
 			/* when comparing two IPv4 addresses for id-equality, the network part
 			 * of the PEER address shall be compared.
 			 */
-			diff |= ADDR_DIFF(PEER, nl_addr_cmp_prefix(a->a_peer, b->a_peer));
+			diff |= ADDR_DIFF(ADDR_ATTR_PEER, nl_addr_cmp_prefix(a->a_peer, b->a_peer));
 		} else
-			diff |= ADDR_DIFF(PEER, nl_addr_cmp(a->a_peer, b->a_peer));
+			diff |= ADDR_DIFF(ADDR_ATTR_PEER, nl_addr_cmp(a->a_peer, b->a_peer));
 	}
-	diff |= ADDR_DIFF(LOCAL,	nl_addr_cmp(a->a_local, b->a_local));
-	diff |= ADDR_DIFF(MULTICAST,	nl_addr_cmp(a->a_multicast,
-						    b->a_multicast));
-	diff |= ADDR_DIFF(BROADCAST,	nl_addr_cmp(a->a_bcast, b->a_bcast));
-	diff |= ADDR_DIFF(ANYCAST,	nl_addr_cmp(a->a_anycast, b->a_anycast));
-	diff |= ADDR_DIFF(CACHEINFO,    memcmp(&a->a_cacheinfo, &b->a_cacheinfo,
+	diff |= ADDR_DIFF(ADDR_ATTR_LOCAL,	nl_addr_cmp(a->a_local, b->a_local));
+	diff |= ADDR_DIFF(ADDR_ATTR_MULTICAST,	nl_addr_cmp(a->a_multicast,
+							    b->a_multicast));
+	diff |= ADDR_DIFF(ADDR_ATTR_BROADCAST,	nl_addr_cmp(a->a_bcast, b->a_bcast));
+	diff |= ADDR_DIFF(ADDR_ATTR_ANYCAST,	nl_addr_cmp(a->a_anycast, b->a_anycast));
+	diff |= ADDR_DIFF(ADDR_ATTR_CACHEINFO,	memcmp(&a->a_cacheinfo, &b->a_cacheinfo,
 	                                       sizeof (a->a_cacheinfo)));
 
 	if (flags & LOOSE_COMPARISON)
-		diff |= ADDR_DIFF(FLAGS,
+		diff |= ADDR_DIFF(ADDR_ATTR_FLAGS,
 				  (a->a_flags ^ b->a_flags) & b->a_flag_mask);
 	else
-		diff |= ADDR_DIFF(FLAGS, a->a_flags != b->a_flags);
+		diff |= ADDR_DIFF(ADDR_ATTR_FLAGS, a->a_flags != b->a_flags);
 
 #undef ADDR_DIFF
 
diff --git a/lib/route/link.c b/lib/route/link.c
index 0d7a63a6..e1844ec4 100644
--- a/lib/route/link.c
+++ b/lib/route/link.c
@@ -1111,34 +1111,37 @@ static uint64_t link_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_link *b = (struct rtnl_link *) _b;
 	uint64_t diff = 0;
 
-#define LINK_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, LINK_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= LINK_DIFF(IFINDEX,	a->l_index != b->l_index);
-	diff |= LINK_DIFF(MTU,		a->l_mtu != b->l_mtu);
-	diff |= LINK_DIFF(LINK,		a->l_link != b->l_link);
-	diff |= LINK_DIFF(LINK_NETNSID, a->l_link_netnsid != b->l_link_netnsid);
-	diff |= LINK_DIFF(TXQLEN,	a->l_txqlen != b->l_txqlen);
-	diff |= LINK_DIFF(WEIGHT,	a->l_weight != b->l_weight);
-	diff |= LINK_DIFF(MASTER,	a->l_master != b->l_master);
-	diff |= LINK_DIFF(FAMILY,	a->l_family != b->l_family);
-	diff |= LINK_DIFF(OPERSTATE,	a->l_operstate != b->l_operstate);
-	diff |= LINK_DIFF(LINKMODE,	a->l_linkmode != b->l_linkmode);
-	diff |= LINK_DIFF(QDISC,	strcmp(a->l_qdisc, b->l_qdisc));
-	diff |= LINK_DIFF(IFNAME,	strcmp(a->l_name, b->l_name));
-	diff |= LINK_DIFF(ADDR,		nl_addr_cmp(a->l_addr, b->l_addr));
-	diff |= LINK_DIFF(BRD,		nl_addr_cmp(a->l_bcast, b->l_bcast));
-	diff |= LINK_DIFF(IFALIAS,	strcmp(a->l_ifalias, b->l_ifalias));
-	diff |= LINK_DIFF(NUM_VF,	a->l_num_vf != b->l_num_vf);
-	diff |= LINK_DIFF(PROMISCUITY,	a->l_promiscuity != b->l_promiscuity);
-	diff |= LINK_DIFF(NUM_TX_QUEUES,a->l_num_tx_queues != b->l_num_tx_queues);
-	diff |= LINK_DIFF(NUM_RX_QUEUES,a->l_num_rx_queues != b->l_num_rx_queues);
-	diff |= LINK_DIFF(GROUP,	a->l_group != b->l_group);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(LINK_ATTR_IFINDEX, a->l_index != b->l_index);
+	diff |= _DIFF(LINK_ATTR_MTU, a->l_mtu != b->l_mtu);
+	diff |= _DIFF(LINK_ATTR_LINK, a->l_link != b->l_link);
+	diff |= _DIFF(LINK_ATTR_LINK_NETNSID,
+		      a->l_link_netnsid != b->l_link_netnsid);
+	diff |= _DIFF(LINK_ATTR_TXQLEN, a->l_txqlen != b->l_txqlen);
+	diff |= _DIFF(LINK_ATTR_WEIGHT, a->l_weight != b->l_weight);
+	diff |= _DIFF(LINK_ATTR_MASTER, a->l_master != b->l_master);
+	diff |= _DIFF(LINK_ATTR_FAMILY, a->l_family != b->l_family);
+	diff |= _DIFF(LINK_ATTR_OPERSTATE, a->l_operstate != b->l_operstate);
+	diff |= _DIFF(LINK_ATTR_LINKMODE, a->l_linkmode != b->l_linkmode);
+	diff |= _DIFF(LINK_ATTR_QDISC, strcmp(a->l_qdisc, b->l_qdisc));
+	diff |= _DIFF(LINK_ATTR_IFNAME, strcmp(a->l_name, b->l_name));
+	diff |= _DIFF(LINK_ATTR_ADDR, nl_addr_cmp(a->l_addr, b->l_addr));
+	diff |= _DIFF(LINK_ATTR_BRD, nl_addr_cmp(a->l_bcast, b->l_bcast));
+	diff |= _DIFF(LINK_ATTR_IFALIAS, strcmp(a->l_ifalias, b->l_ifalias));
+	diff |= _DIFF(LINK_ATTR_NUM_VF, a->l_num_vf != b->l_num_vf);
+	diff |= _DIFF(LINK_ATTR_PROMISCUITY,
+		      a->l_promiscuity != b->l_promiscuity);
+	diff |= _DIFF(LINK_ATTR_NUM_TX_QUEUES,
+		      a->l_num_tx_queues != b->l_num_tx_queues);
+	diff |= _DIFF(LINK_ATTR_NUM_RX_QUEUES,
+		      a->l_num_rx_queues != b->l_num_rx_queues);
+	diff |= _DIFF(LINK_ATTR_GROUP, a->l_group != b->l_group);
 
 	if (flags & LOOSE_COMPARISON)
-		diff |= LINK_DIFF(FLAGS,
+		diff |= _DIFF(LINK_ATTR_FLAGS,
 				  (a->l_flags ^ b->l_flags) & b->l_flag_mask);
 	else
-		diff |= LINK_DIFF(FLAGS, a->l_flags != b->l_flags);
+		diff |= _DIFF(LINK_ATTR_FLAGS, a->l_flags != b->l_flags);
 
 	/*
 	 * Compare LINK_ATTR_PROTINFO af_data
@@ -1148,15 +1151,15 @@ static uint64_t link_compare(struct nl_object *_a, struct nl_object *_b,
 			goto protinfo_mismatch;
 	}
 
-	diff |= LINK_DIFF(LINKINFO, rtnl_link_info_data_compare(a, b, flags) != 0);
+	diff |= _DIFF(LINK_ATTR_LINKINFO, rtnl_link_info_data_compare(a, b, flags) != 0);
 out:
 	return diff;
 
 protinfo_mismatch:
-	diff |= LINK_DIFF(PROTINFO, 1);
+	diff |= _DIFF(LINK_ATTR_PROTINFO, 1);
 	goto out;
 
-#undef LINK_DIFF
+#undef _DIFF
 }
 
 static const struct trans_tbl link_attrs[] = {
diff --git a/lib/route/link/bridge.c b/lib/route/link/bridge.c
index e61b3756..89d30f3c 100644
--- a/lib/route/link/bridge.c
+++ b/lib/route/link/bridge.c
@@ -431,21 +431,23 @@ static int bridge_compare(struct rtnl_link *_a, struct rtnl_link *_b,
 	struct bridge_data *b = bridge_data(_b);
 	int diff = 0;
 
-#define BRIDGE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, BRIDGE_ATTR_##ATTR, a, b, EXPR)
-	diff |= BRIDGE_DIFF(PORT_STATE,	a->b_port_state != b->b_port_state);
-	diff |= BRIDGE_DIFF(PRIORITY, a->b_priority != b->b_priority);
-	diff |= BRIDGE_DIFF(COST, a->b_cost != b->b_cost);
-	diff |= BRIDGE_DIFF(PORT_VLAN, memcmp(&a->vlan_info, &b->vlan_info,
-					      sizeof(struct rtnl_link_bridge_vlan)));
-	diff |= BRIDGE_DIFF(HWMODE, a->b_hwmode != b->b_hwmode);
-	diff |= BRIDGE_DIFF(SELF, a->b_self != b->b_self);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(BRIDGE_ATTR_PORT_STATE,
+		      a->b_port_state != b->b_port_state);
+	diff |= _DIFF(BRIDGE_ATTR_PRIORITY, a->b_priority != b->b_priority);
+	diff |= _DIFF(BRIDGE_ATTR_COST, a->b_cost != b->b_cost);
+	diff |= _DIFF(BRIDGE_ATTR_PORT_VLAN,
+		      memcmp(&a->vlan_info, &b->vlan_info,
+			     sizeof(struct rtnl_link_bridge_vlan)));
+	diff |= _DIFF(BRIDGE_ATTR_HWMODE, a->b_hwmode != b->b_hwmode);
+	diff |= _DIFF(BRIDGE_ATTR_SELF, a->b_self != b->b_self);
 
 	if (flags & LOOSE_COMPARISON)
-		diff |= BRIDGE_DIFF(FLAGS,
-				  (a->b_flags ^ b->b_flags) & b->b_flags_mask);
+		diff |= _DIFF(BRIDGE_ATTR_FLAGS,
+			      (a->b_flags ^ b->b_flags) & b->b_flags_mask);
 	else
-		diff |= BRIDGE_DIFF(FLAGS, a->b_flags != b->b_flags);
-#undef BRIDGE_DIFF
+		diff |= _DIFF(BRIDGE_ATTR_FLAGS, a->b_flags != b->b_flags);
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/link/macsec.c b/lib/route/link/macsec.c
index e8879ab0..821f25f9 100644
--- a/lib/route/link/macsec.c
+++ b/lib/route/link/macsec.c
@@ -367,33 +367,38 @@ static int macsec_compare(struct rtnl_link *link_a, struct rtnl_link *link_b,
 	int diff = 0;
 	uint32_t attrs = flags & LOOSE_COMPARISON ? b->ce_mask : ~0;
 
-#define MACSEC_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, MACSEC_ATTR_##ATTR, a, b, EXPR)
-
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
 	if (a->ce_mask & MACSEC_ATTR_SCI && b->ce_mask & MACSEC_ATTR_SCI)
-		diff |= MACSEC_DIFF(SCI, a->sci != b->sci);
+		diff |= _DIFF(MACSEC_ATTR_SCI, a->sci != b->sci);
 	else if (a->ce_mask & MACSEC_ATTR_PORT && b->ce_mask & MACSEC_ATTR_PORT)
-		diff |= MACSEC_DIFF(PORT, a->port != b->port);
+		diff |= _DIFF(MACSEC_ATTR_PORT, a->port != b->port);
 
-	if (a->ce_mask & MACSEC_ATTR_CIPHER_SUITE && b->ce_mask & MACSEC_ATTR_CIPHER_SUITE) {
-		diff |= MACSEC_DIFF(ICV_LEN, a->icv_len != b->icv_len);
-		diff |= MACSEC_DIFF(CIPHER_SUITE, a->cipher_suite != b->cipher_suite);
+	if (a->ce_mask & MACSEC_ATTR_CIPHER_SUITE &&
+	    b->ce_mask & MACSEC_ATTR_CIPHER_SUITE) {
+		diff |= _DIFF(MACSEC_ATTR_ICV_LEN, a->icv_len != b->icv_len);
+		diff |= _DIFF(MACSEC_ATTR_CIPHER_SUITE,
+			      a->cipher_suite != b->cipher_suite);
 	}
 
-	if (a->ce_mask & MACSEC_ATTR_REPLAY_PROTECT && b->ce_mask & MACSEC_ATTR_REPLAY_PROTECT) {
-		int d = MACSEC_DIFF(REPLAY_PROTECT, a->replay_protect != b->replay_protect);
-		if (a->replay_protect && b->replay_protect)
-			d |= MACSEC_DIFF(WINDOW, a->window != b->window);
+	if (a->ce_mask & MACSEC_ATTR_REPLAY_PROTECT &&
+	    b->ce_mask & MACSEC_ATTR_REPLAY_PROTECT) {
+		int d = _DIFF(MACSEC_ATTR_REPLAY_PROTECT,
+			      a->replay_protect != b->replay_protect);
+		if (a->replay_protect && b->replay_protect) {
+			d |= _DIFF(MACSEC_ATTR_WINDOW, a->window != b->window);
+		}
 		diff |= d;
 	}
 
-	diff |= MACSEC_DIFF(ENCODING_SA, a->encoding_sa != b->encoding_sa);
-	diff |= MACSEC_DIFF(ENCRYPT, a->encrypt != b->encrypt);
-	diff |= MACSEC_DIFF(PROTECT, a->protect != b->protect);
-	diff |= MACSEC_DIFF(INC_SCI, a->send_sci != b->send_sci);
-	diff |= MACSEC_DIFF(ES, a->end_station != b->end_station);
-	diff |= MACSEC_DIFF(SCB, a->scb != b->scb);
-	diff |= MACSEC_DIFF(VALIDATION, a->validate != b->validate);
-#undef MACSEC_DIFF
+	diff |= _DIFF(MACSEC_ATTR_ENCODING_SA,
+		      a->encoding_sa != b->encoding_sa);
+	diff |= _DIFF(MACSEC_ATTR_ENCRYPT, a->encrypt != b->encrypt);
+	diff |= _DIFF(MACSEC_ATTR_PROTECT, a->protect != b->protect);
+	diff |= _DIFF(MACSEC_ATTR_INC_SCI, a->send_sci != b->send_sci);
+	diff |= _DIFF(MACSEC_ATTR_ES, a->end_station != b->end_station);
+	diff |= _DIFF(MACSEC_ATTR_SCB, a->scb != b->scb);
+	diff |= _DIFF(MACSEC_ATTR_VALIDATION, a->validate != b->validate);
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/link/vxlan.c b/lib/route/link/vxlan.c
index 7b8429c8..17782656 100644
--- a/lib/route/link/vxlan.c
+++ b/lib/route/link/vxlan.c
@@ -616,37 +616,41 @@ static int vxlan_compare(struct rtnl_link *link_a, struct rtnl_link *link_b,
 	int diff = 0;
 	uint32_t attrs = flags & LOOSE_COMPARISON ? b->ce_mask : ~0;
 
-#define VXLAN_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, VXLAN_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= VXLAN_DIFF(ID,    a->vxi_id    != b->vxi_id);
-	diff |= VXLAN_DIFF(GROUP, a->vxi_group != b->vxi_group);
-	diff |= VXLAN_DIFF(LINK,  a->vxi_link  != b->vxi_link);
-	diff |= VXLAN_DIFF(LOCAL, a->vxi_local != b->vxi_local);
-	diff |= VXLAN_DIFF(TOS,   a->vxi_tos   != b->vxi_tos);
-	diff |= VXLAN_DIFF(TTL,   a->vxi_ttl   != b->vxi_ttl);
-	diff |= VXLAN_DIFF(LEARNING, a->vxi_learning != b->vxi_learning);
-	diff |= VXLAN_DIFF(AGEING, a->vxi_ageing != b->vxi_ageing);
-	diff |= VXLAN_DIFF(LIMIT, a->vxi_limit != b->vxi_limit);
-	diff |= VXLAN_DIFF(PORT_RANGE,
-	                   a->vxi_port_range.low != b->vxi_port_range.low);
-	diff |= VXLAN_DIFF(PORT_RANGE,
-	                   a->vxi_port_range.high != b->vxi_port_range.high);
-	diff |= VXLAN_DIFF(PROXY, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(RSC, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(L2MISS, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(L3MISS, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(PORT, a->vxi_port != b->vxi_port);
-	diff |= VXLAN_DIFF(GROUP6, memcmp(&a->vxi_group6, &b->vxi_group6, sizeof(a->vxi_group6)) != 0);
-	diff |= VXLAN_DIFF(LOCAL6,  memcmp(&a->vxi_local6, &b->vxi_local6, sizeof(a->vxi_local6)) != 0);
-	diff |= VXLAN_DIFF(UDP_CSUM, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(UDP_ZERO_CSUM6_TX, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(UDP_ZERO_CSUM6_RX, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(REMCSUM_TX, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(REMCSUM_RX, a->vxi_proxy != b->vxi_proxy);
-	diff |= VXLAN_DIFF(COLLECT_METADATA, a->vxi_collect_metadata != b->vxi_collect_metadata);
-	diff |= VXLAN_DIFF(LABEL, a->vxi_label != b->vxi_label);
-	diff |= VXLAN_DIFF(FLAGS, a->vxi_flags != b->vxi_flags);
-#undef VXLAN_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(VXLAN_ATTR_ID, a->vxi_id != b->vxi_id);
+	diff |= _DIFF(VXLAN_ATTR_GROUP, a->vxi_group != b->vxi_group);
+	diff |= _DIFF(VXLAN_ATTR_LINK, a->vxi_link != b->vxi_link);
+	diff |= _DIFF(VXLAN_ATTR_LOCAL, a->vxi_local != b->vxi_local);
+	diff |= _DIFF(VXLAN_ATTR_TOS, a->vxi_tos != b->vxi_tos);
+	diff |= _DIFF(VXLAN_ATTR_TTL, a->vxi_ttl != b->vxi_ttl);
+	diff |= _DIFF(VXLAN_ATTR_LEARNING, a->vxi_learning != b->vxi_learning);
+	diff |= _DIFF(VXLAN_ATTR_AGEING, a->vxi_ageing != b->vxi_ageing);
+	diff |= _DIFF(VXLAN_ATTR_LIMIT, a->vxi_limit != b->vxi_limit);
+	diff |= _DIFF(VXLAN_ATTR_PORT_RANGE,
+		      a->vxi_port_range.low != b->vxi_port_range.low);
+	diff |= _DIFF(VXLAN_ATTR_PORT_RANGE,
+		      a->vxi_port_range.high != b->vxi_port_range.high);
+	diff |= _DIFF(VXLAN_ATTR_PROXY, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_RSC, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_L2MISS, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_L3MISS, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_PORT, a->vxi_port != b->vxi_port);
+	diff |= _DIFF(VXLAN_ATTR_GROUP6, memcmp(&a->vxi_group6, &b->vxi_group6,
+						sizeof(a->vxi_group6)) != 0);
+	diff |= _DIFF(VXLAN_ATTR_LOCAL6, memcmp(&a->vxi_local6, &b->vxi_local6,
+						sizeof(a->vxi_local6)) != 0);
+	diff |= _DIFF(VXLAN_ATTR_UDP_CSUM, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_UDP_ZERO_CSUM6_TX,
+		      a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_UDP_ZERO_CSUM6_RX,
+		      a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_REMCSUM_TX, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_REMCSUM_RX, a->vxi_proxy != b->vxi_proxy);
+	diff |= _DIFF(VXLAN_ATTR_COLLECT_METADATA,
+		      a->vxi_collect_metadata != b->vxi_collect_metadata);
+	diff |= _DIFF(VXLAN_ATTR_LABEL, a->vxi_label != b->vxi_label);
+	diff |= _DIFF(VXLAN_ATTR_FLAGS, a->vxi_flags != b->vxi_flags);
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/mdb.c b/lib/route/mdb.c
index 459959ee..e6df2443 100644
--- a/lib/route/mdb.c
+++ b/lib/route/mdb.c
@@ -55,9 +55,9 @@ static uint64_t mdb_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_mdb_entry *a_entry, *b_entry;
 	uint64_t diff = 0;
 
-#define MDB_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, MDB_ATTR_##ATTR, a, b, EXPR)
-	diff |= MDB_DIFF(IFINDEX, a->ifindex != b->ifindex);
-#undef MDB_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(MDB_ATTR_IFINDEX, a->ifindex != b->ifindex);
+#undef _DIFF
 
 	a_entry = nl_list_entry(a->mdb_entry_list.next, struct rtnl_mdb_entry, mdb_list);
 	b_entry = nl_list_entry(b->mdb_entry_list.next, struct rtnl_mdb_entry, mdb_list);
diff --git a/lib/route/neigh.c b/lib/route/neigh.c
index 98969a9d..6c6787cc 100644
--- a/lib/route/neigh.c
+++ b/lib/route/neigh.c
@@ -265,27 +265,25 @@ static uint64_t neigh_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_neigh *b = (struct rtnl_neigh *) _b;
 	uint64_t diff = 0;
 
-#define NEIGH_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NEIGH_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= NEIGH_DIFF(IFINDEX,	a->n_ifindex != b->n_ifindex);
-	diff |= NEIGH_DIFF(FAMILY,	a->n_family != b->n_family);
-	diff |= NEIGH_DIFF(TYPE,	a->n_type != b->n_type);
-	diff |= NEIGH_DIFF(LLADDR,	nl_addr_cmp(a->n_lladdr, b->n_lladdr));
-	diff |= NEIGH_DIFF(DST,		nl_addr_cmp(a->n_dst, b->n_dst));
-	diff |= NEIGH_DIFF(MASTER,	a->n_master != b->n_master);
-	diff |= NEIGH_DIFF(VLAN,	a->n_vlan != b->n_vlan);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(NEIGH_ATTR_IFINDEX, a->n_ifindex != b->n_ifindex);
+	diff |= _DIFF(NEIGH_ATTR_FAMILY, a->n_family != b->n_family);
+	diff |= _DIFF(NEIGH_ATTR_TYPE, a->n_type != b->n_type);
+	diff |= _DIFF(NEIGH_ATTR_LLADDR, nl_addr_cmp(a->n_lladdr, b->n_lladdr));
+	diff |= _DIFF(NEIGH_ATTR_DST, nl_addr_cmp(a->n_dst, b->n_dst));
+	diff |= _DIFF(NEIGH_ATTR_MASTER, a->n_master != b->n_master);
+	diff |= _DIFF(NEIGH_ATTR_VLAN, a->n_vlan != b->n_vlan);
 
 	if (flags & LOOSE_COMPARISON) {
-		diff |= NEIGH_DIFF(STATE,
-				  (a->n_state ^ b->n_state) & b->n_state_mask);
-		diff |= NEIGH_DIFF(FLAGS,
-				  (a->n_flags ^ b->n_flags) & b->n_flag_mask);
+		diff |= _DIFF(NEIGH_ATTR_STATE,
+			      (a->n_state ^ b->n_state) & b->n_state_mask);
+		diff |= _DIFF(NEIGH_ATTR_FLAGS,
+			      (a->n_flags ^ b->n_flags) & b->n_flag_mask);
 	} else {
-		diff |= NEIGH_DIFF(STATE, a->n_state != b->n_state);
-		diff |= NEIGH_DIFF(FLAGS, a->n_flags != b->n_flags);
+		diff |= _DIFF(NEIGH_ATTR_STATE, a->n_state != b->n_state);
+		diff |= _DIFF(NEIGH_ATTR_FLAGS, a->n_flags != b->n_flags);
 	}
-
-#undef NEIGH_DIFF
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/neightbl.c b/lib/route/neightbl.c
index c4244fc6..8245326d 100644
--- a/lib/route/neightbl.c
+++ b/lib/route/neightbl.c
@@ -56,16 +56,18 @@ static uint64_t neightbl_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_neightbl *b = (struct rtnl_neightbl *)_b;
 	uint64_t diff = 0;
 
-#define NT_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NEIGHTBL_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= NT_DIFF(FAMILY, a->nt_family != b->nt_family);
-	diff |= NT_DIFF(NAME, strcmp(a->nt_name, b->nt_name));
-	diff |= NT_DIFF(THRESH1, a->nt_gc_thresh1 != b->nt_gc_thresh1);
-	diff |= NT_DIFF(THRESH2, a->nt_gc_thresh2 != b->nt_gc_thresh2);
-	diff |= NT_DIFF(THRESH3, a->nt_gc_thresh3 != b->nt_gc_thresh3);
-	diff |= NT_DIFF(GC_INTERVAL, a->nt_gc_interval != b->nt_gc_interval);
-
-#undef NT_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(NEIGHTBL_ATTR_FAMILY, a->nt_family != b->nt_family);
+	diff |= _DIFF(NEIGHTBL_ATTR_NAME, strcmp(a->nt_name, b->nt_name));
+	diff |= _DIFF(NEIGHTBL_ATTR_THRESH1,
+		      a->nt_gc_thresh1 != b->nt_gc_thresh1);
+	diff |= _DIFF(NEIGHTBL_ATTR_THRESH2,
+		      a->nt_gc_thresh2 != b->nt_gc_thresh2);
+	diff |= _DIFF(NEIGHTBL_ATTR_THRESH3,
+		      a->nt_gc_thresh3 != b->nt_gc_thresh3);
+	diff |= _DIFF(NEIGHTBL_ATTR_GC_INTERVAL,
+		      a->nt_gc_interval != b->nt_gc_interval);
+#undef _DIFF
 
 	if (!(a->ce_mask & NEIGHTBL_ATTR_PARMS) &&
 	    !(b->ce_mask & NEIGHTBL_ATTR_PARMS))
diff --git a/lib/route/netconf.c b/lib/route/netconf.c
index 50c91bfe..21c083f4 100644
--- a/lib/route/netconf.c
+++ b/lib/route/netconf.c
@@ -289,19 +289,19 @@ static uint64_t netconf_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_netconf *b = (struct rtnl_netconf *) _b;
 	uint64_t diff = 0;
 
-#define NETCONF_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NETCONF_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= NETCONF_DIFF(FAMILY,	a->family != b->family);
-	diff |= NETCONF_DIFF(IFINDEX,	a->ifindex != b->ifindex);
-	diff |= NETCONF_DIFF(RP_FILTER,	a->rp_filter != b->rp_filter);
-	diff |= NETCONF_DIFF(FWDING,	a->forwarding != b->forwarding);
-	diff |= NETCONF_DIFF(MC_FWDING,	a->mc_forwarding != b->mc_forwarding);
-	diff |= NETCONF_DIFF(PROXY_NEIGH, a->proxy_neigh != b->proxy_neigh);
-	diff |= NETCONF_DIFF(IGNORE_RT_LINKDWN,
-			a->ignore_routes_linkdown != b->ignore_routes_linkdown);
-	diff |= NETCONF_DIFF(INPUT,	a->input != b->input);
-
-#undef NETCONF_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(NETCONF_ATTR_FAMILY, a->family != b->family);
+	diff |= _DIFF(NETCONF_ATTR_IFINDEX, a->ifindex != b->ifindex);
+	diff |= _DIFF(NETCONF_ATTR_RP_FILTER, a->rp_filter != b->rp_filter);
+	diff |= _DIFF(NETCONF_ATTR_FWDING, a->forwarding != b->forwarding);
+	diff |= _DIFF(NETCONF_ATTR_MC_FWDING,
+		      a->mc_forwarding != b->mc_forwarding);
+	diff |= _DIFF(NETCONF_ATTR_PROXY_NEIGH,
+		      a->proxy_neigh != b->proxy_neigh);
+	diff |= _DIFF(NETCONF_ATTR_IGNORE_RT_LINKDWN,
+		      a->ignore_routes_linkdown != b->ignore_routes_linkdown);
+	diff |= _DIFF(NETCONF_ATTR_INPUT, a->input != b->input);
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/nexthop.c b/lib/route/nexthop.c
index 68351371..37f2f4d8 100644
--- a/lib/route/nexthop.c
+++ b/lib/route/nexthop.c
@@ -108,29 +108,26 @@ void rtnl_route_nh_free(struct rtnl_nexthop *nh)
 int rtnl_route_nh_compare(struct rtnl_nexthop *a, struct rtnl_nexthop *b,
 			  uint32_t attrs, int loose)
 {
-	int diff = 0;
-
-#define NH_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NH_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= NH_DIFF(IFINDEX,	a->rtnh_ifindex != b->rtnh_ifindex);
-	diff |= NH_DIFF(WEIGHT,		a->rtnh_weight != b->rtnh_weight);
-	diff |= NH_DIFF(REALMS,		a->rtnh_realms != b->rtnh_realms);
-	diff |= NH_DIFF(GATEWAY,	nl_addr_cmp(a->rtnh_gateway,
-						    b->rtnh_gateway));
-	diff |= NH_DIFF(NEWDST,		nl_addr_cmp(a->rtnh_newdst,
-						    b->rtnh_newdst));
-	diff |= NH_DIFF(VIA,		nl_addr_cmp(a->rtnh_via,
-						    b->rtnh_via));
-	diff |= NH_DIFF(ENCAP,		nh_encap_compare(a->rtnh_encap,
-							 b->rtnh_encap));
+	uint32_t diff = 0;
+
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(NH_ATTR_IFINDEX, a->rtnh_ifindex != b->rtnh_ifindex);
+	diff |= _DIFF(NH_ATTR_WEIGHT, a->rtnh_weight != b->rtnh_weight);
+	diff |= _DIFF(NH_ATTR_REALMS, a->rtnh_realms != b->rtnh_realms);
+	diff |= _DIFF(NH_ATTR_GATEWAY,
+		      nl_addr_cmp(a->rtnh_gateway, b->rtnh_gateway));
+	diff |= _DIFF(NH_ATTR_NEWDST,
+		      nl_addr_cmp(a->rtnh_newdst, b->rtnh_newdst));
+	diff |= _DIFF(NH_ATTR_VIA, nl_addr_cmp(a->rtnh_via, b->rtnh_via));
+	diff |= _DIFF(NH_ATTR_ENCAP,
+		      nh_encap_compare(a->rtnh_encap, b->rtnh_encap));
 
 	if (loose)
-		diff |= NH_DIFF(FLAGS,
-			  (a->rtnh_flags ^ b->rtnh_flags) & b->rtnh_flag_mask);
+		diff |= _DIFF(NH_ATTR_FLAGS, (a->rtnh_flags ^ b->rtnh_flags) &
+						     b->rtnh_flag_mask);
 	else
-		diff |= NH_DIFF(FLAGS, a->rtnh_flags != b->rtnh_flags);
-	
-#undef NH_DIFF
+		diff |= _DIFF(NH_ATTR_FLAGS, a->rtnh_flags != b->rtnh_flags);
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/route_obj.c b/lib/route/route_obj.c
index cd61fd59..df0a03f7 100644
--- a/lib/route/route_obj.c
+++ b/lib/route/route_obj.c
@@ -369,22 +369,21 @@ static uint64_t route_compare(struct nl_object *_a, struct nl_object *_b,
 	int i, found;
 	uint64_t diff = 0;
 
-#define ROUTE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ROUTE_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= ROUTE_DIFF(FAMILY,	a->rt_family != b->rt_family);
-	diff |= ROUTE_DIFF(TOS,		a->rt_tos != b->rt_tos);
-	diff |= ROUTE_DIFF(TABLE,	a->rt_table != b->rt_table);
-	diff |= ROUTE_DIFF(PROTOCOL,	a->rt_protocol != b->rt_protocol);
-	diff |= ROUTE_DIFF(SCOPE,	a->rt_scope != b->rt_scope);
-	diff |= ROUTE_DIFF(TYPE,	a->rt_type != b->rt_type);
-	diff |= ROUTE_DIFF(PRIO,	a->rt_prio != b->rt_prio);
-	diff |= ROUTE_DIFF(DST,		nl_addr_cmp(a->rt_dst, b->rt_dst));
-	diff |= ROUTE_DIFF(SRC,		nl_addr_cmp(a->rt_src, b->rt_src));
-	diff |= ROUTE_DIFF(IIF,		a->rt_iif != b->rt_iif);
-	diff |= ROUTE_DIFF(PREF_SRC,	nl_addr_cmp(a->rt_pref_src,
-						    b->rt_pref_src));
-	diff |= ROUTE_DIFF(TTL_PROPAGATE,
-			   a->rt_ttl_propagate != b->rt_ttl_propagate);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(ROUTE_ATTR_FAMILY, a->rt_family != b->rt_family);
+	diff |= _DIFF(ROUTE_ATTR_TOS, a->rt_tos != b->rt_tos);
+	diff |= _DIFF(ROUTE_ATTR_TABLE, a->rt_table != b->rt_table);
+	diff |= _DIFF(ROUTE_ATTR_PROTOCOL, a->rt_protocol != b->rt_protocol);
+	diff |= _DIFF(ROUTE_ATTR_SCOPE, a->rt_scope != b->rt_scope);
+	diff |= _DIFF(ROUTE_ATTR_TYPE, a->rt_type != b->rt_type);
+	diff |= _DIFF(ROUTE_ATTR_PRIO, a->rt_prio != b->rt_prio);
+	diff |= _DIFF(ROUTE_ATTR_DST, nl_addr_cmp(a->rt_dst, b->rt_dst));
+	diff |= _DIFF(ROUTE_ATTR_SRC, nl_addr_cmp(a->rt_src, b->rt_src));
+	diff |= _DIFF(ROUTE_ATTR_IIF, a->rt_iif != b->rt_iif);
+	diff |= _DIFF(ROUTE_ATTR_PREF_SRC,
+		      nl_addr_cmp(a->rt_pref_src, b->rt_pref_src));
+	diff |= _DIFF(ROUTE_ATTR_TTL_PROPAGATE,
+		      a->rt_ttl_propagate != b->rt_ttl_propagate);
 
 	if (flags & LOOSE_COMPARISON) {
 		nl_list_for_each_entry(nh_b, &b->rt_nexthops, rtnh_list) {
@@ -406,10 +405,10 @@ static uint64_t route_compare(struct nl_object *_a, struct nl_object *_b,
 			if (a->rt_metrics_mask & (1 << i) &&
 			    (!(b->rt_metrics_mask & (1 << i)) ||
 			     a->rt_metrics[i] != b->rt_metrics[i]))
-				diff |= ROUTE_DIFF(METRICS, 1);
+				diff |= _DIFF(ROUTE_ATTR_METRICS, 1);
 		}
 
-		diff |= ROUTE_DIFF(FLAGS,
+		diff |= _DIFF(ROUTE_ATTR_FLAGS,
 			  (a->rt_flags ^ b->rt_flags) & b->rt_flag_mask);
 	} else {
 		if (a->rt_nr_nh != b->rt_nr_nh)
@@ -447,23 +446,22 @@ static uint64_t route_compare(struct nl_object *_a, struct nl_object *_b,
 		for (i = 0; i < RTAX_MAX - 1; i++) {
 			if ((a->rt_metrics_mask & (1 << i)) ^
 			    (b->rt_metrics_mask & (1 << i)))
-				diff |= ROUTE_DIFF(METRICS, 1);
+				diff |= _DIFF(ROUTE_ATTR_METRICS, 1);
 			else
-				diff |= ROUTE_DIFF(METRICS,
+				diff |= _DIFF(ROUTE_ATTR_METRICS,
 					a->rt_metrics[i] != b->rt_metrics[i]);
 		}
 
-		diff |= ROUTE_DIFF(FLAGS, a->rt_flags != b->rt_flags);
+		diff |= _DIFF(ROUTE_ATTR_FLAGS, a->rt_flags != b->rt_flags);
 	}
 
 out:
 	return diff;
 
 nh_mismatch:
-	diff |= ROUTE_DIFF(MULTIPATH, 1);
+	diff |= _DIFF(ROUTE_ATTR_MULTIPATH, 1);
 	goto out;
-
-#undef ROUTE_DIFF
+#undef _DIFF
 }
 
 static int route_update(struct nl_object *old_obj, struct nl_object *new_obj)
diff --git a/lib/route/rule.c b/lib/route/rule.c
index 0c3dc058..cd617889 100644
--- a/lib/route/rule.c
+++ b/lib/route/rule.c
@@ -320,23 +320,21 @@ static uint64_t rule_compare(struct nl_object *_a, struct nl_object *_b,
 	struct rtnl_rule *b = (struct rtnl_rule *) _b;
 	uint64_t diff = 0;
 
-#define RULE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, RULE_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= RULE_DIFF(FAMILY,	a->r_family != b->r_family);
-	diff |= RULE_DIFF(TABLE,	a->r_table != b->r_table);
-	diff |= RULE_DIFF(ACTION,	a->r_action != b->r_action);
-	diff |= RULE_DIFF(IIFNAME,	strcmp(a->r_iifname, b->r_iifname));
-	diff |= RULE_DIFF(OIFNAME,	strcmp(a->r_oifname, b->r_oifname));
-	diff |= RULE_DIFF(PRIO,		a->r_prio != b->r_prio);
-	diff |= RULE_DIFF(MARK,		a->r_mark != b->r_mark);
-	diff |= RULE_DIFF(MASK,		a->r_mask != b->r_mask);
-	diff |= RULE_DIFF(GOTO,		a->r_goto != b->r_goto);
-	diff |= RULE_DIFF(SRC,		nl_addr_cmp(a->r_src, b->r_src));
-	diff |= RULE_DIFF(DST,		nl_addr_cmp(a->r_dst, b->r_dst));
-	diff |= RULE_DIFF(DSFIELD,	a->r_dsfield != b->r_dsfield);
-	diff |= RULE_DIFF(FLOW,		a->r_flow != b->r_flow);
-	
-#undef RULE_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(RULE_ATTR_FAMILY, a->r_family != b->r_family);
+	diff |= _DIFF(RULE_ATTR_TABLE, a->r_table != b->r_table);
+	diff |= _DIFF(RULE_ATTR_ACTION, a->r_action != b->r_action);
+	diff |= _DIFF(RULE_ATTR_IIFNAME, strcmp(a->r_iifname, b->r_iifname));
+	diff |= _DIFF(RULE_ATTR_OIFNAME, strcmp(a->r_oifname, b->r_oifname));
+	diff |= _DIFF(RULE_ATTR_PRIO, a->r_prio != b->r_prio);
+	diff |= _DIFF(RULE_ATTR_MARK, a->r_mark != b->r_mark);
+	diff |= _DIFF(RULE_ATTR_MASK, a->r_mask != b->r_mask);
+	diff |= _DIFF(RULE_ATTR_GOTO, a->r_goto != b->r_goto);
+	diff |= _DIFF(RULE_ATTR_SRC, nl_addr_cmp(a->r_src, b->r_src));
+	diff |= _DIFF(RULE_ATTR_DST, nl_addr_cmp(a->r_dst, b->r_dst));
+	diff |= _DIFF(RULE_ATTR_DSFIELD, a->r_dsfield != b->r_dsfield);
+	diff |= _DIFF(RULE_ATTR_FLOW, a->r_flow != b->r_flow);
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/route/tc.c b/lib/route/tc.c
index a06a4789..5bf5f72d 100644
--- a/lib/route/tc.c
+++ b/lib/route/tc.c
@@ -971,14 +971,12 @@ uint64_t rtnl_tc_compare(struct nl_object *aobj, struct nl_object *bobj,
 	struct rtnl_tc *b = TC_CAST(bobj);
 	uint64_t diff = 0;
 
-#define TC_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, TCA_ATTR_##ATTR, a, b, EXPR)
-
-	diff |= TC_DIFF(HANDLE,		a->tc_handle != b->tc_handle);
-	diff |= TC_DIFF(PARENT,		a->tc_parent != b->tc_parent);
-	diff |= TC_DIFF(IFINDEX,	a->tc_ifindex != b->tc_ifindex);
-	diff |= TC_DIFF(KIND,		strcmp(a->tc_kind, b->tc_kind));
-
-#undef TC_DIFF
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(TCA_ATTR_HANDLE, a->tc_handle != b->tc_handle);
+	diff |= _DIFF(TCA_ATTR_PARENT, a->tc_parent != b->tc_parent);
+	diff |= _DIFF(TCA_ATTR_IFINDEX, a->tc_ifindex != b->tc_ifindex);
+	diff |= _DIFF(TCA_ATTR_KIND, strcmp(a->tc_kind, b->tc_kind));
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/xfrm/ae.c b/lib/xfrm/ae.c
index 3af872f3..b5b819b5 100644
--- a/lib/xfrm/ae.c
+++ b/lib/xfrm/ae.c
@@ -197,16 +197,20 @@ static uint64_t xfrm_ae_compare(struct nl_object *_a, struct nl_object *_b,
 	uint64_t diff = 0;
 	int found = 0;
 
-#define XFRM_AE_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, XFRM_AE_ATTR_##ATTR, a, b, EXPR)
-	diff |= XFRM_AE_DIFF(DADDR,	nl_addr_cmp(a->sa_id.daddr, b->sa_id.daddr));
-	diff |= XFRM_AE_DIFF(SPI,	a->sa_id.spi != b->sa_id.spi);
-	diff |= XFRM_AE_DIFF(PROTO,	a->sa_id.proto != b->sa_id.proto);
-	diff |= XFRM_AE_DIFF(SADDR,	nl_addr_cmp(a->saddr, b->saddr));
-	diff |= XFRM_AE_DIFF(FLAGS, a->flags != b->flags);
-	diff |= XFRM_AE_DIFF(REQID, a->reqid != b->reqid);
-	diff |= XFRM_AE_DIFF(MARK, (a->mark.v & a->mark.m) != (b->mark.v & b->mark.m));
-	diff |= XFRM_AE_DIFF(REPLAY_MAXAGE, a->replay_maxage != b->replay_maxage);
-	diff |= XFRM_AE_DIFF(REPLAY_MAXDIFF, a->replay_maxdiff != b->replay_maxdiff);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(XFRM_AE_ATTR_DADDR,
+		      nl_addr_cmp(a->sa_id.daddr, b->sa_id.daddr));
+	diff |= _DIFF(XFRM_AE_ATTR_SPI, a->sa_id.spi != b->sa_id.spi);
+	diff |= _DIFF(XFRM_AE_ATTR_PROTO, a->sa_id.proto != b->sa_id.proto);
+	diff |= _DIFF(XFRM_AE_ATTR_SADDR, nl_addr_cmp(a->saddr, b->saddr));
+	diff |= _DIFF(XFRM_AE_ATTR_FLAGS, a->flags != b->flags);
+	diff |= _DIFF(XFRM_AE_ATTR_REQID, a->reqid != b->reqid);
+	diff |= _DIFF(XFRM_AE_ATTR_MARK,
+		      (a->mark.v & a->mark.m) != (b->mark.v & b->mark.m));
+	diff |= _DIFF(XFRM_AE_ATTR_REPLAY_MAXAGE,
+		      a->replay_maxage != b->replay_maxage);
+	diff |= _DIFF(XFRM_AE_ATTR_REPLAY_MAXDIFF,
+		      a->replay_maxdiff != b->replay_maxdiff);
 
 	/* Compare replay states */
 	found = AVAILABLE_MISMATCH (a, b, XFRM_AE_ATTR_REPLAY_STATE);
@@ -237,7 +241,7 @@ static uint64_t xfrm_ae_compare(struct nl_object *_a, struct nl_object *_b,
 			}
 		}
 	}
-#undef XFRM_AE_DIFF
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/xfrm/sa.c b/lib/xfrm/sa.c
index a8bbced3..f170460c 100644
--- a/lib/xfrm/sa.c
+++ b/lib/xfrm/sa.c
@@ -236,51 +236,62 @@ static uint64_t xfrm_sa_compare(struct nl_object *_a, struct nl_object *_b,
 	uint64_t diff = 0;
 	int found = 0;
 
-#define XFRM_SA_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, XFRM_SA_ATTR_##ATTR, a, b, EXPR)
-	diff |= XFRM_SA_DIFF(SEL,	xfrmnl_sel_cmp(a->sel, b->sel));
-	diff |= XFRM_SA_DIFF(DADDR,	nl_addr_cmp(a->id.daddr, b->id.daddr));
-	diff |= XFRM_SA_DIFF(SPI,	a->id.spi != b->id.spi);
-	diff |= XFRM_SA_DIFF(PROTO,	a->id.proto != b->id.proto);
-	diff |= XFRM_SA_DIFF(SADDR,	nl_addr_cmp(a->saddr, b->saddr));
-	diff |= XFRM_SA_DIFF(LTIME_CFG,	xfrmnl_ltime_cfg_cmp(a->lft, b->lft));
-	diff |= XFRM_SA_DIFF(REQID,	a->reqid != b->reqid);
-	diff |= XFRM_SA_DIFF(FAMILY,a->family != b->family);
-	diff |= XFRM_SA_DIFF(MODE,a->mode != b->mode);
-	diff |= XFRM_SA_DIFF(REPLAY_WIN,a->replay_window != b->replay_window);
-	diff |= XFRM_SA_DIFF(FLAGS,a->flags != b->flags);
-	diff |= XFRM_SA_DIFF(ALG_AEAD,(strcmp(a->aead->alg_name, b->aead->alg_name) ||
-	                              (a->aead->alg_key_len != b->aead->alg_key_len) ||
-	                              (a->aead->alg_icv_len != b->aead->alg_icv_len) ||
-	                              memcmp(a->aead->alg_key, b->aead->alg_key,
-	                              ((a->aead->alg_key_len + 7)/8))));
-	diff |= XFRM_SA_DIFF(ALG_AUTH,(strcmp(a->auth->alg_name, b->auth->alg_name) ||
-	                              (a->auth->alg_key_len != b->auth->alg_key_len) ||
-	                              (a->auth->alg_trunc_len != b->auth->alg_trunc_len) ||
-	                              memcmp(a->auth->alg_key, b->auth->alg_key,
-	                              ((a->auth->alg_key_len + 7)/8))));
-	diff |= XFRM_SA_DIFF(ALG_CRYPT,(strcmp(a->crypt->alg_name, b->crypt->alg_name) ||
-	                              (a->crypt->alg_key_len != b->crypt->alg_key_len) ||
-	                              memcmp(a->crypt->alg_key, b->crypt->alg_key,
-	                              ((a->crypt->alg_key_len + 7)/8))));
-	diff |= XFRM_SA_DIFF(ALG_COMP,(strcmp(a->comp->alg_name, b->comp->alg_name) ||
-	                              (a->comp->alg_key_len != b->comp->alg_key_len) ||
-	                              memcmp(a->comp->alg_key, b->comp->alg_key,
-	                              ((a->comp->alg_key_len + 7)/8))));
-	diff |= XFRM_SA_DIFF(ENCAP,((a->encap->encap_type != b->encap->encap_type) ||
-	                            (a->encap->encap_sport != b->encap->encap_sport) ||
-	                            (a->encap->encap_dport != b->encap->encap_dport) ||
-	                            nl_addr_cmp(a->encap->encap_oa, b->encap->encap_oa)));
-	diff |= XFRM_SA_DIFF(TFCPAD,a->tfcpad != b->tfcpad);
-	diff |= XFRM_SA_DIFF(COADDR,nl_addr_cmp(a->coaddr, b->coaddr));
-	diff |= XFRM_SA_DIFF(MARK,(a->mark.m != b->mark.m) ||
-	                          (a->mark.v != b->mark.v));
-	diff |= XFRM_SA_DIFF(SECCTX,((a->sec_ctx->ctx_doi != b->sec_ctx->ctx_doi) ||
-	                            (a->sec_ctx->ctx_alg != b->sec_ctx->ctx_alg) ||
-	                            (a->sec_ctx->ctx_len != b->sec_ctx->ctx_len) ||
-	                            strcmp(a->sec_ctx->ctx, b->sec_ctx->ctx)));
-	diff |= XFRM_SA_DIFF(REPLAY_MAXAGE,a->replay_maxage != b->replay_maxage);
-	diff |= XFRM_SA_DIFF(REPLAY_MAXDIFF,a->replay_maxdiff != b->replay_maxdiff);
-	diff |= XFRM_SA_DIFF(EXPIRE,a->hard != b->hard);
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(XFRM_SA_ATTR_SEL, xfrmnl_sel_cmp(a->sel, b->sel));
+	diff |= _DIFF(XFRM_SA_ATTR_DADDR,
+		      nl_addr_cmp(a->id.daddr, b->id.daddr));
+	diff |= _DIFF(XFRM_SA_ATTR_SPI, a->id.spi != b->id.spi);
+	diff |= _DIFF(XFRM_SA_ATTR_PROTO, a->id.proto != b->id.proto);
+	diff |= _DIFF(XFRM_SA_ATTR_SADDR, nl_addr_cmp(a->saddr, b->saddr));
+	diff |= _DIFF(XFRM_SA_ATTR_LTIME_CFG,
+		      xfrmnl_ltime_cfg_cmp(a->lft, b->lft));
+	diff |= _DIFF(XFRM_SA_ATTR_REQID, a->reqid != b->reqid);
+	diff |= _DIFF(XFRM_SA_ATTR_FAMILY, a->family != b->family);
+	diff |= _DIFF(XFRM_SA_ATTR_MODE, a->mode != b->mode);
+	diff |= _DIFF(XFRM_SA_ATTR_REPLAY_WIN,
+		      a->replay_window != b->replay_window);
+	diff |= _DIFF(XFRM_SA_ATTR_FLAGS, a->flags != b->flags);
+	diff |= _DIFF(XFRM_SA_ATTR_ALG_AEAD,
+		      (strcmp(a->aead->alg_name, b->aead->alg_name) ||
+		       (a->aead->alg_key_len != b->aead->alg_key_len) ||
+		       (a->aead->alg_icv_len != b->aead->alg_icv_len) ||
+		       memcmp(a->aead->alg_key, b->aead->alg_key,
+			      ((a->aead->alg_key_len + 7) / 8))));
+	diff |= _DIFF(XFRM_SA_ATTR_ALG_AUTH,
+		      (strcmp(a->auth->alg_name, b->auth->alg_name) ||
+		       (a->auth->alg_key_len != b->auth->alg_key_len) ||
+		       (a->auth->alg_trunc_len != b->auth->alg_trunc_len) ||
+		       memcmp(a->auth->alg_key, b->auth->alg_key,
+			      ((a->auth->alg_key_len + 7) / 8))));
+	diff |= _DIFF(XFRM_SA_ATTR_ALG_CRYPT,
+		      (strcmp(a->crypt->alg_name, b->crypt->alg_name) ||
+		       (a->crypt->alg_key_len != b->crypt->alg_key_len) ||
+		       memcmp(a->crypt->alg_key, b->crypt->alg_key,
+			      ((a->crypt->alg_key_len + 7) / 8))));
+	diff |= _DIFF(XFRM_SA_ATTR_ALG_COMP,
+		      (strcmp(a->comp->alg_name, b->comp->alg_name) ||
+		       (a->comp->alg_key_len != b->comp->alg_key_len) ||
+		       memcmp(a->comp->alg_key, b->comp->alg_key,
+			      ((a->comp->alg_key_len + 7) / 8))));
+	diff |= _DIFF(XFRM_SA_ATTR_ENCAP,
+		      ((a->encap->encap_type != b->encap->encap_type) ||
+		       (a->encap->encap_sport != b->encap->encap_sport) ||
+		       (a->encap->encap_dport != b->encap->encap_dport) ||
+		       nl_addr_cmp(a->encap->encap_oa, b->encap->encap_oa)));
+	diff |= _DIFF(XFRM_SA_ATTR_TFCPAD, a->tfcpad != b->tfcpad);
+	diff |= _DIFF(XFRM_SA_ATTR_COADDR, nl_addr_cmp(a->coaddr, b->coaddr));
+	diff |= _DIFF(XFRM_SA_ATTR_MARK,
+		      (a->mark.m != b->mark.m) || (a->mark.v != b->mark.v));
+	diff |= _DIFF(XFRM_SA_ATTR_SECCTX,
+		      ((a->sec_ctx->ctx_doi != b->sec_ctx->ctx_doi) ||
+		       (a->sec_ctx->ctx_alg != b->sec_ctx->ctx_alg) ||
+		       (a->sec_ctx->ctx_len != b->sec_ctx->ctx_len) ||
+		       strcmp(a->sec_ctx->ctx, b->sec_ctx->ctx)));
+	diff |= _DIFF(XFRM_SA_ATTR_REPLAY_MAXAGE,
+		      a->replay_maxage != b->replay_maxage);
+	diff |= _DIFF(XFRM_SA_ATTR_REPLAY_MAXDIFF,
+		      a->replay_maxdiff != b->replay_maxdiff);
+	diff |= _DIFF(XFRM_SA_ATTR_EXPIRE, a->hard != b->hard);
 
 	/* Compare replay states */
 	found = AVAILABLE_MISMATCH (a, b, XFRM_SA_ATTR_REPLAY_STATE);
@@ -312,7 +323,7 @@ static uint64_t xfrm_sa_compare(struct nl_object *_a, struct nl_object *_b,
 			}
 		}
 	}
-#undef XFRM_SA_DIFF
+#undef _DIFF
 
 	return diff;
 }
diff --git a/lib/xfrm/sp.c b/lib/xfrm/sp.c
index df9e2fbe..1fa02219 100644
--- a/lib/xfrm/sp.c
+++ b/lib/xfrm/sp.c
@@ -151,31 +151,33 @@ static uint64_t xfrm_sp_compare(struct nl_object *_a, struct nl_object *_b,
 	struct xfrmnl_user_tmpl *tmpl_a, *tmpl_b;
 	uint64_t diff = 0;
 
-#define XFRM_SP_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, XFRM_SP_ATTR_##ATTR, a, b, EXPR)
-	diff |= XFRM_SP_DIFF(SEL,	xfrmnl_sel_cmp(a->sel, b->sel));
-	diff |= XFRM_SP_DIFF(LTIME_CFG,	xfrmnl_ltime_cfg_cmp(a->lft, b->lft));
-	diff |= XFRM_SP_DIFF(PRIO,	a->priority != b->priority);
-	diff |= XFRM_SP_DIFF(INDEX,	a->index != b->index);
-	diff |= XFRM_SP_DIFF(DIR,	a->dir != b->dir);
-	diff |= XFRM_SP_DIFF(ACTION,	a->action != b->action);
-	diff |= XFRM_SP_DIFF(FLAGS,	a->flags != b->flags);
-	diff |= XFRM_SP_DIFF(SHARE,	a->share != b->share);
-	diff |= XFRM_SP_DIFF(SECCTX,((a->sec_ctx->len != b->sec_ctx->len) ||
-	                            (a->sec_ctx->exttype != b->sec_ctx->exttype) ||
-	                            (a->sec_ctx->ctx_alg != b->sec_ctx->ctx_alg) ||
-	                            (a->sec_ctx->ctx_doi != b->sec_ctx->ctx_doi) ||
-	                            (a->sec_ctx->ctx_len != b->sec_ctx->ctx_len) ||
-	                            strcmp(a->sec_ctx->ctx, b->sec_ctx->ctx)));
-	diff |= XFRM_SP_DIFF(POLTYPE,(a->uptype.type != b->uptype.type));
-	diff |= XFRM_SP_DIFF(TMPL,(a->nr_user_tmpl != b->nr_user_tmpl));
-	diff |= XFRM_SP_DIFF(MARK,(a->mark.m != b->mark.m) ||
-	                          (a->mark.v != b->mark.v));
+#define _DIFF(ATTR, EXPR) ATTR_DIFF(attrs, ATTR, a, b, EXPR)
+	diff |= _DIFF(XFRM_SP_ATTR_SEL, xfrmnl_sel_cmp(a->sel, b->sel));
+	diff |= _DIFF(XFRM_SP_ATTR_LTIME_CFG,
+		      xfrmnl_ltime_cfg_cmp(a->lft, b->lft));
+	diff |= _DIFF(XFRM_SP_ATTR_PRIO, a->priority != b->priority);
+	diff |= _DIFF(XFRM_SP_ATTR_INDEX, a->index != b->index);
+	diff |= _DIFF(XFRM_SP_ATTR_DIR, a->dir != b->dir);
+	diff |= _DIFF(XFRM_SP_ATTR_ACTION, a->action != b->action);
+	diff |= _DIFF(XFRM_SP_ATTR_FLAGS, a->flags != b->flags);
+	diff |= _DIFF(XFRM_SP_ATTR_SHARE, a->share != b->share);
+	diff |= _DIFF(XFRM_SP_ATTR_SECCTX,
+		      ((a->sec_ctx->len != b->sec_ctx->len) ||
+		       (a->sec_ctx->exttype != b->sec_ctx->exttype) ||
+		       (a->sec_ctx->ctx_alg != b->sec_ctx->ctx_alg) ||
+		       (a->sec_ctx->ctx_doi != b->sec_ctx->ctx_doi) ||
+		       (a->sec_ctx->ctx_len != b->sec_ctx->ctx_len) ||
+		       strcmp(a->sec_ctx->ctx, b->sec_ctx->ctx)));
+	diff |= _DIFF(XFRM_SP_ATTR_POLTYPE, (a->uptype.type != b->uptype.type));
+	diff |= _DIFF(XFRM_SP_ATTR_TMPL, (a->nr_user_tmpl != b->nr_user_tmpl));
+	diff |= _DIFF(XFRM_SP_ATTR_MARK,
+		      (a->mark.m != b->mark.m) || (a->mark.v != b->mark.v));
 
 	/* Compare the templates */
 	nl_list_for_each_entry(tmpl_b, &b->usertmpl_list, utmpl_list)
 	nl_list_for_each_entry(tmpl_a, &a->usertmpl_list, utmpl_list)
 	diff |= xfrmnl_user_tmpl_cmp (tmpl_a, tmpl_b);
-#undef XFRM_SP_DIFF
+#undef _DIFF
 
 	return diff;
 }