|
111
|
1 /* Copyright (C) 2013-2017 Free Software Foundation, Inc.
|
|
|
2
|
|
|
3 This file is part of GCC.
|
|
|
4
|
|
|
5 GCC is free software; you can redistribute it and/or modify it under
|
|
|
6 the terms of the GNU General Public License as published by the Free
|
|
|
7 Software Foundation; either version 3, or (at your option) any later
|
|
|
8 version.
|
|
|
9
|
|
|
10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
13 for more details.
|
|
|
14
|
|
|
15 You should have received a copy of the GNU General Public License
|
|
|
16 along with GCC; see the file COPYING3. If not see
|
|
|
17 <http://www.gnu.org/licenses/>. */
|
|
|
18
|
|
|
19 /* Virtual Table Pointer Security. */
|
|
|
20
|
|
|
21 #ifndef VTABLE_VERIFY_H
|
|
|
22 #define VTABLE_VERIFY_H
|
|
|
23
|
|
|
24 #include "sbitmap.h"
|
|
|
25
|
|
|
26 /* The function decl used to create calls to __VLTVtableVerify. It must
|
|
|
27 be global because it needs to be initialized in the C++ front end, but
|
|
|
28 used in the middle end (in the vtable verification pass). */
|
|
|
29
|
|
|
30 extern tree verify_vtbl_ptr_fndecl;
|
|
|
31
|
|
|
32 /* Global variable keeping track of how many vtable map variables we
|
|
|
33 have created. */
|
|
|
34 extern unsigned num_vtable_map_nodes;
|
|
|
35
|
|
|
36 /* Keep track of how many virtual calls we are actually verifying. */
|
|
|
37 extern int total_num_virtual_calls;
|
|
|
38 extern int total_num_verified_vcalls;
|
|
|
39
|
|
|
40 /* Each vtable map variable corresponds to a virtual class. Each
|
|
|
41 vtable map variable has a hash table associated with it, that keeps
|
|
|
42 track of the vtable pointers for which we have generated a call to
|
|
|
43 __VLTRegisterPair (with the current vtable map variable). This is
|
|
|
44 the hash table node that is used for each entry in this hash table
|
|
|
45 of vtable pointers.
|
|
|
46
|
|
|
47 Sometimes there are multiple valid vtable pointer entries that use
|
|
|
48 the same vtable pointer decl with different offsets. Therefore,
|
|
|
49 for each vtable pointer in the hash table, there is also an array
|
|
|
50 of offsets used with that vtable. */
|
|
|
51
|
|
|
52 struct vtable_registration
|
|
|
53 {
|
|
|
54 tree vtable_decl; /* The var decl of the vtable. */
|
|
|
55 vec<unsigned> offsets; /* The offsets array. */
|
|
|
56 };
|
|
|
57
|
|
|
58 struct registration_hasher : nofree_ptr_hash <struct vtable_registration>
|
|
|
59 {
|
|
|
60 static inline hashval_t hash (const vtable_registration *);
|
|
|
61 static inline bool equal (const vtable_registration *,
|
|
|
62 const vtable_registration *);
|
|
|
63 };
|
|
|
64
|
|
|
65 typedef hash_table<registration_hasher> register_table_type;
|
|
|
66 typedef register_table_type::iterator registration_iterator_type;
|
|
|
67
|
|
|
68 /* This struct is used to represent the class hierarchy information
|
|
|
69 that we need. Each vtable map variable has an associated class
|
|
|
70 hierarchy node (struct vtv_graph_node). Note: In this struct,
|
|
|
71 'children' means immediate descendants in the class hierarchy;
|
|
|
72 'descendant' means any descendant however many levels deep. */
|
|
|
73
|
|
|
74 struct vtv_graph_node {
|
|
|
75 tree class_type; /* The record_type of the class. */
|
|
|
76 unsigned class_uid; /* A unique, monotonically
|
|
|
77 ascending id for class node.
|
|
|
78 Each vtable map node also has
|
|
|
79 an id. The class uid is the
|
|
|
80 same as the vtable map node id
|
|
|
81 for nodes corresponding to the
|
|
|
82 same class. */
|
|
|
83 unsigned num_processed_children; /* # of children for whom we have
|
|
|
84 computed the class hierarchy
|
|
|
85 transitive closure. */
|
|
|
86 vec<struct vtv_graph_node *> parents; /* Vector of parents in the graph. */
|
|
|
87 vec<struct vtv_graph_node *> children; /* Vector of children in the graph.*/
|
|
|
88 sbitmap descendants; /* Bitmap representing all this node's
|
|
|
89 descendants in the graph. */
|
|
|
90 };
|
|
|
91
|
|
|
92 /* This is the node used for our hashtable of vtable map variable
|
|
|
93 information. When we create a vtable map variable (var decl) we
|
|
|
94 put it into one of these nodes; create a corresponding
|
|
|
95 vtv_graph_node for our class hierarchy info and store that in this
|
|
|
96 node; generate a unique (monotonically ascending) id for both the
|
|
|
97 vtbl_map_node and the vtv_graph_node; and insert the node into two
|
|
|
98 data structures (to make it easy to find in several different
|
|
|
99 ways): 1). A hash table ("vtbl_map_hash" in vtable-verify.c).
|
|
|
100 This gives us an easy way to check to see if we already have a node
|
|
|
101 for the vtable map variable or not; and 2). An array (vector) of
|
|
|
102 vtbl_map_nodes, where the array index corresponds to the unique id
|
|
|
103 of the vtbl_map_node, which gives us an easy way to use bitmaps to
|
|
|
104 represent and find the vtable map nodes. */
|
|
|
105
|
|
|
106 struct vtbl_map_node {
|
|
|
107 tree vtbl_map_decl; /* The var decl for the vtable map
|
|
|
108 variable. */
|
|
|
109 tree class_name; /* The DECL_ASSEMBLER_NAME of the
|
|
|
110 class. */
|
|
|
111 struct vtv_graph_node *class_info; /* Our class hierarchy info for the
|
|
|
112 class. */
|
|
|
113 unsigned uid; /* The unique id for the vtable map
|
|
|
114 variable. */
|
|
|
115 struct vtbl_map_node *next, *prev; /* Pointers for the linked list
|
|
|
116 structure. */
|
|
|
117 register_table_type *registered; /* Hashtable of vtable pointers for which
|
|
|
118 we have generated a _VLTRegisterPair
|
|
|
119 call with this vtable map variable. */
|
|
|
120 bool is_used; /* Boolean indicating if we used this vtable map
|
|
|
121 variable in a call to __VLTVerifyVtablePointer. */
|
|
|
122 };
|
|
|
123
|
|
|
124 /* Controls debugging for vtable verification. */
|
|
|
125 extern bool vtv_debug;
|
|
|
126
|
|
|
127 /* The global vector of vtbl_map_nodes. */
|
|
|
128 extern vec<struct vtbl_map_node *> vtbl_map_nodes_vec;
|
|
|
129
|
|
|
130 /* The global vectors for mangled class names for anonymous classes. */
|
|
|
131 extern GTY(()) vec<tree, va_gc> *vtbl_mangled_name_types;
|
|
|
132 extern GTY(()) vec<tree, va_gc> *vtbl_mangled_name_ids;
|
|
|
133
|
|
|
134 extern void vtbl_register_mangled_name (tree, tree);
|
|
|
135 extern struct vtbl_map_node *vtbl_map_get_node (tree);
|
|
|
136 extern struct vtbl_map_node *find_or_create_vtbl_map_node (tree);
|
|
|
137 extern void vtbl_map_node_class_insert (struct vtbl_map_node *, unsigned);
|
|
|
138 extern bool vtbl_map_node_registration_find (struct vtbl_map_node *,
|
|
|
139 tree, unsigned);
|
|
|
140 extern bool vtbl_map_node_registration_insert (struct vtbl_map_node *,
|
|
|
141 tree, unsigned);
|
|
|
142
|
|
|
143 #endif /* VTABLE_VERIFY_H */
|
