diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt
index 8f5d76c..283c632 100644
--- a/gcc/c-family/c.opt
+++ b/gcc/c-family/c.opt
@@ -1043,6 +1043,9 @@ Instrument only functions marked with bnd_instrument attribute.
 static-libmpx
 Driver
 
+static-libmpxwrappers
+Driver
+
 fcilkplus
 C ObjC C++ ObjC++ LTO Report Var(flag_cilkplus) Init(0)
 Enable Cilk Plus
diff --git a/gcc/gcc.c b/gcc/gcc.c
index 75e5767..aa8c9a3 100644
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -828,9 +828,23 @@ proper position among the other output files.  */
 #endif
 #endif
 
+#ifndef LIBMPXWRAPPERS_SPEC
+#if defined(HAVE_LD_STATIC_DYNAMIC)
+#define LIBMPXWRAPPERS_SPEC "\
+%{mmpx:%{fcheck-pointer-bounds:%{!fno-chkp-use-wrappers:\
+    %{static:-lmpxwrappers}\
+    %{!static:%{static-libmpxwrappers:" LD_STATIC_OPTION " --whole-archive}\
+    -lmpxwrappers %{static-libmpxwrappers:--no-whole-archive "\
+    LD_DYNAMIC_OPTION "}}}}}"
+#else
+#define LIBMPXWRAPPERS_SPEC "\
+%{mmpx:%{fcheck-pointer-bounds:{!fno-chkp-use-wrappers:-lmpxwrappers}}}"
+#endif
+#endif
+
 #ifndef MPX_SPEC
 #define MPX_SPEC "\
-%{!nostdlib:%{!nodefaultlibs:" LIBMPX_SPEC "}}"
+%{!nostdlib:%{!nodefaultlibs:" LIBMPX_SPEC LIBMPXWRAPPERS_SPEC "}}"
 #endif
 
 /* -u* was put back because both BSD and SysV seem to support it.  */
diff --git a/libmpx/Makefile.am b/libmpx/Makefile.am
index 6cee4ac..bd0a8b6 100644
--- a/libmpx/Makefile.am
+++ b/libmpx/Makefile.am
@@ -2,6 +2,9 @@ ACLOCAL_AMFLAGS = -I .. -I ../config
 
 if LIBMPX_SUPPORTED
 SUBDIRS = mpxrt
+if MPX_AS_SUPPORTED
+SUBDIRS += mpxwrap
+endif
 nodist_toolexeclib_HEADERS = libmpx.spec
 endif
 
@@ -45,3 +48,5 @@ AM_MAKEFLAGS = \
 	"PICFLAG=$(PICFLAG)" \
 	"RANLIB=$(RANLIB)" \
 	"DESTDIR=$(DESTDIR)"
+
+MAKEOVERRIDES =
diff --git a/libmpx/configure.ac b/libmpx/configure.ac
index dbfad02..4669525 100644
--- a/libmpx/configure.ac
+++ b/libmpx/configure.ac
@@ -100,6 +100,18 @@ AC_CHECK_TOOL(AS, as)
 AC_CHECK_TOOL(AR, ar)
 AC_CHECK_TOOL(RANLIB, ranlib, :)
 
+# Check we may build wrappers library
+echo "test:  bndmov %bnd0, %bnd1" > conftest.s
+if AC_TRY_COMMAND([$AS -o conftest.o conftest.s 1>&AS_MESSAGE_LOG_FD])
+then
+    mpx_as=yes
+else
+    mpx_as=no
+    echo "configure: no MPX support fo as" >&AS_MESSAGE_LOG_FD
+fi
+rm -f conftest.o conftest.s
+AM_CONDITIONAL(MPX_AS_SUPPORTED, [test "x$mpx_as" = "xyes"])
+
 # Configure libtool
 AC_LIBTOOL_DLOPEN
 AM_PROG_LIBTOOL
@@ -117,7 +129,7 @@ fi
 
 AC_CONFIG_FILES([Makefile libmpx.spec])
 AC_CONFIG_HEADERS(config.h)
-AC_CONFIG_FILES(AC_FOREACH([DIR], [mpxrt], [DIR/Makefile]),
+AC_CONFIG_FILES(AC_FOREACH([DIR], [mpxrt mpxwrap], [DIR/Makefile ]),
   [cat > vpsed$$ << \_EOF
 s!`test -f '$<' || echo '$(srcdir)/'`!!
 _EOF
diff --git a/libmpx/mpxwrap/Makefile.am b/libmpx/mpxwrap/Makefile.am
new file mode 100644
index 0000000..c254d9b
--- /dev/null
+++ b/libmpx/mpxwrap/Makefile.am
@@ -0,0 +1,54 @@
+ALCLOCAL_AMFLAGS = -I .. -I ../config
+
+# May be used by toolexeclibdir.
+gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER)
+
+libmpxwrappers_la_CFLAGS = -fcheck-pointer-bounds -mmpx -fno-chkp-check-read \
+			   -fno-chkp-check-write -fno-chkp-use-wrappers
+libmpxwrappers_la_DEPENDENCIES = libmpxwrappers.map
+libmpxwrappers_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libmpxwrappers.map
+
+toolexeclib_LTLIBRARIES = libmpxwrappers.la
+
+libmpxwrappers_la_SOURCES = mpx_wrappers.c
+
+# Work around what appears to be a GNU make bug handling MAKEFLAGS
+# values defined in terms of make variables, as is the case for CC and
+# friends when we are called from the top level Makefile.
+AM_MAKEFLAGS = \
+       "AR_FLAGS=$(AR_FLAGS)" \
+       "CC_FOR_BUILD=$(CC_FOR_BUILD)" \
+       "CFLAGS=$(CFLAGS)" \
+       "CXXFLAGS=$(CXXFLAGS)" \
+       "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
+       "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
+       "INSTALL=$(INSTALL)" \
+       "INSTALL_DATA=$(INSTALL_DATA)" \
+       "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
+       "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
+       "JC1FLAGS=$(JC1FLAGS)" \
+       "LDFLAGS=$(LDFLAGS)" \
+       "LIBCFLAGS=$(LIBCFLAGS)" \
+       "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
+       "MAKE=$(MAKE)" \
+       "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
+       "PICFLAG=$(PICFLAG)" \
+       "PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \
+       "SHELL=$(SHELL)" \
+       "RUNTESTFLAGS=$(RUNTESTFLAGS)" \
+       "exec_prefix=$(exec_prefix)" \
+       "infodir=$(infodir)" \
+       "libdir=$(libdir)" \
+       "prefix=$(prefix)" \
+       "includedir=$(includedir)" \
+       "AR=$(AR)" \
+       "AS=$(AS)" \
+       "LD=$(LD)" \
+       "LIBCFLAGS=$(LIBCFLAGS)" \
+       "NM=$(NM)" \
+       "PICFLAG=$(PICFLAG)" \
+       "RANLIB=$(RANLIB)" \
+       "DESTDIR=$(DESTDIR)"
+
+MAKEOVERRIDES =
+
diff --git a/libmpx/mpxwrap/libmpxwrappers.map b/libmpx/mpxwrap/libmpxwrappers.map
new file mode 100644
index 0000000..c2912a7
--- /dev/null
+++ b/libmpx/mpxwrap/libmpxwrappers.map
@@ -0,0 +1,23 @@
+LIBMPXWRAPPERS_1.0
+{
+  global:
+	__mpx_wrapper_malloc;
+	__mpx_wrapper_mmap;
+	__mpx_wrapper_realloc;
+	__mpx_wrapper_calloc;
+	__mpx_wrapper_memset;
+	__mpx_wrapper_bzero;
+	__mpx_wrapper_memmove;
+	__mpx_wrapper_memcpy;
+	__mpx_wrapper_mempcpy;
+	__mpx_wrapper_strncat;
+	__mpx_wrapper_strcat;
+	__mpx_wrapper_stpcpy;
+	__mpx_wrapper_stpncpy;
+	__mpx_wrapper_strcpy;
+	__mpx_wrapper_strncpy;
+	__mpx_wrapper_strlen;
+
+  local:
+	*;
+};
diff --git a/libmpx/mpxwrap/libtool-version b/libmpx/mpxwrap/libtool-version
new file mode 100644
index 0000000..bfe84c8
--- /dev/null
+++ b/libmpx/mpxwrap/libtool-version
@@ -0,0 +1,6 @@
+# This file is used to maintain libtool version info for libmpxintr.  See
+# the libtool manual to understand the meaning of the fields.  This is
+# a separate file so that version updates don't involve re-running
+# automake.
+# CURRENT:REVISION:AGE
+1:0:0
diff --git a/libmpx/mpxwrap/mpx_wrappers.c b/libmpx/mpxwrap/mpx_wrappers.c
new file mode 100644
index 0000000..63cbb40
--- /dev/null
+++ b/libmpx/mpxwrap/mpx_wrappers.c
@@ -0,0 +1,263 @@
+/* MPX Wrappers Library
+   Copyright (C) 2014 Free Software Foundation, Inc.
+   Contributed by Ilya Enkovich (ilya.enkovich@intel.com)
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 3, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   Under Section 7 of GPL version 3, you are granted additional
+   permissions described in the GCC Runtime Library Exception, version
+   3.1, as published by the Free Software Foundation.
+
+   You should have received a copy of the GNU General Public License and
+   a copy of the GCC Runtime Library Exception along with this program;
+   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include "stdlib.h"
+#include "string.h"
+#include <sys/mman.h>
+
+void *
+__mpx_wrapper_malloc (size_t size)
+{
+  void *p = (void *)malloc (size);
+  if (!p) return __bnd_null_ptr_bounds (p);
+  return __bnd_set_ptr_bounds (p, size);
+}
+
+
+void *
+__mpx_wrapper_mmap (void *addr, size_t length, int prot, int flags,
+		    int fd, off_t offset)
+{
+  void *p = mmap (addr, length, prot, flags, fd, offset);
+  if (!p) return __bnd_null_ptr_bounds (p);
+  return __bnd_set_ptr_bounds (p, length);
+}
+
+void *
+__mpx_wrapper_realloc (void *ptr, size_t n)
+{
+  if (!ptr)
+    return __mpx_wrapper_malloc (n);
+
+  /* We don't kwnow how much data is copied by realloc
+     and therefore may check only lower bounds.  */
+  __bnd_chk_ptr_lbounds (ptr);
+  ptr = realloc (ptr, n);
+
+  if (!ptr)
+    return __bnd_null_ptr_bounds (ptr);
+
+  return __bnd_set_ptr_bounds (ptr, n);
+}
+
+void *
+__mpx_wrapper_calloc (size_t n_elements, size_t element_size)
+{
+  void *p = calloc (n_elements, element_size);
+  if (!p)
+    return __bnd_null_ptr_bounds (p);
+  return __bnd_set_ptr_bounds (p, n_elements * element_size);
+}
+
+void *
+__mpx_wrapper_memset (void *dstpp, int c, size_t len)
+{
+  if (len > 0)
+    {
+      __bnd_chk_ptr_bounds (dstpp, len);
+      memset (dstpp, c, len);
+    }
+  return dstpp;
+}
+
+void
+__mpx_wrapper_bzero (void *dst, size_t len)
+{
+  __mpx_wrapper_memset (dst, 0, len);
+}
+
+void *
+__mpx_wrapper_memmove (void *dst, const void *src, size_t n)
+{
+  const char *s = (const char*)src;
+  char *d = (char*)dst;
+  void *ret = dst;
+  size_t offset_src = ((size_t) s) & (sizeof (void *) - 1);
+  size_t offset_dst = ((size_t) d) & (sizeof (void *) - 1);
+
+  __bnd_chk_ptr_bounds (dst, n);
+  __bnd_chk_ptr_bounds (src, n);
+
+  /* Different alignment means that even if
+     pointers exist in memory, we don't how
+     pointers are aligned and therefore cann't
+     copy bounds anyway.  */
+  if (offset_src != offset_dst)
+    memmove (dst, src, n);
+  else
+    {
+      if (s < d)
+	{
+	  d += n;
+	  s += n;
+	  offset_src = (offset_src + n) & (sizeof (void *) -1);
+	  while (n-- && offset_src--)
+	    *--d = *--s;
+	  n++;
+	  if (!n)
+	    return ret;
+	  void **d1 = (void **)d;
+	  void **s1 = (void **)s;
+	  /* This loop will also copy bounds.  */
+	  while (n >= sizeof (void *))
+	    {
+	      n -= sizeof (void *);
+	      *--d1 = *--s1;
+	    }
+	  s = (char *)s1;
+	  d = (char *)d1;
+	  while (n--)
+	    *--d = *--s;
+	}
+      else
+	{
+	  offset_src = sizeof (void *) - offset_src;
+	  while (n-- && offset_src--)
+	    *d++ = *s++;
+	  n++;
+	  if (!n)
+	    return ret;
+	  void **d1 = (void **)d;
+	  void **s1 = (void **)s;
+	  /* This loop will also copy bounds.  */
+	  while (n >= sizeof (void *))
+	    {
+	      n -= sizeof (void *);
+	      *d1++ = *s1++;
+	    }
+	  s = (char *)s1;
+	  d = (char *)d1;
+	  while (n--)
+	    *d++ = *s++;
+	}
+    }
+  return ret;
+}
+
+
+void *
+__mpx_wrapper_memcpy (void *dst, const void *src, size_t n)
+{
+  return __mpx_wrapper_memmove (dst, src, n);
+}
+
+void *
+__mpx_wrapper_mempcpy (void *dst, const void *src, size_t n)
+{
+  return (char *)__mpx_wrapper_memcpy (dst, src, n) + n;
+}
+
+char *
+__mpx_wrapper_strncat (char *dst, const char *src, size_t n)
+{
+  size_t dst_size = strlen (dst);
+  size_t src_size = strnlen (src, n);
+
+  __bnd_chk_ptr_bounds (dst, dst_size + src_size + 1);
+  if (src_size < n)
+    __bnd_chk_ptr_bounds (src, src_size + 1);
+  else
+    __bnd_chk_ptr_bounds (src, src_size);
+
+  strncat (dst, src, n);
+
+  return dst;
+}
+
+char *
+__mpx_wrapper_strcat (char *dst, const char *src)
+{
+  size_t dst_size = strlen (dst);
+  size_t src_size = strlen (src);
+
+  __bnd_chk_ptr_bounds (dst, dst_size + src_size + 1);
+  __bnd_chk_ptr_bounds (src, src_size + 1);
+
+  strcat (dst, src);
+
+  return dst;
+}
+
+char *
+__mpx_wrapper_stpcpy (char *dst, const char *src)
+{
+  size_t src_size = strlen (src);
+
+  __bnd_chk_ptr_bounds (dst, src_size + 1);
+  __bnd_chk_ptr_bounds (src, src_size + 1);
+
+  memcpy (dst, src, src_size + 1);
+
+  return dst + src_size;
+}
+
+char *
+__mpx_wrapper_stpncpy (char *dst, const char *src, size_t n)
+{
+  size_t src_size = strnlen (src, n);
+
+  __bnd_chk_ptr_bounds (dst, n);
+  if (src_size < n)
+    __bnd_chk_ptr_bounds (src, src_size + 1);
+  else
+    __bnd_chk_ptr_bounds (src, src_size);
+
+  return dst + src_size;
+}
+
+char *
+__mpx_wrapper_strcpy (char *dst, const char *src)
+{
+  size_t src_size = strlen (src);
+
+  __bnd_chk_ptr_bounds (dst, src_size + 1);
+  __bnd_chk_ptr_bounds (src, src_size + 1);
+
+  memcpy (dst, src, src_size + 1);
+
+  return dst;
+}
+
+char *
+__mpx_wrapper_strncpy (char *dst, const char *src, size_t n)
+{
+  size_t src_size = strnlen (src, n);
+
+  __bnd_chk_ptr_bounds (dst, n);
+  if (src_size < n)
+    __bnd_chk_ptr_bounds (src, src_size + 1);
+  else
+    __bnd_chk_ptr_bounds (src, src_size);
+
+  return dst;
+}
+
+size_t
+__mpx_wrapper_strlen (const char *s)
+{
+  size_t length = strlen (s);
+  __bnd_chk_ptr_bounds (s, length);
+  return length;
+}
