diff --git a/legacy/eina/configure.ac b/legacy/eina/configure.ac
index ce8b184634..76cf1e18f3 100644
--- a/legacy/eina/configure.ac
+++ b/legacy/eina/configure.ac
@@ -62,6 +62,27 @@ if test "x${enable_magic_debug}" = "xyes" ; then
 fi
 AC_SUBST(EINA_MAGIC_DEBUG)
 
+# Safety checks (avoid crashes on wrong api usage)
+want_safety_checks="yes"
+AC_MSG_CHECKING(whether to do safety checking on api parameters)
+AC_ARG_ENABLE(safety-checks,
+  AC_HELP_STRING(
+    [--disable-safety-checks],
+    [disable safety checks for NULL pointers and like. [[default=enabled]]]
+  ),
+  [ want_safety_checks="$enableval" ]
+)
+AC_MSG_RESULT($want_safety_checks)
+
+AM_CONDITIONAL(SAFETY_CHECKS, test "x$want_safety_checks" = "xyes")
+if test "x$want_safety_checks" = "xyes"; then
+  AC_DEFINE(SAFETY_CHECKS, 1, [disable safety checks for NULL pointers and like.])
+  EINA_SAFETY_CHECKS=1
+else
+  EINA_SAFETY_CHECKS=0
+fi
+AC_SUBST(EINA_SAFETY_CHECKS)
+
 # Choose best memory pool
 AC_ARG_ENABLE([default-mempool],
    [AC_HELP_STRING([--enable-default-mempool], [Default memory allocator could be faster for some computer])],
diff --git a/legacy/eina/src/include/Makefile.am b/legacy/eina/src/include/Makefile.am
index 1fa8c9567b..bb4de5d414 100644
--- a/legacy/eina/src/include/Makefile.am
+++ b/legacy/eina/src/include/Makefile.am
@@ -1,6 +1,7 @@
 MAINTAINERCLEANFILES = Makefile.in
 
 EINAHEADERS = \
+eina_safety_checks.h \
 eina_error.h \
 eina_f16p16.h \
 eina_hash.h \
diff --git a/legacy/eina/src/include/eina_config.h.in b/legacy/eina/src/include/eina_config.h.in
index 35e8399509..d9bf7ffc11 100644
--- a/legacy/eina/src/include/eina_config.h.in
+++ b/legacy/eina/src/include/eina_config.h.in
@@ -29,4 +29,9 @@
 #define EINA_DEFAULT_MEMPOOL
 #endif
 
+#undef EINA_SAFETY_CHECKS
+#if @EINA_SAFETY_CHECKS@
+#define EINA_SAFETY_CHECKS
+#endif
+
 #endif /* EINA_CONFIG_H_ */
diff --git a/legacy/eina/src/include/eina_hash.h b/legacy/eina/src/include/eina_hash.h
index 473ef9bad8..5f498f3b71 100644
--- a/legacy/eina/src/include/eina_hash.h
+++ b/legacy/eina/src/include/eina_hash.h
@@ -115,14 +115,14 @@ EAPI void        eina_hash_foreach(const Eina_Hash *hash,
 
 /* Paul Hsieh (http://www.azillionmonkeys.com/qed/hash.html) hash function
    used by WebCore (http://webkit.org/blog/8/hashtables-part-2/) */
-EAPI int eina_hash_superfast(const char *key, int len);
+EAPI int eina_hash_superfast(const char *key, int len) EINA_ARG_NONNULL(1);
 
 /* Hash function first reported by dan bernstein many years ago in comp.lang.c */
-static inline int eina_hash_djb2(const char *key, int len);
+static inline int eina_hash_djb2(const char *key, int len) EINA_ARG_NONNULL(1);
 
 /* Hash function from http://www.concentric.net/~Ttwang/tech/inthash.htm */
-static inline int eina_hash_int32(unsigned int *pkey, int len);
-static inline int eina_hash_int64(unsigned long int *pkey, int len);
+static inline int eina_hash_int32(unsigned int *pkey, int len) EINA_ARG_NONNULL(1);
+static inline int eina_hash_int64(unsigned long int *pkey, int len) EINA_ARG_NONNULL(1);
 
 #include "eina_inline_hash.x"
 
diff --git a/legacy/eina/src/include/eina_inlist.h b/legacy/eina/src/include/eina_inlist.h
index 03b77dad8d..eb20f9620b 100644
--- a/legacy/eina/src/include/eina_inlist.h
+++ b/legacy/eina/src/include/eina_inlist.h
@@ -41,10 +41,10 @@ struct _Eina_Inlist
 
 EAPI Eina_Inlist * eina_inlist_append(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
 EAPI Eina_Inlist * eina_inlist_prepend(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_Inlist * eina_inlist_append_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_Inlist * eina_inlist_prepend_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_Inlist * eina_inlist_append_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_Inlist * eina_inlist_prepend_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
 EAPI Eina_Inlist * eina_inlist_remove(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_Inlist * eina_inlist_find(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_Inlist * eina_inlist_find(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
 EAPI Eina_Inlist * eina_inlist_promote(Eina_Inlist *list, Eina_Inlist *item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
 EAPI Eina_Inlist * eina_inlist_demote(Eina_Inlist *list, Eina_Inlist *item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
 
diff --git a/legacy/eina/src/include/eina_list.h b/legacy/eina/src/include/eina_list.h
index 7e75fd776a..020d57b165 100644
--- a/legacy/eina/src/include/eina_list.h
+++ b/legacy/eina/src/include/eina_list.h
@@ -81,22 +81,22 @@ EAPI int eina_list_shutdown(void);
 
 EAPI Eina_List *eina_list_append (Eina_List *list, const void *data) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
 EAPI Eina_List *eina_list_prepend (Eina_List *list, const void *data) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_append_relative (Eina_List *list, const void *data, const void *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_append_relative_list (Eina_List *list, const void *data, Eina_List *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_prepend_relative (Eina_List *list, const void *data, const void *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_prepend_relative_list (Eina_List *list, const void *data, Eina_List *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_remove (Eina_List *list, const void *data) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_remove_list (Eina_List *list, Eina_List *remove_list) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_promote_list (Eina_List *list, Eina_List *move_list) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI void *eina_list_data_find(const Eina_List *list, const void *data) EINA_PURE EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_data_find_list (const Eina_List *list, const void *data) EINA_PURE EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_free (Eina_List *list) EINA_ARG_NONNULL(1);
-EAPI void *eina_list_nth(const Eina_List *list, unsigned int n) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_nth_list (const Eina_List *list, unsigned int n) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_reverse (Eina_List *list) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_sort (Eina_List *list, unsigned int size, Eina_Compare_Cb func) EINA_ARG_NONNULL(1, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_merge (Eina_List *left, Eina_List *right) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_List *eina_list_sorted_merge(Eina_List *left, Eina_List *right, Eina_Compare_Cb func) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_append_relative (Eina_List *list, const void *data, const void *relative) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_append_relative_list (Eina_List *list, const void *data, Eina_List *relative) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_prepend_relative (Eina_List *list, const void *data, const void *relative) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_prepend_relative_list (Eina_List *list, const void *data, Eina_List *relative) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_remove (Eina_List *list, const void *data) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_remove_list (Eina_List *list, Eina_List *remove_list) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_promote_list (Eina_List *list, Eina_List *move_list) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI void *eina_list_data_find(const Eina_List *list, const void *data) EINA_PURE EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_data_find_list (const Eina_List *list, const void *data) EINA_PURE EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_free (Eina_List *list);
+EAPI void *eina_list_nth(const Eina_List *list, unsigned int n) EINA_PURE EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_nth_list (const Eina_List *list, unsigned int n) EINA_PURE EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_reverse (Eina_List *list) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_sort (Eina_List *list, unsigned int size, Eina_Compare_Cb func) EINA_ARG_NONNULL(3) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_merge (Eina_List *left, Eina_List *right) EINA_WARN_UNUSED_RESULT;
+EAPI Eina_List *eina_list_sorted_merge(Eina_List *left, Eina_List *right, Eina_Compare_Cb func) EINA_ARG_NONNULL(3) EINA_WARN_UNUSED_RESULT;
 
 
 static inline Eina_List *eina_list_last (const Eina_List *list) EINA_PURE EINA_WARN_UNUSED_RESULT;
diff --git a/legacy/eina/src/include/eina_rbtree.h b/legacy/eina/src/include/eina_rbtree.h
index 75f5ca50d5..88eac6dc0a 100644
--- a/legacy/eina/src/include/eina_rbtree.h
+++ b/legacy/eina/src/include/eina_rbtree.h
@@ -56,10 +56,10 @@ typedef void (*Eina_Rbtree_Free_Cb)(Eina_Rbtree *node, void *data);
 #define EINA_RBTREE_FREE_CB(Function) ((Eina_Rbtree_Free_Cb) Function)
 
 EAPI Eina_Rbtree *eina_rbtree_inline_insert(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data) EINA_ARG_NONNULL(2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI Eina_Rbtree *eina_rbtree_inline_remove(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
-EAPI void eina_rbtree_delete(Eina_Rbtree *root, Eina_Rbtree_Free_Cb func, void *data) EINA_ARG_NONNULL(1, 2);
+EAPI Eina_Rbtree *eina_rbtree_inline_remove(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data) EINA_ARG_NONNULL(2, 3) EINA_WARN_UNUSED_RESULT;
+EAPI void eina_rbtree_delete(Eina_Rbtree *root, Eina_Rbtree_Free_Cb func, void *data) EINA_ARG_NONNULL(2);
 
-static inline Eina_Rbtree *eina_rbtree_inline_lookup(const Eina_Rbtree *root, const void *key, int length, Eina_Rbtree_Cmp_Key_Cb cmp, const void *data) EINA_PURE EINA_ARG_NONNULL(1, 2, 4) EINA_WARN_UNUSED_RESULT;
+static inline Eina_Rbtree *eina_rbtree_inline_lookup(const Eina_Rbtree *root, const void *key, int length, Eina_Rbtree_Cmp_Key_Cb cmp, const void *data) EINA_PURE EINA_ARG_NONNULL(2, 4) EINA_WARN_UNUSED_RESULT;
 
 EAPI Eina_Iterator *eina_rbtree_iterator_prefix(const Eina_Rbtree *root) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
 EAPI Eina_Iterator *eina_rbtree_iterator_infix(const Eina_Rbtree *root) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
diff --git a/legacy/eina/src/include/eina_safety_checks.h b/legacy/eina/src/include/eina_safety_checks.h
new file mode 100644
index 0000000000..620eb20930
--- /dev/null
+++ b/legacy/eina/src/include/eina_safety_checks.h
@@ -0,0 +1,119 @@
+/* EINA - EFL data type library
+ * Copyright (C) 2008 Gustavo Sverzut Barbieri
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library;
+ * if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef EINA_SAFETY_CHECKS_H_
+#define EINA_SAFETY_CHECKS_H_
+#ifdef EINA_SAFETY_CHECKS
+
+#include "eina_error.h"
+
+#define EINA_SAFETY_ON_NULL_RETURN(exp)					\
+  do									\
+    {									\
+       if (EINA_UNLIKELY((exp) == NULL))				\
+	 {								\
+	    EINA_ERROR_PERR("%s", "safety check failed: " #exp " == NULL\n"); \
+	    return;							\
+	 }								\
+    }									\
+  while (0)
+
+#define EINA_SAFETY_ON_NULL_RETURN_VAL(exp, val)			\
+  do									\
+    {									\
+       if (EINA_UNLIKELY((exp) == NULL))				\
+	 {								\
+	    EINA_ERROR_PERR("%s", "safety check failed: " #exp " == NULL\n"); \
+	    return (val);						\
+	 }								\
+    }									\
+  while (0)
+
+#define EINA_SAFETY_ON_TRUE_RETURN(exp)					\
+  do									\
+    {									\
+       if (EINA_UNLIKELY(exp))						\
+	 {								\
+	    EINA_ERROR_PERR("%s", "safety check failed: " #exp " is true\n"); \
+	    return;							\
+	 }								\
+    }									\
+  while (0)
+
+#define EINA_SAFETY_ON_TRUE_RETURN_VAL(exp, val)			\
+  do									\
+    {									\
+       if (EINA_UNLIKELY(exp))						\
+	 {								\
+	    EINA_ERROR_PERR("%s", "safety check failed: " #exp " is true\n"); \
+	    return val;							\
+	 }								\
+    }									\
+  while (0)
+
+#define EINA_SAFETY_ON_FALSE_RETURN(exp)				\
+  do									\
+    {									\
+       if (EINA_UNLIKELY(!(exp)))					\
+	 {								\
+	    EINA_ERROR_PERR("%s", "safety check failed: " #exp " is false\n"); \
+	    return;							\
+	 }								\
+    }									\
+  while (0)
+
+#define EINA_SAFETY_ON_FALSE_RETURN_VAL(exp, val)			\
+  do									\
+    {									\
+       if (EINA_UNLIKELY(!(exp)))					\
+	 {								\
+	    EINA_ERROR_PERR("%s", "safety check failed: " #exp " is false\n"); \
+	    return val;							\
+	 }								\
+    }									\
+  while (0)
+
+#ifdef EINA_ARG_NONNULL
+/* make EINA_ARG_NONNULL void so GCC does not optimize safety checks */
+#undef EINA_ARG_NONNULL
+#define EINA_ARG_NONNULL(idx, ...)
+#endif
+
+
+#else /* no safety checks */
+
+#define EINA_SAFETY_ON_NULL_RETURN(exp)					\
+  do { (void)((exp) == NULL) } while (0)
+
+#define EINA_SAFETY_ON_NULL_RETURN_VAL(exp, val)			\
+  do { if (0 && (exp) == NULL) (void)val; } while (0)
+
+#define EINA_SAFETY_ON_TRUE_RETURN(exp)					\
+  do { (void)(exp) } while (0)
+
+#define EINA_SAFETY_ON_TRUE_RETURN_VAL(exp, val)			\
+  do { if (0 && (exp)) (void)val; } while (0)
+
+#define EINA_SAFETY_ON_FALSE_RETURN(exp)				\
+  do { (void)((!exp)) } while (0)
+
+#define EINA_SAFETY_ON_FALSE_RETURN_VAL(exp, val)			\
+  do { if (0 && !(exp)) (void)val; } while (0)
+
+#endif /* safety checks macros */
+#endif /* EINA_SAFETY_CHECKS_H_ */
diff --git a/legacy/eina/src/include/eina_types.h b/legacy/eina/src/include/eina_types.h
index 253d03edde..400a869999 100644
--- a/legacy/eina/src/include/eina_types.h
+++ b/legacy/eina/src/include/eina_types.h
@@ -69,6 +69,12 @@
 #ifdef EINA_CONST
 # undef EINA_CONST
 #endif
+#ifdef EINA_UNLIKELY
+# undef EINA_UNLIKELY
+#endif
+#ifdef EINA_LIKELY
+# undef EINA_LIKELY
+#endif
 
 #ifdef HAVE___ATTRIBUTE__
 # ifdef __GNUC__
@@ -78,7 +84,7 @@
 #   define EINA_WARN_UNUSED_RESULT
 #  endif
 
-#  if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
+#  if (!defined(EINA_SAFETY_CHECKS)) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3))
 #   define EINA_ARG_NONNULL(idx, ...) __attribute__ ((nonnull(idx, ## __VA_ARGS__)))
 #  else
 #   define EINA_ARG_NONNULL(idx, ...)
@@ -97,11 +103,15 @@
 #   define EINA_SCANF(fmt, arg)  __attribute__((format (scanf, fmt, arg)))
 #   define EINA_FORMAT(fmt) __attribute__((format_arg(fmt)))
 #   define EINA_CONST __attribute__((const))
+#   define EINA_UNLIKELY(exp) __builtin_expect((exp), 0)
+#   define EINA_LIKELY(exp) __builtin_expect((exp), 1)
 #  else
 #   define EINA_PRINTF(fmt, arg)
 #   define EINA_SCANF(fmt, arg)
 #   define EINA_FORMAT(fmt)
 #   define EINA_CONST
+#   define EINA_UNLIKELY(exp)
+#   define EINA_LIKELY(exp)
 #  endif
 # else /* no __GNUC__ */
 #  define EINA_WARN_UNUSED_RESULT
@@ -112,6 +122,8 @@
 #  define EINA_SCANF(fmt, arg)
 #  define EINA_FORMAT(fmt)
 #  define EINA_CONST
+#  define EINA_UNLIKELY(exp)
+#  define EINA_LIKELY(exp)
 # endif
 #else /* no HAVE___ATTRIBUTE__ */
 # define EINA_WARN_UNUSED_RESULT
@@ -122,6 +134,8 @@
 # define EINA_SCANF(fmt, arg)
 # define EINA_FORMAT(fmt)
 # define EINA_CONST
+# define EINA_UNLIKELY(exp)
+# define EINA_LIKELY(exp)
 #endif
 
 
diff --git a/legacy/eina/src/lib/eina_accessor.c b/legacy/eina/src/lib/eina_accessor.c
index 16b3e89034..520ec092bd 100644
--- a/legacy/eina/src/lib/eina_accessor.c
+++ b/legacy/eina/src/lib/eina_accessor.c
@@ -28,6 +28,7 @@
 #include "eina_private.h"
 
 #include "eina_accessor.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -92,7 +93,9 @@ EAPI void
 eina_accessor_free(Eina_Accessor *accessor)
 {
    EINA_MAGIC_CHECK_ACCESSOR(accessor);
-   if (accessor) accessor->free(accessor);
+   EINA_SAFETY_ON_NULL_RETURN(accessor);
+   EINA_SAFETY_ON_NULL_RETURN(accessor->free);
+   accessor->free(accessor);
 }
 
 /**
@@ -108,7 +111,8 @@ EAPI void *
 eina_accessor_container_get(Eina_Accessor *accessor)
 {
    EINA_MAGIC_CHECK_ACCESSOR(accessor);
-   if (!accessor) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(accessor, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(accessor->get_container, NULL);
    return accessor->get_container(accessor);
 }
 
@@ -129,7 +133,9 @@ EAPI Eina_Bool
 eina_accessor_data_get(Eina_Accessor *accessor, unsigned int position, void **data)
 {
    EINA_MAGIC_CHECK_ACCESSOR(accessor);
-   if (!accessor) return EINA_FALSE;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(accessor, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(accessor->get_at, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
    return accessor->get_at(accessor, position, data);
 }
 
@@ -156,16 +162,18 @@ eina_accessor_over(Eina_Accessor *accessor,
 		   unsigned int end,
 		   const void *fdata)
 {
-   void *container;
+   const void *container;
    void *data;
    unsigned int i;
 
    EINA_MAGIC_CHECK_ACCESSOR(accessor);
+   EINA_SAFETY_ON_NULL_RETURN(accessor);
+   EINA_SAFETY_ON_NULL_RETURN(accessor->get_container);
+   EINA_SAFETY_ON_NULL_RETURN(accessor->get_at);
+   EINA_SAFETY_ON_NULL_RETURN(cb);
+   EINA_SAFETY_ON_FALSE_RETURN(start < end);
 
-   if (!accessor) return ;
-   if (!(start < end)) return ;
-
-   container = eina_accessor_container_get(accessor);
+   container = accessor->get_container(accessor);
    for (i = start; i < end && accessor->get_at(accessor, i, &data) == EINA_TRUE; ++i)
       if (cb(container, data, (void*) fdata) != EINA_TRUE) return ;
 }
diff --git a/legacy/eina/src/lib/eina_array.c b/legacy/eina/src/lib/eina_array.c
index 5932ea936f..207eaeb147 100644
--- a/legacy/eina/src/lib/eina_array.c
+++ b/legacy/eina/src/lib/eina_array.c
@@ -39,6 +39,7 @@
 #include "eina_array.h"
 #include "eina_inline_array.x"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -148,6 +149,7 @@ eina_array_grow(Eina_Array *array)
    unsigned int total;
 
    EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE);
 
    total = array->total + array->step;
    eina_error_set(0);
@@ -318,6 +320,7 @@ eina_array_free(Eina_Array *array)
    eina_array_flush(array);
 
    EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN(array);
    MAGIC_FREE(array);
 }
 
@@ -334,6 +337,7 @@ eina_array_free(Eina_Array *array)
 EAPI void
 eina_array_step_set(Eina_Array *array, unsigned int step)
 {
+  EINA_SAFETY_ON_NULL_RETURN(array);
   array->data = NULL;
   array->total = 0;
   array->count = 0;
@@ -354,6 +358,7 @@ EAPI void
 eina_array_clean(Eina_Array *array)
 {
    EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN(array);
    array->count = 0;
 }
 
@@ -371,10 +376,12 @@ EAPI void
 eina_array_flush(Eina_Array *array)
 {
    EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN(array);
    array->count = 0;
    array->total = 0;
 
-   if (array->data) free(array->data);
+   if (!array->data) return;
+   free(array->data);
    array->data = NULL;
 }
 
@@ -405,6 +412,9 @@ eina_array_remove(Eina_Array *array, Eina_Bool (*keep)(void *data, void *gdata),
    unsigned int i;
 
    EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(keep, EINA_FALSE);
+
    if (array->total == 0) return EINA_TRUE;
 
    for (i = 0; i < array->count; ++i)
@@ -492,7 +502,9 @@ eina_array_iterator_new(const Eina_Array *array)
 {
    Eina_Iterator_Array *it;
 
-   if (!array) return NULL;
+   EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(array, NULL);
+
    if (eina_array_count_get(array) <= 0) return NULL;
 
    eina_error_set(0);
@@ -531,7 +543,8 @@ eina_array_accessor_new(const Eina_Array *array)
 {
    Eina_Accessor_Array *it;
 
-   if (!array) return NULL;
+   EINA_MAGIC_CHECK_ARRAY(array);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(array, NULL);
 
    eina_error_set(0);
    it = calloc(1, sizeof (Eina_Accessor_Array));
diff --git a/legacy/eina/src/lib/eina_convert.c b/legacy/eina/src/lib/eina_convert.c
index 04d0bf79db..7b13ba7c7e 100644
--- a/legacy/eina/src/lib/eina_convert.c
+++ b/legacy/eina/src/lib/eina_convert.c
@@ -25,6 +25,7 @@
 #include <string.h>
 
 #include "eina_convert.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -277,6 +278,8 @@ eina_convert_itoa(int n, char *s)
    int i = 0;
    int r = 0;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(s, 0);
+
    if (n < 0)
      {
 	n = -n;
@@ -316,6 +319,8 @@ eina_convert_xtoa(unsigned int n, char *s)
 {
    int i;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(s, 0);
+
    i = 0;
    do {
       s[i++] = look_up_table[n & 0xF];
@@ -379,6 +384,10 @@ eina_convert_atod(const char *src, int length, long long *m, long *e)
    int         nbr_decimals = 0;
    int         sign = 1;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(src, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(m, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(e, EINA_FALSE);
+
    if (length <= 0) goto on_length_error;
 
    /* Compute the mantisse. */
@@ -487,6 +496,8 @@ eina_convert_dtoa(double d, char *des)
    int p;
    int i;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(des, EINA_FALSE);
+
    if (d < 0.0)
      {
         *(des++) = '-';
diff --git a/legacy/eina/src/lib/eina_counter.c b/legacy/eina/src/lib/eina_counter.c
index 8ddc0313af..992e8185b0 100644
--- a/legacy/eina/src/lib/eina_counter.c
+++ b/legacy/eina/src/lib/eina_counter.c
@@ -36,6 +36,7 @@
 #include "eina_inlist.h"
 #include "eina_error.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -299,7 +300,7 @@ eina_counter_add(const char *name)
    Eina_Counter *counter;
    int length;
 
-   if (!name) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
 
    length = strlen(name) + 1;
 
@@ -330,7 +331,7 @@ eina_counter_add(const char *name)
 EAPI void
 eina_counter_delete(Eina_Counter *counter)
 {
-   if (!counter) return;
+   EINA_SAFETY_ON_NULL_RETURN(counter);
 
    while (counter->clocks)
      {
@@ -365,7 +366,7 @@ eina_counter_start(Eina_Counter *counter)
    Eina_Clock *clk;
    Eina_Nano_Time tp;
 
-   if (!counter) return;
+   EINA_SAFETY_ON_NULL_RETURN(counter);
    if (_eina_counter_time_get(&tp) != 0) return;
 
    eina_error_set(0);
@@ -400,7 +401,7 @@ eina_counter_stop(Eina_Counter *counter, int specimen)
    Eina_Clock *clk;
    Eina_Nano_Time tp;
 
-   if (!counter) return;
+   EINA_SAFETY_ON_NULL_RETURN(counter);
    if (_eina_counter_time_get(&tp) != 0) return;
 
    clk = (Eina_Clock *) counter->clocks;
@@ -436,7 +437,7 @@ eina_counter_dump(Eina_Counter *counter)
    char *result = NULL;
    int position = 0;
 
-   if (!counter) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(counter, NULL);
 
    result = _eina_counter_asiprintf(result, &position, "# specimen\texperiment time\tstarting time\tending time\n");
    if (!result) return NULL;
diff --git a/legacy/eina/src/lib/eina_error.c b/legacy/eina/src/lib/eina_error.c
index 3e9e881b53..1f0adec95f 100644
--- a/legacy/eina/src/lib/eina_error.c
+++ b/legacy/eina/src/lib/eina_error.c
@@ -361,6 +361,7 @@
 #include "eina_error.h"
 #include "eina_inlist.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /* TODO
  * + printing errors to stdout or stderr can be implemented
@@ -588,6 +589,8 @@ EAPI Eina_Error eina_error_msg_register(const char *msg)
 	Eina_Inlist *tmp;
 	int length;
 
+	EINA_SAFETY_ON_NULL_RETURN_VAL(msg, 0);
+
 	length = strlen(msg) + 1;
 
 	tmp = malloc(sizeof (Eina_Inlist) + length);
@@ -686,6 +689,10 @@ EAPI void eina_error_print(Eina_Error_Level level, const char *file,
 	if (level > _error_level)
 		return;
 
+	EINA_SAFETY_ON_NULL_RETURN(file);
+	EINA_SAFETY_ON_NULL_RETURN(fnc);
+	EINA_SAFETY_ON_NULL_RETURN(fmt);
+
 	va_start(args, fmt);
 	_print_cb(level, file, fnc, line, fmt, _print_cb_data, args);
 	va_end(args);
diff --git a/legacy/eina/src/lib/eina_file.c b/legacy/eina/src/lib/eina_file.c
index cd1f2e6ef7..131dd5da25 100644
--- a/legacy/eina/src/lib/eina_file.c
+++ b/legacy/eina/src/lib/eina_file.c
@@ -60,6 +60,7 @@ void *alloca (size_t);
 
 #include "eina_file.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                 Global                                     *
@@ -114,12 +115,14 @@ void *alloca (size_t);
 EAPI Eina_Bool
 eina_file_dir_list(const char *dir, Eina_Bool recursive, Eina_File_Dir_List_Cb cb, void *data)
 {
+        EINA_SAFETY_ON_NULL_RETURN_VAL(cb, EINA_FALSE);
+        EINA_SAFETY_ON_NULL_RETURN_VAL(dir, EINA_FALSE);
+        EINA_SAFETY_ON_TRUE_RETURN_VAL(dir[0] == '\0', EINA_FALSE);
+
 #ifndef _WIN32
 	struct dirent *de;
 	DIR *d;
 
-	if (!cb) return EINA_FALSE;
-
 	d = opendir(dir);
 	if (!d) return EINA_FALSE;
 
@@ -166,9 +169,6 @@ eina_file_dir_list(const char *dir, Eina_Bool recursive, Eina_File_Dir_List_Cb c
 	TCHAR          *tdir;
 	int             length_dir;
 
-	if (!cb) return EINA_FALSE;
-	if (!dir || (*dir == '\0')) return EINA_FALSE;
-
 	length_dir = strlen(dir);
 	new_dir = (char *)alloca(length_dir + 5);
 	if (!new_dir) return EINA_FALSE;
@@ -248,7 +248,7 @@ eina_file_split(char *path)
 	char *current;
 	int length;
 
-	if (!path) return NULL;
+	EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
 
 	ea = eina_array_new(16);
 
diff --git a/legacy/eina/src/lib/eina_hash.c b/legacy/eina/src/lib/eina_hash.c
index 7f6ce48bb1..1fe87438c4 100644
--- a/legacy/eina/src/lib/eina_hash.c
+++ b/legacy/eina/src/lib/eina_hash.c
@@ -29,6 +29,7 @@
 #include "eina_rbtree.h"
 #include "eina_error.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -190,7 +191,9 @@ eina_hash_add_alloc_by_hash(Eina_Hash *hash,
    int hash_num;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if ((!hash) || (!key) || (!data)) goto on_error;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
    error = EINA_ERROR_OUT_OF_MEMORY;
 
    /* Apply eina mask to hash. */
@@ -385,8 +388,9 @@ _eina_hash_del_by_key_hash(Eina_Hash *hash, const void *key, int key_length, int
    Eina_Hash_Tuple tuple;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return EINA_FALSE;
-   if (!key) return EINA_FALSE;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
+
    if (!hash->buckets) return EINA_FALSE;
 
    tuple.key = (void *) key;
@@ -676,6 +680,7 @@ eina_hash_shutdown(void)
      eina_error_shutdown();
    return --_eina_hash_init_count;
 }
+
 EAPI Eina_Hash *
 eina_hash_new(Eina_Key_Length key_length_cb,
 	      Eina_Key_Cmp key_cmp_cb,
@@ -687,8 +692,11 @@ eina_hash_new(Eina_Key_Length key_length_cb,
    Eina_Hash *new;
 
    eina_error_set(0);
-   if (!key_length_cb || !key_cmp_cb || !key_hash_cb) return NULL;
-   if (buckets_power_size < 3 || buckets_power_size > 16) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key_length_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key_cmp_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key_hash_cb, NULL);
+   EINA_SAFETY_ON_TRUE_RETURN_VAL(buckets_power_size < 3, NULL);
+   EINA_SAFETY_ON_TRUE_RETURN_VAL(buckets_power_size > 16, NULL);
 
    new = malloc(sizeof (Eina_Hash));
    if (!new) goto on_error;
@@ -789,7 +797,7 @@ EAPI int
 eina_hash_population(const Eina_Hash *hash)
 {
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return 0;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, 0);
    return hash->population;
 }
 
@@ -817,7 +825,7 @@ eina_hash_free(Eina_Hash *hash)
    int i;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return;
+   EINA_SAFETY_ON_NULL_RETURN(hash);
 
    if (hash->buckets)
      for (i = 0; i < hash->size; i++)
@@ -916,7 +924,11 @@ eina_hash_add(Eina_Hash *hash, const void *key, const void *data)
    int key_hash;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if ((!hash) || (!key) || (!data)) return EINA_FALSE;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_length_cb, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_hash_cb, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
 
    key_length = hash->key_length_cb(key);
    key_hash = hash->key_hash_cb(key, key_length);
@@ -951,7 +963,11 @@ eina_hash_direct_add(Eina_Hash *hash, const void *key, const void *data)
    int key_hash;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if ((!hash) || (!key) || (!data)) return EINA_FALSE;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_length_cb, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_hash_cb, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
 
    key_length = hash->key_length_cb(key);
    key_hash = hash->key_hash_cb(key, key_length);
@@ -976,6 +992,8 @@ eina_hash_direct_add(Eina_Hash *hash, const void *key, const void *data)
 EAPI Eina_Bool
 eina_hash_del_by_key_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash)
 {
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
    return _eina_hash_del_by_key_hash(hash, key, key_length, key_hash, NULL);
 }
 
@@ -996,6 +1014,8 @@ eina_hash_del_by_key_hash(Eina_Hash *hash, const void *key, int key_length, int
 EAPI Eina_Bool
 eina_hash_del_by_key(Eina_Hash *hash, const void *key)
 {
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, EINA_FALSE);
    return _eina_hash_del_by_key(hash, key, NULL);
 }
 
@@ -1019,8 +1039,8 @@ eina_hash_del_by_data(Eina_Hash *hash, const void *data)
    int key_hash;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return EINA_FALSE;
-   if (!data) return EINA_FALSE;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
 
    el = _eina_hash_find_by_data(hash, data, &key_hash, &eh);
    if (!el) return EINA_FALSE;
@@ -1051,6 +1071,8 @@ eina_hash_del_by_data(Eina_Hash *hash, const void *data)
 EAPI Eina_Bool
 eina_hash_del_by_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash, const void *data)
 {
+   EINA_MAGIC_CHECK_HASH(hash);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
    if (key) return _eina_hash_del_by_key_hash(hash, key, key_length, key_hash, data);
    else return eina_hash_del_by_data(hash, data);
 }
@@ -1077,6 +1099,8 @@ eina_hash_del_by_hash(Eina_Hash *hash, const void *key, int key_length, int key_
 EAPI Eina_Bool
 eina_hash_del(Eina_Hash *hash, const void *key, const void *data)
 {
+   EINA_MAGIC_CHECK_HASH(hash);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, EINA_FALSE);
    if (key) return _eina_hash_del_by_key(hash, key, data);
    else return eina_hash_del_by_data(hash, data);
 }
@@ -1097,8 +1121,9 @@ eina_hash_find_by_hash(const Eina_Hash *hash, const void *key, int key_length, i
    Eina_Hash_El *el;
    Eina_Hash_Tuple tuple;
 
-   if ((!hash) || (!key)) return NULL;
    EINA_MAGIC_CHECK_HASH(hash);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, NULL);
 
    tuple.key = key;
    tuple.key_length = key_length;
@@ -1122,8 +1147,11 @@ eina_hash_find(const Eina_Hash *hash, const void *key)
    int key_length;
    int hash_num;
 
-   if ((!hash) || (!key)) return NULL;
    EINA_MAGIC_CHECK_HASH(hash);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_length_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_hash_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, NULL);
 
    key_length = hash->key_length_cb(key);
    hash_num = hash->key_hash_cb(key, key_length);
@@ -1151,7 +1179,10 @@ eina_hash_modify_by_hash(Eina_Hash *hash, const void *key, int key_length, int k
    Eina_Hash_Tuple tuple;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, NULL);
+
    tuple.key = key;
    tuple.key_length = key_length;
    tuple.data = NULL;
@@ -1182,7 +1213,11 @@ eina_hash_modify(Eina_Hash *hash, const void *key, const void *data)
    int hash_num;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_length_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash->key_hash_cb, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(key, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, NULL);
 
    key_length = hash->key_length_cb(key);
    hash_num = hash->key_hash_cb(key, key_length);
@@ -1235,7 +1270,8 @@ eina_hash_foreach(const Eina_Hash *hash,
    Eina_Hash_Foreach_Data foreach;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return;
+   EINA_SAFETY_ON_NULL_RETURN(hash);
+   EINA_SAFETY_ON_NULL_RETURN(func);
 
    foreach.cb = func;
    foreach.fdata = fdata;
@@ -1253,8 +1289,7 @@ eina_hash_iterator_data_new(const Eina_Hash *hash)
    Eina_Iterator_Hash *it;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return NULL;
-   if (hash->population <= 0) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
 
    it = calloc(1, sizeof (Eina_Iterator_Hash));
    if (!it) return NULL;
@@ -1278,8 +1313,7 @@ eina_hash_iterator_key_new(const Eina_Hash *hash)
    Eina_Iterator_Hash *it;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return NULL;
-   if (hash->population <= 0) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
 
    it = calloc(1, sizeof (Eina_Iterator_Hash));
    if (!it) return NULL;
@@ -1303,8 +1337,7 @@ eina_hash_iterator_tuple_new(const Eina_Hash *hash)
    Eina_Iterator_Hash *it;
 
    EINA_MAGIC_CHECK_HASH(hash);
-   if (!hash) return NULL;
-   if (hash->population <= 0) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hash, NULL);
 
    it = calloc(1, sizeof (Eina_Iterator_Hash));
    if (!it) return NULL;
diff --git a/legacy/eina/src/lib/eina_inlist.c b/legacy/eina/src/lib/eina_inlist.c
index afe06352c1..463579a486 100644
--- a/legacy/eina/src/lib/eina_inlist.c
+++ b/legacy/eina/src/lib/eina_inlist.c
@@ -26,6 +26,7 @@
 #include "eina_inlist.h"
 #include "eina_error.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /* FIXME: TODO please, refactor this :) */
 
@@ -142,6 +143,8 @@ eina_inlist_append(Eina_Inlist *list, Eina_Inlist *new_l)
 {
    Eina_Inlist *l;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(new_l, list);
+
    new_l->next = NULL;
    if (!list) {
       new_l->prev = NULL;
@@ -165,6 +168,8 @@ eina_inlist_append(Eina_Inlist *list, Eina_Inlist *new_l)
 EAPI Eina_Inlist *
 eina_inlist_prepend(Eina_Inlist *list, Eina_Inlist *new_l)
 {
+   EINA_SAFETY_ON_NULL_RETURN_VAL(new_l, list);
+
    new_l->prev = NULL;
    if (!list) {
       new_l->next = NULL;
@@ -186,6 +191,8 @@ eina_inlist_append_relative(Eina_Inlist *list,
 			    Eina_Inlist *new_l,
 			    Eina_Inlist *relative)
 {
+   EINA_SAFETY_ON_NULL_RETURN_VAL(new_l, list);
+
    if (relative) {
       if (relative->next) {
 	 new_l->next = relative->next;
@@ -209,6 +216,8 @@ eina_inlist_prepend_relative(Eina_Inlist *list,
 			     Eina_Inlist *new_l,
 			     Eina_Inlist *relative)
 {
+   EINA_SAFETY_ON_NULL_RETURN_VAL(new_l, list);
+
    if (relative) {
       new_l->prev = relative->prev;
       new_l->next = relative;
@@ -239,8 +248,8 @@ eina_inlist_remove(Eina_Inlist *list, Eina_Inlist *item)
    Eina_Inlist *return_l;
 
    /* checkme */
-   if (!list) return list;
-   if (!item) return list;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(list, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(item, list);
 
    if (item->next)
      item->next->prev = item->prev;
@@ -266,8 +275,10 @@ eina_inlist_remove(Eina_Inlist *list, Eina_Inlist *item)
 EAPI Eina_Inlist *
 eina_inlist_promote(Eina_Inlist *list, Eina_Inlist *item)
 {
+   EINA_SAFETY_ON_NULL_RETURN_VAL(list, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(item, list);
+
    if (item == list) return list;
-   if (!item || !list) return list;
 
    if (item->next)
      item->next->prev = item->prev;
@@ -294,7 +305,9 @@ eina_inlist_demote(Eina_Inlist *list, Eina_Inlist *item)
 {
    Eina_Inlist *l;
 
-   if (!item || !list) return list;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(list, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(item, list);
+
    if (list->last == item) return list;
 
    if (!list->last)
@@ -339,8 +352,6 @@ eina_inlist_iterator_new(const Eina_Inlist *list)
 {
    Eina_Iterator_Inlist *it;
 
-   if (!list) return NULL;
-
    eina_error_set(0);
    it = calloc(1, sizeof (Eina_Iterator_Inlist));
    if (!it) {
@@ -365,8 +376,6 @@ eina_inlist_accessor_new(const Eina_Inlist *list)
 {
    Eina_Accessor_Inlist *it;
 
-   if (!list) return NULL;
-
    eina_error_set(0);
    it = calloc(1, sizeof (Eina_Accessor_Inlist));
    if (!it) {
diff --git a/legacy/eina/src/lib/eina_iterator.c b/legacy/eina/src/lib/eina_iterator.c
index 786a4c8785..b2f7383a66 100644
--- a/legacy/eina/src/lib/eina_iterator.c
+++ b/legacy/eina/src/lib/eina_iterator.c
@@ -28,6 +28,7 @@
 #include "eina_private.h"
 
 #include "eina_iterator.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -93,7 +94,9 @@ EAPI void
 eina_iterator_free(Eina_Iterator *iterator)
 {
    EINA_MAGIC_CHECK_ITERATOR(iterator);
-   if (iterator) iterator->free(iterator);
+   EINA_SAFETY_ON_NULL_RETURN(iterator);
+   EINA_SAFETY_ON_NULL_RETURN(iterator->free);
+   iterator->free(iterator);
 }
 
 /**
@@ -109,7 +112,8 @@ EAPI void *
 eina_iterator_container_get(Eina_Iterator *iterator)
 {
    EINA_MAGIC_CHECK_ITERATOR(iterator);
-   if (!iterator) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iterator, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iterator->get_container, NULL);
    return iterator->get_container(iterator);
 }
 
@@ -130,6 +134,9 @@ eina_iterator_next(Eina_Iterator *iterator, void **data)
 {
    if (!iterator) return EINA_FALSE;
    EINA_MAGIC_CHECK_ITERATOR(iterator);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iterator, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(iterator->next, EINA_FALSE);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
    return iterator->next(iterator, data);
 }
 
@@ -150,12 +157,14 @@ eina_iterator_foreach(Eina_Iterator *iterator,
 		      Eina_Each cb,
 		      const void *fdata)
 {
-   void *container;
+   const void *container;
    void *data;
 
-   if (!iterator) return ;
-
    EINA_MAGIC_CHECK_ITERATOR(iterator);
+   EINA_SAFETY_ON_NULL_RETURN(iterator);
+   EINA_SAFETY_ON_NULL_RETURN(iterator->get_container);
+   EINA_SAFETY_ON_NULL_RETURN(iterator->next);
+   EINA_SAFETY_ON_NULL_RETURN(cb);
 
    container = iterator->get_container(iterator);
    while (iterator->next(iterator, &data) == EINA_TRUE) {
diff --git a/legacy/eina/src/lib/eina_lalloc.c b/legacy/eina/src/lib/eina_lalloc.c
index 50f5699a21..3ca9cf4e04 100644
--- a/legacy/eina/src/lib/eina_lalloc.c
+++ b/legacy/eina/src/lib/eina_lalloc.c
@@ -24,6 +24,7 @@
 
 #include "eina_lalloc.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -65,6 +66,9 @@ EAPI Eina_Lalloc * eina_lalloc_new(void *data, Eina_Lalloc_Alloc alloc_cb, Eina_
 {
 	Eina_Lalloc *a;
 
+	EINA_SAFETY_ON_NULL_RETURN_VAL(alloc_cb, NULL);
+	EINA_SAFETY_ON_NULL_RETURN_VAL(free_cb, NULL);
+
 	a = calloc(1, sizeof(Eina_Lalloc));
 	a->data = data;
 	a->alloc_cb = alloc_cb;
@@ -79,12 +83,17 @@ EAPI Eina_Lalloc * eina_lalloc_new(void *data, Eina_Lalloc_Alloc alloc_cb, Eina_
 
 EAPI void eina_lalloc_delete(Eina_Lalloc *a)
 {
+	EINA_SAFETY_ON_NULL_RETURN(a);
+	EINA_SAFETY_ON_NULL_RETURN(a->free_cb);
 	a->free_cb(a->data);
 	free(a);
 }
 
 EAPI Eina_Bool eina_lalloc_element_add(Eina_Lalloc *a)
 {
+	EINA_SAFETY_ON_NULL_RETURN_VAL(a, EINA_FALSE);
+	EINA_SAFETY_ON_NULL_RETURN_VAL(a->alloc_cb, EINA_FALSE);
+
 	if (a->num_elements == a->num_allocated)
 	{
 		if (a->alloc_cb(a->data, (1 << a->acc)) == EINA_TRUE)
@@ -104,6 +113,9 @@ EAPI Eina_Bool eina_lalloc_elements_add(Eina_Lalloc *a, int num)
 {
 	int tmp;
 
+	EINA_SAFETY_ON_NULL_RETURN_VAL(a, EINA_FALSE);
+	EINA_SAFETY_ON_NULL_RETURN_VAL(a->alloc_cb, EINA_FALSE);
+
 	tmp = a->num_elements + num;
 	if (tmp > a->num_allocated)
 	{
diff --git a/legacy/eina/src/lib/eina_list.c b/legacy/eina/src/lib/eina_list.c
index d82afedc74..fec8b6f1b9 100644
--- a/legacy/eina/src/lib/eina_list.c
+++ b/legacy/eina/src/lib/eina_list.c
@@ -76,6 +76,8 @@
 #include "eina_list.h"
 #include "eina_mempool.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
+
 
 /*============================================================================*
  *                                  Local                                     *
@@ -498,7 +500,7 @@ eina_list_shutdown(void)
  * @param data The data to append.
  * @return A list pointer.
  *
- * This function appends @p data to @p list. If @p data is @c NULL, a
+ * This function appends @p data to @p list. If @p list is @c NULL, a
  * new list is returned. On success, a new list pointer that should be
  * used in place of the one given to this function is
  * returned. Otherwise, the old pointer is returned.
@@ -553,7 +555,7 @@ eina_list_append(Eina_List *list, const void *data)
  * @param data The data to prepend.
  * @return A list pointer.
  *
- * This function prepends @p data to @p list. If @p data is @c NULL, a
+ * This function prepends @p data to @p list. If @p list is @c NULL, a
  * new list is returned. On success, a new list pointer that should be
  * used in place of the one given to this function is
  * returned. Otherwise, the old pointer is returned.
@@ -1242,8 +1244,8 @@ eina_list_sort(Eina_List *list, unsigned int size, Eina_Compare_Cb func)
    Eina_List *unsort = NULL;
    Eina_List *stack[EINA_LIST_SORT_STACK_SIZE];
 
-   if (!list || !func) return NULL;
-
+   EINA_SAFETY_ON_NULL_RETURN_VAL(func, list);
+   if (!list) return NULL;
    EINA_MAGIC_CHECK_LIST(list);
 
    /* if the caller specified an invalid size, sort the whole list */
@@ -1376,9 +1378,10 @@ eina_list_sorted_merge(Eina_List *left, Eina_List *right, Eina_Compare_Cb func)
    Eina_List *ret;
    Eina_List *current;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(func, NULL);
+
    if (!left) return right;
    if (!right) return left;
-   if (!func) return NULL;
 
    if (func(left->data, right->data) < 0)
      {
@@ -1460,8 +1463,6 @@ eina_list_iterator_new(const Eina_List *list)
 {
    Eina_Iterator_List *it;
 
-   if (!list) return NULL;
-
    eina_error_set(0);
    it = calloc(1, sizeof (Eina_Iterator_List));
    if (!it) {
@@ -1499,8 +1500,6 @@ eina_list_accessor_new(const Eina_List *list)
 {
    Eina_Accessor_List *it;
 
-   if (!list) return NULL;
-
    eina_error_set(0);
    it = calloc(1, sizeof (Eina_Accessor_List));
    if (!it) {
diff --git a/legacy/eina/src/lib/eina_mempool.c b/legacy/eina/src/lib/eina_mempool.c
index a796d2d5be..3a0f2f209d 100644
--- a/legacy/eina/src/lib/eina_mempool.c
+++ b/legacy/eina/src/lib/eina_mempool.c
@@ -29,6 +29,7 @@
 #include "eina_hash.h"
 #include "eina_module.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -202,7 +203,7 @@ eina_mempool_new(const char *name, const char *context, const char *options, ...
 	Eina_Mempool *mp;
 	va_list args;
 
-	if (!name) return NULL;
+	EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
 
 	va_start(args, options);
 	mp = _new_from_buffer(name, context, options, args);
@@ -216,24 +217,22 @@ eina_mempool_new(const char *name, const char *context, const char *options, ...
  */
 EAPI void eina_mempool_delete(Eina_Mempool *mp)
 {
-	if (!mp) return ;
-
+        EINA_SAFETY_ON_NULL_RETURN(mp);
+	EINA_SAFETY_ON_NULL_RETURN(mp->backend.shutdown);
 	mp->backend.shutdown(mp->backend_data);
 	free(mp);
 }
 
 EAPI void eina_mempool_gc(Eina_Mempool *mp)
 {
-	assert(mp);
-	assert(mp->backend.garbage_collect);
-
+        EINA_SAFETY_ON_NULL_RETURN(mp);
+        EINA_SAFETY_ON_NULL_RETURN(mp->backend.garbage_collect);
 	mp->backend.garbage_collect(mp->backend_data);
 }
 
 EAPI void eina_mempool_statistics(Eina_Mempool *mp)
 {
-	assert(mp);
-	assert(mp->backend.statistics);
-
+        EINA_SAFETY_ON_NULL_RETURN(mp);
+        EINA_SAFETY_ON_NULL_RETURN(mp->backend.statistics);
 	mp->backend.statistics(mp->backend_data);
 }
diff --git a/legacy/eina/src/lib/eina_module.c b/legacy/eina/src/lib/eina_module.c
index cf35e83556..a8cce154dc 100644
--- a/legacy/eina/src/lib/eina_module.c
+++ b/legacy/eina/src/lib/eina_module.c
@@ -39,6 +39,7 @@
 #include "eina_module.h"
 #include "eina_file.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -177,6 +178,8 @@ EAPI Eina_Bool eina_module_load(Eina_Module *m)
 	void *dl_handle;
 	Eina_Module_Init *initcall;
 
+	EINA_SAFETY_ON_NULL_RETURN_VAL(m, EINA_FALSE);
+
 	if (m->handle) goto loaded;
 
 	eina_error_set(EINA_ERROR_WRONG_MODULE);
@@ -209,7 +212,7 @@ loaded:
 EAPI Eina_Bool eina_module_unload(Eina_Module *m)
 {
 	Eina_Module_Shutdown *shut;
-	if (!m)	return EINA_FALSE;
+	EINA_SAFETY_ON_NULL_RETURN_VAL(m, EINA_FALSE);
 
 	m->ref--;
 	if (!m->ref)
@@ -231,6 +234,7 @@ EAPI Eina_Module * eina_module_new(const char *file)
 {
 	Eina_Module *m;
 
+	EINA_SAFETY_ON_NULL_RETURN_VAL(file, NULL);
 	/* TODO check that the file exists */
 
 	m = malloc(sizeof(Eina_Module));
@@ -247,7 +251,7 @@ EAPI Eina_Module * eina_module_new(const char *file)
  */
 EAPI Eina_Bool eina_module_delete(Eina_Module *m)
 {
-	if (!m)	return EINA_FALSE;
+	EINA_SAFETY_ON_NULL_RETURN_VAL(m, EINA_FALSE);
 
 	if (m->handle)
 	{
@@ -264,9 +268,8 @@ EAPI Eina_Bool eina_module_delete(Eina_Module *m)
  */
 EAPI void * eina_module_symbol_get(Eina_Module *m, const char *symbol)
 {
-	if ((!m) || (!m->handle))
-		return NULL;
-
+	EINA_SAFETY_ON_NULL_RETURN_VAL(m, NULL);
+	EINA_SAFETY_ON_NULL_RETURN_VAL(m->handle, NULL);
 	return dlsym(m->handle, symbol);
 }
 /**
@@ -275,13 +278,14 @@ EAPI void * eina_module_symbol_get(Eina_Module *m, const char *symbol)
  */
 EAPI const char * eina_module_file_get(Eina_Module *m)
 {
-	if (!m) return NULL;
-
+	EINA_SAFETY_ON_NULL_RETURN_VAL(m, NULL);
 	return m->file;
 }
 
 EAPI char *eina_module_symbol_path_get(const void *symbol, const char *sub_dir)
 {
+        EINA_SAFETY_ON_NULL_RETURN_VAL(symbol, NULL);
+
 #ifdef HAVE_DLADDR
 	Dl_info eina_dl;
 
@@ -318,6 +322,8 @@ EAPI char *eina_module_environment_path_get(const char *env, const char *sub_dir
 {
 	const char *env_dir;
 
+	EINA_SAFETY_ON_NULL_RETURN_VAL(env, NULL);
+
 	env_dir = getenv(env);
 	if (env_dir)
 	{
@@ -358,8 +364,7 @@ EAPI Eina_Array * eina_module_list_get(Eina_Array *array, const char *path, unsi
 	Dir_List_Get_Cb_Data list_get_cb_data;
 	Dir_List_Cb_Data list_cb_data;
 
-	if (!path)
-		return array;
+	EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
 
 	list_get_cb_data.array = array ? array : eina_array_new(4);
 	list_get_cb_data.cb = cb;
@@ -382,6 +387,8 @@ EAPI void eina_module_list_load(Eina_Array *array)
 	Eina_Module *m;
 	unsigned int i;
 
+	EINA_SAFETY_ON_NULL_RETURN(array);
+
 	EINA_ARRAY_ITER_NEXT(array, i, m, iterator)
 		eina_module_load(m);
 }
@@ -395,6 +402,8 @@ EAPI void eina_module_list_unload(Eina_Array *array)
 	Eina_Module *m;
 	unsigned int i;
 
+	EINA_SAFETY_ON_NULL_RETURN(array);
+
 	EINA_ARRAY_ITER_NEXT(array, i, m, iterator)
 		eina_module_unload(m);
 }
@@ -408,6 +417,8 @@ EAPI void eina_module_list_delete(Eina_Array *array)
 	Eina_Module *m;
 	unsigned int i;
 
+	EINA_SAFETY_ON_NULL_RETURN(array);
+
 	EINA_ARRAY_ITER_NEXT(array, i, m, iterator)
 		eina_module_delete(m);
 }
diff --git a/legacy/eina/src/lib/eina_rbtree.c b/legacy/eina/src/lib/eina_rbtree.c
index d56bae363f..b245757a06 100644
--- a/legacy/eina/src/lib/eina_rbtree.c
+++ b/legacy/eina/src/lib/eina_rbtree.c
@@ -27,6 +27,7 @@
 #include "eina_rbtree.h"
 #include "eina_array.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -161,8 +162,6 @@ _eina_rbtree_iterator_build(const Eina_Rbtree *root, unsigned char mask)
    Eina_Iterator_Rbtree_List *first;
    Eina_Iterator_Rbtree *it;
 
-   if (!root) return NULL;
-
    it = calloc(1, sizeof (Eina_Iterator_Rbtree));
    if (!it) return NULL;
 
@@ -249,6 +248,9 @@ eina_rbtree_inline_insert(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_
    Eina_Rbtree *p, *q;  /* Iterator & parent */
    Eina_Rbtree_Direction dir, last;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(node, root);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cmp, root);
+
    if (!node) return root;
 
    _eina_rbtree_node_init(node);
@@ -328,6 +330,9 @@ eina_rbtree_inline_remove(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_
    Eina_Rbtree *f = NULL;
    Eina_Rbtree_Direction dir;
 
+   EINA_SAFETY_ON_NULL_RETURN_VAL(node, root);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cmp, root);
+
    if (!root || !node) return root;
 
    memset(&head, 0, sizeof(Eina_Rbtree));
@@ -455,6 +460,8 @@ eina_rbtree_delete(Eina_Rbtree *root, Eina_Rbtree_Free_Cb func, void *data)
 {
    if (!root) return ;
 
+   EINA_SAFETY_ON_NULL_RETURN(func);
+
    eina_rbtree_delete(root->son[0], func, data);
    eina_rbtree_delete(root->son[1], func, data);
    func(root, data);
diff --git a/legacy/eina/src/lib/eina_rectangle.c b/legacy/eina/src/lib/eina_rectangle.c
index 05a9dd794f..aaee6012c6 100644
--- a/legacy/eina/src/lib/eina_rectangle.c
+++ b/legacy/eina/src/lib/eina_rectangle.c
@@ -26,6 +26,7 @@
 #include "eina_magic.h"
 #include "eina_inlist.h"
 #include "eina_private.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *
@@ -223,7 +224,7 @@ eina_rectangle_pool_delete(Eina_Rectangle_Pool *pool)
 {
    Eina_Rectangle_Alloc *del;
 
-   if (!pool) return ;
+   EINA_SAFETY_ON_NULL_RETURN(pool);
    while (pool->head)
      {
 	del = (Eina_Rectangle_Alloc*) pool->head;
@@ -239,7 +240,7 @@ eina_rectangle_pool_delete(Eina_Rectangle_Pool *pool)
 EAPI int
 eina_rectangle_pool_count(Eina_Rectangle_Pool *pool)
 {
-   if (!pool) return 0;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(pool, 0);
    return pool->references;
 }
 
@@ -252,7 +253,8 @@ eina_rectangle_pool_request(Eina_Rectangle_Pool *pool, int w, int h)
    int x;
    int y;
 
-   if (!pool) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(pool, NULL);
+
    if (w > pool->w || h > pool->h) return NULL;
 
    test = _eina_rectangle_pool_find((Eina_Rectangle_Alloc*) pool->head, pool->w, pool->h, w, h, &x, &y);
@@ -279,6 +281,8 @@ eina_rectangle_pool_release(Eina_Rectangle *rect)
 {
    Eina_Rectangle_Alloc *era = ((Eina_Rectangle_Alloc *) rect) - 1;
 
+   EINA_SAFETY_ON_NULL_RETURN(rect);
+
    EINA_MAGIC_CHECK_RECTANGLE_ALLOC(era);
    EINA_MAGIC_CHECK_RECTANGLE_POOL(era->pool);
 
@@ -293,7 +297,7 @@ eina_rectangle_pool_get(Eina_Rectangle *rect)
 {
    Eina_Rectangle_Alloc *era = ((Eina_Rectangle_Alloc *) rect) - 1;
 
-   if (!rect) return NULL;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(rect, NULL);
 
    EINA_MAGIC_CHECK_RECTANGLE_ALLOC(era);
    EINA_MAGIC_CHECK_RECTANGLE_POOL(era->pool);
@@ -304,9 +308,8 @@ eina_rectangle_pool_get(Eina_Rectangle *rect)
 EAPI void
 eina_rectangle_pool_data_set(Eina_Rectangle_Pool *pool, const void *data)
 {
-   if (!pool) return ;
-
    EINA_MAGIC_CHECK_RECTANGLE_POOL(pool);
+   EINA_SAFETY_ON_NULL_RETURN(pool);
 
    pool->data = (void*) data;
 }
@@ -314,9 +317,8 @@ eina_rectangle_pool_data_set(Eina_Rectangle_Pool *pool, const void *data)
 EAPI void *
 eina_rectangle_pool_data_get(Eina_Rectangle_Pool *pool)
 {
-   if (!pool) return NULL;
-
    EINA_MAGIC_CHECK_RECTANGLE_POOL(pool);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(pool, NULL);
 
    return pool->data;
 }
@@ -327,6 +329,7 @@ eina_rectangle_pool_geometry_get(Eina_Rectangle_Pool *pool, int *w, int *h)
    if (!pool) return EINA_FALSE;
 
    EINA_MAGIC_CHECK_RECTANGLE_POOL(pool);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(pool, EINA_FALSE);
 
    if (w) *w = pool->w;
    if (h) *h = pool->h;
diff --git a/legacy/eina/src/lib/eina_stringshare.c b/legacy/eina/src/lib/eina_stringshare.c
index deefe0e839..e97cadf6d8 100644
--- a/legacy/eina/src/lib/eina_stringshare.c
+++ b/legacy/eina/src/lib/eina_stringshare.c
@@ -80,6 +80,7 @@
 #include "eina_error.h"
 #include "eina_private.h"
 #include "eina_magic.h"
+#include "eina_safety_checks.h"
 
 /*============================================================================*
  *                                  Local                                     *