Commit the vtable verification feature.

Commit the vtable verification feature.  This feature is designed to
detect, at run time, if/when the vtable pointer in a C++ object has
been corrupted, before allowing virtual calls through that pointer. 
If pointer corruption is detected, execution of the program is halted.

libstdc++-v3 ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        * fragment.am: Add XTEMPLATE_FLAGS.
        * configure.ac: Add definitions for --enable-vtable-verify.
        * acinclude.m4:  Add --enable-vtable-verify and
        --disable-vtable-verify; define --enable-vtable-verify; define
        VTV_CXXFLAGS, VTV_PCH_CXXFLAGS and VTV_CXXLINKFLAGS.
        * config/abi/pre/gnu.ver: Export symbols for vtable verification.
        * libsupc++/Makefile.am: Define vtv_sources and add it to
        libsupc___la_SOURCES and libsupc__convenience_la_SOURCES.
        * libsupc++/vtv_stubs.cc: New file.
        * include/Makefile.am: Add VTV_PCH_CXXFLAGS to PCHFLAGS.
        * src/Makefile.am: Add VTV_CXXFLAGS to AM_CXXFLAGS; add
        VTV_CXXLINKFLAGS to CXXLINK.
        * src/c++98/Makefile.am: Comment out XTEMPLATE_FLAGS; add VTV_CXXFLAGS
        to AM_CXXFLAGS; add VTV_CXXXLINKFLAGS to CXXLINK.
        * src/C++11/Makefile.am: Ditto.
        * doc/xml/manual/configure.xml: Add entry for --enable-vtable-verify.
        * scripts/testsuite_flags.in: Add cxxvtvflags to Usage; cause
        cxxvtvflags to use VTV_CXXFLAGS and VTV_CXXLINKFLAGS.
        * testsuite/lib/libstdc++.exp: Add cxxvtvflags; add code to locate
        libvtv if --enable-vtable-verify was used; set cxxvtvflags; add
        cxxvtvflags to cxx_final.
        * testsuite/18_support/bad_exception/23591_thread-1.c: Add
        -fvtable-verify=none to compiler flags.
        * testsuite/17_intro/freestanding.cc: Add -fvtable-verify=none
        to compiler flags.
        * configure: Regenerated.
        * Makefile.in: Regenerated.
        * python/Makefile.in: Regenerated.
        * include/Makefile.in: Regenerated.
        * libsupc++/Makefile.in: Regenerated.
        * config.h.in: Regenerated.
        * po/Makefile.in: Regenerated.
        * src/Makefile.in: Regenerated.
        * src/c++98/Makefile.in: Regenerated.
        * src/c++11/Makefile.in: Regenerated.
        * doc/Makefile.in: Regenerated.
        * testsuite/Makefile.in: Regenerated.

top level ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        * configure.ac: Add target-libvtv to target_libraries; disable libvtv
        on non-linux systems; add target-libvtv to noconfigdirs; add
        libsupc++/.libs to C++ library search paths.
        * configure: Regenerated.
        * Makefile.def: Add libvtv to target_modules; make libvtv depend on
        libstdc++ and libgcc.
        * Makefile.in: Regenerated.

include/ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        * vtv-change-permission.h: New file.

contrib/ChangeLog:
2013-08-06  Caroline Tice4  <cmtice@google.com>

        * gcc_update: Add libvtv files.

libgcc/ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        config.host (extra_parts): Add vtv_start.o, vtv_end.o
        vtv_start_preinit.o and vtv_end_preinit.o.
        configure.ac: Add code to check/set enable_vtable_verify.
        Makefile.in: Add rules to build vtv_*.o, if enable_vtable_verify is
        true.
        vtv_start_preinit.c: New file.
        vtv_end_preinit.c: New file.
        vtv_start.c: New file.
        vtv_end.c: New file.
        configure: Regenerated.

gcc/ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        * gcc.c (VTABLE_VERIFICATION_SPEC): New definition.
        (LINK_COMMAND_SPEC): Add VTABLE_VERIFICATION_SPEC.
        * tree-pass.h: Add pass_vtable_verify.
        * varasm.c (assemble_variable): Add code to properly set the comdat
        section and name for the .vtable_map_vars section.
        (assemble_vtyv_preinit_initializer): New function.
        (default_sectin_type_flags):  Make sure .vtable_map_vars section has
        LINK_ONCE flag.
        * output.h: Add function decl for assemble_vtv_preinit_initializer.
        * vtable-verify.c: New file.
        * vtable-verify.h: New file.
        * flag-types.h (enum vtv_priority): Defintions for flag_vtable_verify
        initialiation levels.
        * timevar.def (TV_VTABLE_VERIFICATION): New definition.
        * passes.def: Insert pass_vtable_verify.
        * aclocal.m4: Reorder includes.
        * doc/invoke.texi: Add documentation for the flags -fvtable-verify=,
	-fvtv-debug and -fvtv-counts.
        * config/gnu-user.h (GNU_USER_TARGET_STARTFILE_SPEC): Add vtv_start*.o,
as appropriate, if -fvtable-verify=... is used.
        (GNU_USER_TARGET_ENDFILE_SPEC): Add vtv_end*.o as appropriate, if
        -fvtable-verify=... is used.
        * Makefile.in (OBJS):  Add vtable-verify.o to list.
        (vtable-verify.o): Add new build rule.
        (GTFILES): Add vtable-verify.c to list.
        * common.opt (fvtable-verify=): New flag.
        (vtv_priority): Values for fvtable-verify= flag.
        (fvtv-counts): New flag.
(fvtv-debug): New flag.
        * tree.h (save_vtable_map_decl): New extern function decl.


gcc/cp/ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        * Make-lang.in (*CXX_AND_OBJCXX_OBJS):  Add vtable-class-hierarchy.o to
        list.
        (vtable-class-hierarchy.o): Add build rule.
        * cp-tree.h (vtv_start_verification_constructor_init_function): New
        extern function decl.
        (vtv_finish_verification_constructor_init_function): New extern
        function decl.
        (build_vtbl_address): New extern function decl.
        (get_mangled_vtable_map_var_name): New extern function decl.
        (vtv_compute_class_hierarchy_transitive_closure): New extern function
        decl.
        (vtv_generate_init_routine): New extern function decl.
        (vtv_save_class_info): New extern function decl.
        (vtv_recover_class_info): New extern function decl.
        (vtv_build_vtable_verify_fndecl): New extern function decl.
        * class.c (finish_struct_1): Add call to vtv_save_class_info if
        flag_vtable_verify is true.
        * config-lang.in: Add vtable-class-hierarchy.c to gtfiles list.
        * vtable-class-hierarchy.c: New file.
        * mangle.c (get_mangled_vtable_map_var_name):  New function.
        * decl2.c (start_objects): Update function comment.
        (cp_write_global_declarations): Call vtv_recover_class_info,
        vtv_compute_class_hierarchy_transitive_closure and
        vtv_build_vtable_verify_fndecl, before calling
        finalize_compilation_unit, and call vtv_generate_init_rount after, IFF
        flag_vtable_verify is true.
        (vtv_start_verification_constructor_init_function): New function.
        (vtv_finish_verification_constructor_init_function): New function.
        * init.c (build_vtbl_address): Remove static qualifier from function.

libvtv/ChangeLog:
2013-08-06  Caroline Tice  <cmtice@google.com>

        Initial check-in of new vtable verification feature.
        * configure.ac : New file.
        * acinclude.m4 : New file.
        * Makefile.am : New file.
        * aclocal.m4 : New file.
        * configure.tgt : New file.
        * configure: New file (generated).
        * Makefile.in: New file (generated).
        * vtv_set.h : New file.
        * vtv_utils.cc : New file.
        * vtv_utils.h : New file.
        * vtv_malloc.cc : New file.
        * vtv_rts.cc : New file.
        * vtv_malloc.h : New file.
        * vtv_rts.h : New file.
        * vtv_fail.cc : New file.
        * vtv_fail.h : New file.
        * vtv_map.h : New file.
        * scripts/run-testsuite.sh : New file.
        * scripts/sum-vtv-counts.c : New file.
        * testsuite/parts-test-main.h : New file.
        * testusite/dataentry.cc : New file.
        * testsuite/temp_deriv.cc : New file.
        * testsuite/register_pair.cc : New file.
        * testsuite/virtual_inheritance.cc : New file.
        * testsuite/field-test.cc : New file.
        * testsuite/nested_vcall_test.cc : New file.
        * testsuite/template-list-iostream.cc : New file.
        * testsuite/register_pair_inserts.cc : New file.
        * testsuite/register_pair_inserts_mt.cc : New file.
        * testsuite/event.list : New file.
        * testsuite/parts-test-extra-parts-views.cc : New file.
        * testsuite/parts-test-extra-parts-views.h : New file.
        * testsuite/environment-fail-32.s : New file.
        * testsuite/parts-test-extra-parts.h : New file.
        * testsuite/temp_deriv2.cc : New file.
        * testsuite/dlopen_mt.cc : New file.
        * testsuite/event.h : New file.
        * testsuite/template-list.cc : New file.
        * testsuite/replace-fail.cc : New file.
        * testsuite/Makefile.am : New file.
        * testsuite/Makefile.in: New file (generated).
        * testsuite/mempool_negative.c : New file.
        * testsuite/parts-test-main.cc : New file.
        * testsuite/event-private.cc : New file.
        * testsuite/thunk.cc : New file.
        * testsuite/event-defintiions.cc : New file.
        * testsuite/event-private.h : New file.
        * testsuite/parts-test.list : New file.
        * testusite/register_pair_mt.cc : New file.
        * testsuite/povray-derived.cc : New file.
        * testsuite/event-main.cc : New file.
        * testsuite/environment.cc : New file.
        * testsuite/template-list2.cc : New file.
        * testsuite/thunk_vtable_map_attack.cc : New file.
        * testsuite/parts-test-extra-parts.cc : New file.
        * testsuite/environment-fail-64.s : New file.
        * testsuite/dlopen.cc : New file.
        * testsuite/so.cc : New file.
        * testsuite/temp_deriv3.cc : New file.
        * testsuite/const_vtable.cc : New file.
        * testsuite/mempool_positive.c : New file.
        * testsuite/dup_name.cc : New file.

From-SVN: r201555

1 files changed, 267 insertions, 0 deletions

diff --git a/libvtv/vtv_malloc.cc b/libvtv/vtv_malloc.cc
new file mode 100644
index 0000000..8aaa636
--- /dev/null
+++ b/libvtv/vtv_malloc.cc
@@ -0,0 +1,267 @@
+/* Copyright (C) 2012-2013
+   Free Software Foundation
+
+   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/>.  */
+
+/* This file is part of the vtable verification runtime library.  It
+   contains our memory allocation and deallocation routines, which we
+   use in order to keep track of the pages in memory in which our sets
+   of valid vtable pointes are stored.  (We need to know the pages so
+   we can set the protections on them appropriately).  For more
+   information about the vtable verification feature, see the comments
+   in vtv_rts.cc.  We use the existing obstack implementation in our
+   memory allocation scheme.  */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include "vtv_utils.h"
+#include "vtv_malloc.h"
+#include "obstack.h"
+
+/* The following variables are used only for debugging and performance tuning
+   purposes. Therefore they do not need to be "protected".  They cannot be used
+   to attack the vtable verification system and if they become corrupted it will
+   not affect the correctness or security of any of the rest of the vtable
+   verification feature.  */
+
+unsigned int num_calls_to_mprotect = 0;
+unsigned int num_pages_protected = 0;
+unsigned int long long mprotect_cycles = 0;
+
+/* Put the following variables in our ".vtable_map_vars" section so
+   that they are protected.  They are explicitly unprotected and
+   protected again by calls to __vtv_unprotect and __vtv_protect */
+
+static struct obstack vtv_obstack VTV_PROTECTED_VAR;
+static void *current_chunk VTV_PROTECTED_VAR = 0;
+static size_t current_chunk_size VTV_PROTECTED_VAR = 0;
+static int malloc_initialized VTV_PROTECTED_VAR = 0;
+
+/* The function goes through and counts all the pages we have allocated
+   so far.  It returns the page count.  */
+
+int
+__vtv_count_mmapped_pages (void)
+{
+  int count = 0;
+  struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
+  while (ci)
+    {
+      count++;
+      ci = ci->prev;
+    }
+
+  return count;
+}
+
+/* This function goes through all of the pages we have allocated so
+   far and calls mprotect to change the protections on the pages,
+   according to the value of PROTECTION_FLAG.  */
+
+static void
+change_protections_on_data_chunks (int protection_flag)
+{
+  struct _obstack_chunk *ci;
+  ci = (struct _obstack_chunk *) current_chunk;
+
+  while (ci)
+    {
+      /* Initial set up for mprotect call.*/
+      struct _obstack_chunk *protect_start = ci;
+      size_t chunk_size;
+      size_t total_size;
+      unsigned int num_pages_in_chunk;
+      char *next_page;
+      unsigned long long start, end;
+      int result;
+
+
+      /* As long as the next 'chunk' is adjacent to the current one,
+         keep going down the list.  */
+      do
+        {
+          chunk_size = (ci->limit - (char *) ci);
+          total_size = (ci->limit - (char *) protect_start);
+          num_pages_in_chunk = chunk_size / VTV_PAGE_SIZE;
+          if (chunk_size % VTV_PAGE_SIZE > 0)
+            num_pages_in_chunk++;
+          next_page = (char *) ci + (num_pages_in_chunk * VTV_PAGE_SIZE);
+          ci = ci->prev;
+        } while (ci && (char *) ci == next_page);
+
+      VTV_DEBUG_ASSERT (((unsigned long) protect_start & (VTV_PAGE_SIZE - 1))
+                                                                       == 0);
+
+      /* Protect the contiguous chunks so far.  */
+      start = rdtsc ();
+      result = mprotect (protect_start, total_size, protection_flag);
+      end = rdtsc ();
+      mprotect_cycles += end - start;
+      if (result == -1)
+        VTV_error ();
+      num_calls_to_mprotect++;
+      num_pages_protected += (total_size + VTV_PAGE_SIZE - 1)/ VTV_PAGE_SIZE;
+    }
+
+#ifdef VTV_DEBUG
+    VTV_malloc_dump_stats ();
+#endif
+}
+
+/* This function makes all of our allocated pages read-only.  */
+
+void
+__vtv_malloc_protect (void)
+{
+  change_protections_on_data_chunks (PROT_READ);
+}
+
+/* This function makes all of our allocated pages read-write.  */
+
+void
+__vtv_malloc_unprotect (void)
+{
+  change_protections_on_data_chunks (PROT_READ | PROT_WRITE);
+}
+
+/* Allocates a SIZE-sized chunk of memory that is aligned to a page
+   boundary.  The amount of memory requested (SIZE) must be a multiple
+   of the page size.  Note: We must use mmap to allocate the memory;
+   using malloc here will cause problems.  */
+
+static void *
+obstack_chunk_alloc (size_t size)
+{
+  /* Increase size to the next multiple of VTV_PAGE_SIZE.   */
+  size = (size + (VTV_PAGE_SIZE - 1)) & (~(VTV_PAGE_SIZE - 1));
+  VTV_DEBUG_ASSERT ((size & (VTV_PAGE_SIZE - 1)) == 0);
+  void *allocated;
+
+  if ((allocated = mmap (NULL, size, PROT_READ | PROT_WRITE,
+                         MAP_PRIVATE | MAP_ANONYMOUS,  -1, 0)) == 0)
+    VTV_error ();
+
+  VTV_DEBUG_ASSERT (((unsigned long) allocated & (VTV_PAGE_SIZE - 1)) == 0);
+
+  current_chunk = allocated;
+  current_chunk_size = size;
+  return allocated;
+}
+
+static void
+obstack_chunk_free (size_t)
+{
+  /* Do nothing. For our purposes there should be very little
+     de-allocation. */
+}
+
+/* This function sets up and initializes the obstack pieces for our
+   memory allocation scheme.  */
+
+void
+__vtv_malloc_init (void)
+{
+  /* Make sure we only execute the main body of this function ONCE.  */
+  if (malloc_initialized)
+    return;
+
+  if (VTV_PAGE_SIZE != sysconf (_SC_PAGE_SIZE))
+    VTV_error ();
+
+  obstack_chunk_size (&vtv_obstack) = VTV_PAGE_SIZE;
+  obstack_alignment_mask (&vtv_obstack) = sizeof (long) - 1;
+  /* We guarantee that the obstack alloc failed handler will never be
+     called because in case the allocation of the chunk fails, it will
+     never return */
+  obstack_alloc_failed_handler = NULL;
+
+  obstack_init (&vtv_obstack);
+  malloc_initialized = 1;
+}
+
+/* This is our external interface for the memory allocation.  SIZE is
+   the requested number of bytes to be allocated/  */
+
+void *
+__vtv_malloc (size_t size)
+{
+  return obstack_alloc (&vtv_obstack, size);
+}
+
+
+/* This is our external interface for memory deallocation.  */
+
+void
+__vtv_free (void *)
+{
+  /* Do nothing. We dont care about recovering unneded memory at this
+     time.  */
+}
+
+
+/* This is a debugging function tat collects statistics about our
+   memory allocation.  */
+void
+__vtv_malloc_stats (void)
+{
+  int count = 0;
+  struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
+  while (ci)
+    {
+      count++;
+      ci = ci->prev;
+    }
+  fprintf (stderr,
+           "__vtv_malloc_stats:\n  Page Size = %lu bytes\n  "
+           "Number of pages = %d\n", static_cast<unsigned long>(VTV_PAGE_SIZE),
+	   count);
+}
+
+/* This is a debugging function.  It writes out our memory allocation
+   statistics to a log file.  */
+
+void
+__vtv_malloc_dump_stats (void)
+{
+  static int fd = -1;
+
+  if (fd == -1)
+    fd = __vtv_open_log ("vtv_mem_protection.log");
+  if (fd == -1)
+    return;
+
+  int count = 0;
+  struct _obstack_chunk * ci = (struct _obstack_chunk *) current_chunk;
+  while (ci)
+    {
+      count++;
+      ci = ci->prev;
+    }
+
+  __vtv_add_to_log (fd, "__vtv_malloc_protect protected=%d pages\n", count);
+}