b0cca5ecbb
Fix PR 66521
libvtv/ChangeLog
2015-08-01 Caroline Tice <cmtice@google.com>
PR 66521
* Makefile.am: Update to match latest tree.
* Makefile.in: Regenerate.
* testsuite/lib/libvtv: Brought up to date.
* vtv_malloc.cc (VTV_DEBUG): Update function call to match renamed
function (old bug!).
* vtv_rts.cc (debug_functions, debug_init, debug_verify_vtable): Update
initializations to work correctly with VTV_DEBUG defined.
gcc/ChangeLog:
2015-08-01 Caroline Tice <cmtice@google.com>
PR 66521
* vtable-verify.c (vtbl_mangled_name_types, vtbl_mangled_name_ids): New
global variables.
(vtbl_find_mangled_name): New function.
(vtbl_register_mangled_name): New function.
(vtbl_map_get_node): If DECL_ASSEMBLER_NAME is "<anon>", look up
mangled name in mangled name vectors.
(find_or_create_vtbl_map_node): Ditto.
(var_is_used_for_virtual_call_p): Add recursion_depth parameter;
update recursion_depth on function entry; pass it to every recursive
call; automatically exit if depth > 25 (give up looking at that point).
(verify_bb_vtables): Initialize recursion_depth and pass it to
var_is_used_for_virtual_call_p.
* vtable-verify.h (vtbl_mangbled_name_types, vtbl_mangled_name_ids): New
global variable decls.
(vtbl_register_mangled_name): New extern function decl.
gcc/cp/ChangeLog:
2015-08-01 Caroline Tice <cmtice@google.com>
PR 66521
* mangle.c : Add vtable-verify.h to include files.
(get_mangled_vtable_map_var_name): If the DECL_ASSEMBLER_NAME
is "<anon>" get the real mangled name for the class instead, and
also store the real mangled name in a vector for use later.
From-SVN: r226471
144 lines
6.7 KiB
C
144 lines
6.7 KiB
C
/* Copyright (C) 2013-2015 Free Software Foundation, Inc.
|
|
|
|
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.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* Virtual Table Pointer Security. */
|
|
|
|
#ifndef VTABLE_VERIFY_H
|
|
#define VTABLE_VERIFY_H
|
|
|
|
#include "sbitmap.h"
|
|
|
|
/* The function decl used to create calls to __VLTVtableVerify. It must
|
|
be global because it needs to be initialized in the C++ front end, but
|
|
used in the middle end (in the vtable verification pass). */
|
|
|
|
extern tree verify_vtbl_ptr_fndecl;
|
|
|
|
/* Global variable keeping track of how many vtable map variables we
|
|
have created. */
|
|
extern unsigned num_vtable_map_nodes;
|
|
|
|
/* Keep track of how many virtual calls we are actually verifying. */
|
|
extern int total_num_virtual_calls;
|
|
extern int total_num_verified_vcalls;
|
|
|
|
/* Each vtable map variable corresponds to a virtual class. Each
|
|
vtable map variable has a hash table associated with it, that keeps
|
|
track of the vtable pointers for which we have generated a call to
|
|
__VLTRegisterPair (with the current vtable map variable). This is
|
|
the hash table node that is used for each entry in this hash table
|
|
of vtable pointers.
|
|
|
|
Sometimes there are multiple valid vtable pointer entries that use
|
|
the same vtable pointer decl with different offsets. Therefore,
|
|
for each vtable pointer in the hash table, there is also an array
|
|
of offsets used with that vtable. */
|
|
|
|
struct vtable_registration
|
|
{
|
|
tree vtable_decl; /* The var decl of the vtable. */
|
|
vec<unsigned> offsets; /* The offsets array. */
|
|
};
|
|
|
|
struct registration_hasher : nofree_ptr_hash <struct vtable_registration>
|
|
{
|
|
static inline hashval_t hash (const vtable_registration *);
|
|
static inline bool equal (const vtable_registration *,
|
|
const vtable_registration *);
|
|
};
|
|
|
|
typedef hash_table<registration_hasher> register_table_type;
|
|
typedef register_table_type::iterator registration_iterator_type;
|
|
|
|
/* This struct is used to represent the class hierarchy information
|
|
that we need. Each vtable map variable has an associated class
|
|
hierarchy node (struct vtv_graph_node). Note: In this struct,
|
|
'children' means immediate descendants in the class hierarchy;
|
|
'descendant' means any descendant however many levels deep. */
|
|
|
|
struct vtv_graph_node {
|
|
tree class_type; /* The record_type of the class. */
|
|
unsigned class_uid; /* A unique, monotonically
|
|
ascending id for class node.
|
|
Each vtable map node also has
|
|
an id. The class uid is the
|
|
same as the vtable map node id
|
|
for nodes corresponding to the
|
|
same class. */
|
|
unsigned num_processed_children; /* # of children for whom we have
|
|
computed the class hierarchy
|
|
transitive closure. */
|
|
vec<struct vtv_graph_node *> parents; /* Vector of parents in the graph. */
|
|
vec<struct vtv_graph_node *> children; /* Vector of children in the graph.*/
|
|
sbitmap descendants; /* Bitmap representing all this node's
|
|
descendants in the graph. */
|
|
};
|
|
|
|
/* This is the node used for our hashtable of vtable map variable
|
|
information. When we create a vtable map variable (var decl) we
|
|
put it into one of these nodes; create a corresponding
|
|
vtv_graph_node for our class hierarchy info and store that in this
|
|
node; generate a unique (monotonically ascending) id for both the
|
|
vtbl_map_node and the vtv_graph_node; and insert the node into two
|
|
data structures (to make it easy to find in several different
|
|
ways): 1). A hash table ("vtbl_map_hash" in vtable-verify.c).
|
|
This gives us an easy way to check to see if we already have a node
|
|
for the vtable map variable or not; and 2). An array (vector) of
|
|
vtbl_map_nodes, where the array index corresponds to the unique id
|
|
of the vtbl_map_node, which gives us an easy way to use bitmaps to
|
|
represent and find the vtable map nodes. */
|
|
|
|
struct vtbl_map_node {
|
|
tree vtbl_map_decl; /* The var decl for the vtable map
|
|
variable. */
|
|
tree class_name; /* The DECL_ASSEMBLER_NAME of the
|
|
class. */
|
|
struct vtv_graph_node *class_info; /* Our class hierarchy info for the
|
|
class. */
|
|
unsigned uid; /* The unique id for the vtable map
|
|
variable. */
|
|
struct vtbl_map_node *next, *prev; /* Pointers for the linked list
|
|
structure. */
|
|
register_table_type *registered; /* Hashtable of vtable pointers for which
|
|
we have generated a _VLTRegisterPair
|
|
call with this vtable map variable. */
|
|
bool is_used; /* Boolean indicating if we used this vtable map
|
|
variable in a call to __VLTVerifyVtablePointer. */
|
|
};
|
|
|
|
/* Controls debugging for vtable verification. */
|
|
extern bool vtv_debug;
|
|
|
|
/* The global vector of vtbl_map_nodes. */
|
|
extern vec<struct vtbl_map_node *> vtbl_map_nodes_vec;
|
|
|
|
/* The global vectors for mangled class names for anonymous classes. */
|
|
extern GTY(()) vec<tree, va_gc> *vtbl_mangled_name_types;
|
|
extern GTY(()) vec<tree, va_gc> *vtbl_mangled_name_ids;
|
|
|
|
extern void vtbl_register_mangled_name (tree, tree);
|
|
extern struct vtbl_map_node *vtbl_map_get_node (tree);
|
|
extern struct vtbl_map_node *find_or_create_vtbl_map_node (tree);
|
|
extern void vtbl_map_node_class_insert (struct vtbl_map_node *, unsigned);
|
|
extern bool vtbl_map_node_registration_find (struct vtbl_map_node *,
|
|
tree, unsigned);
|
|
extern bool vtbl_map_node_registration_insert (struct vtbl_map_node *,
|
|
tree, unsigned);
|
|
|
|
#endif /* VTABLE_VERIFY_H */
|