1/* Copyright (C) 2012-2023 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
6 under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3, or (at your option)
8 any later version.
9
10 GCC is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15You should have received a copy of the GNU General Public License
16along with GCC; see the file COPYING3. If not see
17<http://www.gnu.org/licenses/>. */
18
19/* Virtual Table Pointer Security Pass - Detect corruption of vtable pointers
20 before using them for virtual method dispatches. */
21
22/* This file is part of the vtable security feature implementation.
23 The vtable security feature is designed to detect when a virtual
24 call is about to be made through an invalid vtable pointer
25 (possibly due to data corruption or malicious attacks). The
26 compiler finds every virtual call, and inserts a verification call
27 before the virtual call. The verification call takes the actual
28 vtable pointer value in the object through which the virtual call
29 is being made, and compares the vtable pointer against a set of all
30 valid vtable pointers that the object could contain (this set is
31 based on the declared type of the object). If the pointer is in
32 the valid set, execution is allowed to continue; otherwise the
33 program is halted.
34
35 There are several pieces needed in order to make this work: 1. For
36 every virtual class in the program (i.e. a class that contains
37 virtual methods), we need to build the set of all possible valid
38 vtables that an object of that class could point to. This includes
39 vtables for any class(es) that inherit from the class under
40 consideration. 2. For every such data set we build up, we need a
41 way to find and reference the data set. This is complicated by the
42 fact that the real vtable addresses are not known until runtime,
43 when the program is loaded into memory, but we need to reference the
44 sets at compile time when we are inserting verification calls into
45 the program. 3. We need to find every virtual call in the program,
46 and insert the verification call (with the appropriate arguments)
47 before the virtual call. 4. We need some runtime library pieces:
48 the code to build up the data sets at runtime; the code to actually
49 perform the verification using the data sets; and some code to set
50 protections on the data sets, so they themselves do not become
51 hacker targets.
52
53 To find and reference the set of valid vtable pointers for any given
54 virtual class, we create a special global varible for each virtual
55 class. We refer to this as the "vtable map variable" for that
56 class. The vtable map variable has the type "void *", and is
57 initialized by the compiler to NULL. At runtime when the set of
58 valid vtable pointers for a virtual class, e.g. class Foo, is built,
59 the vtable map variable for class Foo is made to point to the set.
60 During compile time, when the compiler is inserting verification
61 calls into the program, it passes the vtable map variable for the
62 appropriate class to the verification call, so that at runtime the
63 verification call can find the appropriate data set.
64
65 The actual set of valid vtable pointers for a virtual class,
66 e.g. class Foo, cannot be built until runtime, when the vtables get
67 loaded into memory and their addresses are known. But the knowledge
68 about which vtables belong in which class' hierarchy is only known
69 at compile time. Therefore at compile time we collect class
70 hierarchy and vtable information about every virtual class, and we
71 generate calls to build up the data sets at runtime. To build the
72 data sets, we call one of the functions we add to the runtime
73 library, __VLTRegisterPair. __VLTRegisterPair takes two arguments,
74 a vtable map variable and the address of a vtable. If the vtable
75 map variable is currently NULL, it creates a new data set (hash
76 table), makes the vtable map variable point to the new data set, and
77 inserts the vtable address into the data set. If the vtable map
78 variable is not NULL, it just inserts the vtable address into the
79 data set. In order to make sure that our data sets are built before
80 any verification calls happen, we create a special constructor
81 initialization function for each compilation unit, give it a very
82 high initialization priority, and insert all of our calls to
83 __VLTRegisterPair into our special constructor initialization
84 function.
85
86 The vtable verification feature is controlled by the flag
87 '-fvtable-verify='. There are three flavors of this:
88 '-fvtable-verify=std', '-fvtable-verify=preinit', and
89 '-fvtable-verify=none'. If the option '-fvtable-verfy=preinit' is
90 used, then our constructor initialization function gets put into the
91 preinit array. This is necessary if there are data sets that need
92 to be built very early in execution. If the constructor
93 initialization function gets put into the preinit array, the we also
94 add calls to __VLTChangePermission at the beginning and end of the
95 function. The call at the beginning sets the permissions on the
96 data sets and vtable map variables to read/write, and the one at the
97 end makes them read-only. If the '-fvtable-verify=std' option is
98 used, the constructor initialization functions are executed at their
99 normal time, and the __VLTChangePermission calls are handled
100 differently (see the comments in libstdc++-v3/libsupc++/vtv_rts.cc).
101 The option '-fvtable-verify=none' turns off vtable verification.
102
103 This file contains code to find and record the class hierarchies for
104 the virtual classes in a program, and all the vtables associated
105 with each such class; to generate the vtable map variables; and to
106 generate the constructor initialization function (with the calls to
107 __VLTRegisterPair, and __VLTChangePermission). The main data
108 structures used for collecting the class hierarchy data and
109 building/maintaining the vtable map variable data are defined in
110 gcc/vtable-verify.h, because they are used both here and in
111 gcc/vtable-verify.cc. */
112
113#include "config.h"
114#include "system.h"
115#include "coretypes.h"
116#include "vtable-verify.h"
117#include "cp-tree.h"
118#include "stringpool.h"
119#include "cgraph.h"
120#include "output.h"
121#include "tree-iterator.h"
122#include "gimplify.h"
123#include "stor-layout.h"
124
125static int num_calls_to_regset = 0;
126static int num_calls_to_regpair = 0;
127static int current_set_size;
128
129/* Mark these specially since they need to be stored in precompiled
130 header IR. */
131static GTY (()) vec<tree, va_gc> *vlt_saved_class_info;
132static GTY (()) tree vlt_register_pairs_fndecl = NULL_TREE;
133static GTY (()) tree vlt_register_set_fndecl = NULL_TREE;
134
135struct work_node {
136 struct vtv_graph_node *node;
137 struct work_node *next;
138};
139
140struct vtbl_map_node *vtable_find_or_create_map_decl (tree);
141
142/* As part of vtable verification the compiler generates and inserts
143 calls to __VLTVerifyVtablePointer, which is in libstdc++. This
144 function builds and initializes the function decl that is used
145 in generating those function calls.
146
147 In addition to __VLTVerifyVtablePointer there is also
148 __VLTVerifyVtablePointerDebug which can be used in place of
149 __VLTVerifyVtablePointer, and which takes extra parameters and
150 outputs extra information, to help debug problems. The debug
151 version of this function is generated and used if flag_vtv_debug is
152 true.
153
154 The signatures for these functions are:
155
156 void * __VLTVerifyVtablePointer (void **, void*);
157 void * __VLTVerifyVtablePointerDebug (void**, void *, char *, char *);
158*/
159
160void
161vtv_build_vtable_verify_fndecl (void)
162{
163 tree func_type = NULL_TREE;
164
165 if (verify_vtbl_ptr_fndecl != NULL_TREE
166 && TREE_CODE (verify_vtbl_ptr_fndecl) != ERROR_MARK)
167 return;
168
169 if (flag_vtv_debug)
170 {
171 func_type = build_function_type_list (const_ptr_type_node,
172 build_pointer_type (ptr_type_node),
173 const_ptr_type_node,
174 const_string_type_node,
175 const_string_type_node,
176 NULL_TREE);
177 verify_vtbl_ptr_fndecl =
178 build_lang_decl (FUNCTION_DECL,
179 get_identifier ("__VLTVerifyVtablePointerDebug"),
180 func_type);
181 }
182 else
183 {
184 func_type = build_function_type_list (const_ptr_type_node,
185 build_pointer_type (ptr_type_node),
186 const_ptr_type_node,
187 NULL_TREE);
188 verify_vtbl_ptr_fndecl =
189 build_lang_decl (FUNCTION_DECL,
190 get_identifier ("__VLTVerifyVtablePointer"),
191 func_type);
192 }
193
194 TREE_NOTHROW (verify_vtbl_ptr_fndecl) = 1;
195 DECL_ATTRIBUTES (verify_vtbl_ptr_fndecl)
196 = tree_cons (get_identifier ("leaf"), NULL,
197 DECL_ATTRIBUTES (verify_vtbl_ptr_fndecl));
198 DECL_PURE_P (verify_vtbl_ptr_fndecl) = 1;
199 TREE_PUBLIC (verify_vtbl_ptr_fndecl) = 1;
200 DECL_PRESERVE_P (verify_vtbl_ptr_fndecl) = 1;
201}
202
203/* As part of vtable verification the compiler generates and inserts
204 calls to __VLTRegisterSet and __VLTRegisterPair, which are in
205 libsupc++. This function builds and initializes the function decls
206 that are used in generating those function calls.
207
208 The signatures for these functions are:
209
210 void __VLTRegisterSetDebug (void **, const void *, std::size_t,
211 size_t, void **);
212
213 void __VLTRegisterSet (void **, const void *, std::size_t,
214 size_t, void **);
215
216 void __VLTRegisterPairDebug (void **, const void *, size_t,
217 const void *, const char *, const char *);
218
219 void __VLTRegisterPair (void **, const void *, size_t, const void *);
220*/
221
222static void
223init_functions (void)
224{
225 tree register_set_type;
226 tree register_pairs_type;
227
228 if (vlt_register_set_fndecl != NULL_TREE)
229 return;
230
231 gcc_assert (vlt_register_pairs_fndecl == NULL_TREE);
232 gcc_assert (vlt_register_set_fndecl == NULL_TREE);
233
234 /* Build function decl for __VLTRegisterSet*. */
235
236 register_set_type = build_function_type_list
237 (void_type_node,
238 build_pointer_type (ptr_type_node),
239 const_ptr_type_node,
240 size_type_node,
241 size_type_node,
242 build_pointer_type (ptr_type_node),
243 NULL_TREE);
244
245 if (flag_vtv_debug)
246 vlt_register_set_fndecl = build_lang_decl
247 (FUNCTION_DECL,
248 get_identifier ("__VLTRegisterSetDebug"),
249 register_set_type);
250 else
251 vlt_register_set_fndecl = build_lang_decl
252 (FUNCTION_DECL,
253 get_identifier ("__VLTRegisterSet"),
254 register_set_type);
255
256
257 TREE_NOTHROW (vlt_register_set_fndecl) = 1;
258 DECL_ATTRIBUTES (vlt_register_set_fndecl) =
259 tree_cons (get_identifier ("leaf"), NULL,
260 DECL_ATTRIBUTES (vlt_register_set_fndecl));
261 DECL_EXTERNAL(vlt_register_set_fndecl) = 1;
262 TREE_PUBLIC (vlt_register_set_fndecl) = 1;
263 DECL_PRESERVE_P (vlt_register_set_fndecl) = 1;
264 SET_DECL_LANGUAGE (vlt_register_set_fndecl, lang_cplusplus);
265
266 /* Build function decl for __VLTRegisterPair*. */
267
268 if (flag_vtv_debug)
269 {
270 register_pairs_type = build_function_type_list (void_type_node,
271 build_pointer_type
272 (ptr_type_node),
273 const_ptr_type_node,
274 size_type_node,
275 const_ptr_type_node,
276 const_string_type_node,
277 const_string_type_node,
278 NULL_TREE);
279
280 vlt_register_pairs_fndecl = build_lang_decl
281 (FUNCTION_DECL,
282 get_identifier ("__VLTRegisterPairDebug"),
283 register_pairs_type);
284 }
285 else
286 {
287 register_pairs_type = build_function_type_list (void_type_node,
288 build_pointer_type
289 (ptr_type_node),
290 const_ptr_type_node,
291 size_type_node,
292 const_ptr_type_node,
293 NULL_TREE);
294
295 vlt_register_pairs_fndecl = build_lang_decl
296 (FUNCTION_DECL,
297 get_identifier ("__VLTRegisterPair"),
298 register_pairs_type);
299 }
300
301 TREE_NOTHROW (vlt_register_pairs_fndecl) = 1;
302 DECL_ATTRIBUTES (vlt_register_pairs_fndecl) =
303 tree_cons (get_identifier ("leaf"), NULL,
304 DECL_ATTRIBUTES (vlt_register_pairs_fndecl));
305 DECL_EXTERNAL(vlt_register_pairs_fndecl) = 1;
306 TREE_PUBLIC (vlt_register_pairs_fndecl) = 1;
307 DECL_PRESERVE_P (vlt_register_pairs_fndecl) = 1;
308 SET_DECL_LANGUAGE (vlt_register_pairs_fndecl, lang_cplusplus);
309
310}
311
312/* This is a helper function for
313 vtv_compute_class_hierarchy_transitive_closure. It adds a
314 vtv_graph_node to the WORKLIST, which is a linked list of
315 seen-but-not-yet-processed nodes. INSERTED is a bitmap, one bit
316 per node, to help make sure that we don't insert a node into the
317 worklist more than once. Each node represents a class somewhere in
318 our class hierarchy information. Every node in the graph gets added
319 to the worklist exactly once and removed from the worklist exactly
320 once (when all of its children have been processed). */
321
322static void
323add_to_worklist (struct work_node **worklist, struct vtv_graph_node *node,
324 sbitmap inserted)
325{
326 struct work_node *new_work_node;
327
328 if (bitmap_bit_p (map: inserted, bitno: node->class_uid))
329 return;
330
331 new_work_node = XNEW (struct work_node);
332 new_work_node->next = *worklist;
333 new_work_node->node = node;
334 *worklist = new_work_node;
335
336 bitmap_set_bit (map: inserted, bitno: node->class_uid);
337}
338
339/* This is a helper function for
340 vtv_compute_class_hierarchy_transitive_closure. It goes through
341 the WORKLIST of class hierarchy nodes looking for a "leaf" node,
342 i.e. a node whose children in the hierarchy have all been
343 processed. When it finds the next leaf node, it removes it from
344 the linked list (WORKLIST) and returns the node. */
345
346static struct vtv_graph_node *
347find_and_remove_next_leaf_node (struct work_node **worklist)
348{
349 struct work_node *prev, *cur;
350 struct vtv_graph_node *ret_val = NULL;
351
352 for (prev = NULL, cur = *worklist; cur; prev = cur, cur = cur->next)
353 {
354 if ((cur->node->children).length() == cur->node->num_processed_children)
355 {
356 if (prev == NULL)
357 (*worklist) = cur->next;
358 else
359 prev->next = cur->next;
360
361 cur->next = NULL;
362 ret_val = cur->node;
363 free (ptr: cur);
364 return ret_val;
365 }
366 }
367
368 return NULL;
369}
370
371/* In our class hierarchy graph, each class node contains a bitmap,
372 with one bit for each class in the hierarchy. The bits are set for
373 classes that are descendants in the graph of the current node.
374 Initially the descendants bitmap is only set for immediate
375 descendants. This function traverses the class hierarchy graph,
376 bottom up, filling in the transitive closures for the descendants
377 as we rise up the graph. */
378
379void
380vtv_compute_class_hierarchy_transitive_closure (void)
381{
382 struct work_node *worklist = NULL;
383 sbitmap inserted = sbitmap_alloc (num_vtable_map_nodes);
384 unsigned i;
385 unsigned j;
386
387 /* Note: Every node in the graph gets added to the worklist exactly
388 once and removed from the worklist exactly once (when all of its
389 children have been processed). Each node's children edges are
390 followed exactly once, and each node's parent edges are followed
391 exactly once. So this algorithm is roughly O(V + 2E), i.e.
392 O(E + V). */
393
394 /* Set-up: */
395 /* Find all the "leaf" nodes in the graph, and add them to the worklist. */
396 bitmap_clear (inserted);
397 for (j = 0; j < num_vtable_map_nodes; ++j)
398 {
399 struct vtbl_map_node *cur = vtbl_map_nodes_vec[j];
400 if (cur->class_info
401 && ((cur->class_info->children).length() == 0)
402 && ! (bitmap_bit_p (map: inserted, bitno: cur->class_info->class_uid)))
403 add_to_worklist (worklist: &worklist, node: cur->class_info, inserted);
404 }
405
406 /* Main work: pull next leaf node off work list, process it, add its
407 parents to the worklist, where a 'leaf' node is one that has no
408 children, or all of its children have been processed. */
409 while (worklist)
410 {
411 struct vtv_graph_node *temp_node =
412 find_and_remove_next_leaf_node (worklist: &worklist);
413
414 gcc_assert (temp_node != NULL);
415 temp_node->descendants = sbitmap_alloc (num_vtable_map_nodes);
416 bitmap_clear (temp_node->descendants);
417 bitmap_set_bit (map: temp_node->descendants, bitno: temp_node->class_uid);
418 for (i = 0; i < (temp_node->children).length(); ++i)
419 bitmap_ior (temp_node->descendants, temp_node->descendants,
420 temp_node->children[i]->descendants);
421 for (i = 0; i < (temp_node->parents).length(); ++i)
422 {
423 temp_node->parents[i]->num_processed_children =
424 temp_node->parents[i]->num_processed_children + 1;
425 if (!bitmap_bit_p (map: inserted, bitno: temp_node->parents[i]->class_uid))
426 add_to_worklist (worklist: &worklist, node: temp_node->parents[i], inserted);
427 }
428 }
429}
430
431/* Keep track of which pairs we have already created __VLTRegisterPair
432 calls for, to prevent creating duplicate calls within the same
433 compilation unit. VTABLE_DECL is the var decl for the vtable of
434 the (descendant) class that we are adding to our class hierarchy
435 data. VPTR_ADDRESS is an expression for calculating the correct
436 offset into the vtable (VTABLE_DECL). It is the actual vtable
437 pointer address that will be stored in our list of valid vtable
438 pointers for BASE_CLASS. BASE_CLASS is the record_type node for
439 the base class to whose hiearchy we want to add
440 VPTR_ADDRESS. (VTABLE_DECL should be the vtable for BASE_CLASS or
441 one of BASE_CLASS' descendents. */
442
443static bool
444check_and_record_registered_pairs (tree vtable_decl, tree vptr_address,
445 tree base_class)
446{
447 unsigned offset;
448 struct vtbl_map_node *base_vtable_map_node;
449 bool inserted_something = false;
450
451
452 if (TREE_CODE (vptr_address) == ADDR_EXPR
453 && TREE_CODE (TREE_OPERAND (vptr_address, 0)) == MEM_REF)
454 vptr_address = TREE_OPERAND (vptr_address, 0);
455
456 if (TREE_OPERAND_LENGTH (vptr_address) > 1)
457 offset = TREE_INT_CST_LOW (TREE_OPERAND (vptr_address, 1));
458 else
459 offset = 0;
460
461 base_vtable_map_node = vtbl_map_get_node (TYPE_MAIN_VARIANT (base_class));
462
463 inserted_something = vtbl_map_node_registration_insert
464 (base_vtable_map_node,
465 vtable_decl,
466 offset);
467 return !inserted_something;
468}
469
470/* A class may contain secondary vtables in it, for various reasons.
471 This function goes through the decl chain of a class record looking
472 for any fields that point to secondary vtables, and adding calls to
473 __VLTRegisterPair for the secondary vtable pointers.
474
475 BASE_CLASS_DECL_ARG is an expression for the address of the vtable
476 map variable for the BASE_CLASS (whose hierarchy we are currently
477 updating). BASE_CLASS is the record_type node for the base class.
478 RECORD_TYPE is the record_type node for the descendant class that
479 we are possibly adding to BASE_CLASS's hierarchy. BODY is the
480 function body for the constructor init function to which we are
481 adding our calls to __VLTRegisterPair. */
482
483static void
484register_construction_vtables (tree base_class, tree record_type,
485 vec<tree> *vtable_ptr_array)
486{
487 tree vtbl_var_decl;
488
489 if (TREE_CODE (record_type) != RECORD_TYPE)
490 return;
491
492 vtbl_var_decl = CLASSTYPE_VTABLES (record_type);
493
494 if (CLASSTYPE_VBASECLASSES (record_type))
495 {
496 tree vtt_decl;
497 bool already_registered = false;
498 tree val_vtbl_decl = NULL_TREE;
499
500 vtt_decl = DECL_CHAIN (vtbl_var_decl);
501
502 /* Check to see if we have found a VTT. Add its data if appropriate. */
503 if (vtt_decl)
504 {
505 tree values = DECL_INITIAL (vtt_decl);
506 if (TREE_ASM_WRITTEN (vtt_decl)
507 && values != NULL_TREE
508 && TREE_CODE (values) == CONSTRUCTOR
509 && TREE_CODE (TREE_TYPE (values)) == ARRAY_TYPE)
510 {
511 unsigned HOST_WIDE_INT cnt;
512 constructor_elt *ce;
513
514 /* Loop through the initialization values for this
515 vtable to get all the correct vtable pointer
516 addresses that we need to add to our set of valid
517 vtable pointers for the current base class. This may
518 result in adding more than just the element assigned
519 to the primary vptr of the class, so we may end up
520 with more vtable pointers than are strictly
521 necessary. */
522
523 for (cnt = 0;
524 vec_safe_iterate (CONSTRUCTOR_ELTS (values),
525 ix: cnt, ptr: &ce);
526 cnt++)
527 {
528 tree value = ce->value;
529
530 /* Search for the ADDR_EXPR operand within the value. */
531
532 while (value
533 && TREE_OPERAND (value, 0)
534 && TREE_CODE (TREE_OPERAND (value, 0)) == ADDR_EXPR)
535 value = TREE_OPERAND (value, 0);
536
537 /* The VAR_DECL for the vtable should be the first
538 argument of the ADDR_EXPR, which is the first
539 argument of value.*/
540
541 if (TREE_OPERAND (value, 0))
542 val_vtbl_decl = TREE_OPERAND (value, 0);
543
544 while (!VAR_P (val_vtbl_decl)
545 && TREE_OPERAND (val_vtbl_decl, 0))
546 val_vtbl_decl = TREE_OPERAND (val_vtbl_decl, 0);
547
548 gcc_assert (VAR_P (val_vtbl_decl));
549
550 /* Check to see if we already have this vtable pointer in
551 our valid set for this base class. */
552
553 already_registered = check_and_record_registered_pairs
554 (vtable_decl: val_vtbl_decl,
555 vptr_address: value,
556 base_class);
557
558 if (already_registered)
559 continue;
560
561 /* Add this vtable pointer to our set of valid
562 pointers for the base class. */
563
564 vtable_ptr_array->safe_push (obj: value);
565 current_set_size++;
566 }
567 }
568 }
569 }
570}
571
572/* This function iterates through all the vtables it can find from the
573 BINFO of a class, to make sure we have found ALL of the vtables
574 that an object of that class could point to. Generate calls to
575 __VLTRegisterPair for those vtable pointers that we find.
576
577 BINFO is the tree_binfo node for the BASE_CLASS. BODY is the
578 function body for the constructor init function to which we are
579 adding calls to __VLTRegisterPair. ARG1 is an expression for the
580 address of the vtable map variable (for the BASE_CLASS), that will
581 point to the updated data set. BASE_CLASS is the record_type node
582 for the base class whose set of valid vtable pointers we are
583 updating. STR1 and STR2 are all debugging information, to be passed
584 as parameters to __VLTRegisterPairDebug. STR1 represents the name
585 of the vtable map variable to be updated by the call. Similarly,
586 STR2 represents the name of the class whose vtable pointer is being
587 added to the hierarchy. */
588
589static void
590register_other_binfo_vtables (tree binfo, tree base_class,
591 vec<tree> *vtable_ptr_array)
592{
593 unsigned ix;
594 tree base_binfo;
595 tree vtable_decl;
596 bool already_registered;
597
598 if (binfo == NULL_TREE)
599 return;
600
601 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
602 {
603 if ((!BINFO_PRIMARY_P (base_binfo)
604 || BINFO_VIRTUAL_P (base_binfo))
605 && (vtable_decl = get_vtbl_decl_for_binfo (base_binfo)))
606 {
607 tree vtable_address = build_vtbl_address (base_binfo);
608
609 already_registered = check_and_record_registered_pairs
610 (vtable_decl,
611 vptr_address: vtable_address,
612 base_class);
613 if (!already_registered)
614 {
615 vtable_ptr_array->safe_push (obj: vtable_address);
616 current_set_size++;
617 }
618 }
619
620 register_other_binfo_vtables (binfo: base_binfo, base_class, vtable_ptr_array);
621 }
622}
623
624/* The set of valid vtable pointers for any given class are stored in
625 a hash table. For reasons of efficiency, that hash table size is
626 always a power of two. In order to try to prevent re-sizing the
627 hash tables very often, we pass __VLTRegisterPair an initial guess
628 as to the number of entries the hashtable will eventually need
629 (rounded up to the nearest power of two). This function takes the
630 class information we have collected for a particular class,
631 CLASS_NODE, and calculates the hash table size guess. */
632
633static int
634guess_num_vtable_pointers (struct vtv_graph_node *class_node)
635{
636 tree vtbl;
637 int total_num_vtbls = 0;
638 int num_vtbls_power_of_two = 1;
639 unsigned i;
640
641 for (i = 0; i < num_vtable_map_nodes; ++i)
642 if (bitmap_bit_p (map: class_node->descendants, bitno: i))
643 {
644 tree class_type = vtbl_map_nodes_vec[i]->class_info->class_type;
645 for (vtbl = CLASSTYPE_VTABLES (class_type); vtbl;
646 vtbl = DECL_CHAIN (vtbl))
647 {
648 total_num_vtbls++;
649 if (total_num_vtbls > num_vtbls_power_of_two)
650 num_vtbls_power_of_two <<= 1;
651 }
652 }
653 return num_vtbls_power_of_two;
654}
655
656/* A simple hash function on strings */
657/* Be careful about changing this routine. The values generated will
658 be stored in the calls to InitSet. So, changing this routine may
659 cause a binary incompatibility. */
660
661static uint32_t
662vtv_string_hash (const char *in)
663{
664 const char *s = in;
665 uint32_t h = 0;
666
667 gcc_assert (in != NULL);
668 for ( ; *s; ++s)
669 h = 5 * h + *s;
670 return h;
671}
672
673static char *
674get_log_file_name (const char *fname)
675{
676 const char *tmp_dir = concat (dump_dir_name, NULL);
677 char *full_name;
678 int dir_len;
679 int fname_len;
680
681 dir_len = strlen (s: tmp_dir);
682 fname_len = strlen (s: fname);
683
684 full_name = XNEWVEC (char, dir_len + fname_len + 1);
685 strcpy (dest: full_name, src: tmp_dir);
686 strcpy (dest: full_name + dir_len, src: fname);
687
688 return full_name;
689}
690
691static void
692write_out_current_set_data (tree base_class, int set_size)
693{
694 static int class_data_log_fd = -1;
695 char buffer[1024];
696 int bytes_written __attribute__ ((unused));
697 char *file_name = get_log_file_name (fname: "vtv_class_set_sizes.log");
698
699 if (class_data_log_fd == -1)
700 class_data_log_fd = open (file: file_name,
701 O_WRONLY | O_APPEND | O_CREAT, S_IRWXU);
702
703 if (class_data_log_fd == -1)
704 {
705 warning_at (UNKNOWN_LOCATION, 0,
706 "unable to open log file %<vtv_class_set_sizes.log%>: %m");
707 return;
708 }
709
710 snprintf (s: buffer, maxlen: sizeof (buffer), format: "%s %d\n",
711 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (base_class))),
712 set_size);
713 bytes_written = write (fd: class_data_log_fd, buf: buffer, n: strlen (s: buffer));
714}
715
716static tree
717build_key_buffer_arg (tree base_ptr_var_decl)
718{
719 const int key_type_fixed_size = 8;
720 uint32_t len1 = IDENTIFIER_LENGTH (DECL_NAME (base_ptr_var_decl));
721 uint32_t hash_value = vtv_string_hash (IDENTIFIER_POINTER
722 (DECL_NAME (base_ptr_var_decl)));
723 void *key_buffer = xmalloc (len1 + key_type_fixed_size);
724 uint32_t *value_ptr = (uint32_t *) key_buffer;
725 tree ret_value;
726
727 /* Set the len and hash for the string. */
728 *value_ptr = len1;
729 value_ptr++;
730 *value_ptr = hash_value;
731
732 /* Now copy the string representation of the vtbl map name... */
733 memcpy (dest: (char *) key_buffer + key_type_fixed_size,
734 IDENTIFIER_POINTER (DECL_NAME (base_ptr_var_decl)),
735 n: len1);
736
737 /* ... and build a string literal from it. This will make a copy
738 so the key_bufffer is not needed anymore after this. */
739 ret_value = build_string_literal (len1 + key_type_fixed_size,
740 (char *) key_buffer);
741 free (ptr: key_buffer);
742 return ret_value;
743}
744
745static void
746insert_call_to_register_set (tree class_name,
747 vec<tree> *vtbl_ptr_array, tree body, tree arg1,
748 tree arg2, tree size_hint_arg)
749{
750 tree call_expr;
751 int num_args = vtbl_ptr_array->length();
752 char *array_arg_name = ACONCAT (("__vptr_array_",
753 IDENTIFIER_POINTER (class_name), NULL));
754 tree array_arg_type = build_array_type_nelts (build_pointer_type
755 (build_pointer_type
756 (void_type_node)),
757 num_args);
758 tree array_arg = build_decl (UNKNOWN_LOCATION, VAR_DECL,
759 get_identifier (array_arg_name),
760 array_arg_type);
761 int k;
762
763 vec<constructor_elt, va_gc> *array_elements;
764 vec_alloc (v&: array_elements, nelems: num_args);
765
766 tree initial = NULL_TREE;
767 tree arg3 = NULL_TREE;
768
769 TREE_PUBLIC (array_arg) = 0;
770 DECL_EXTERNAL (array_arg) = 0;
771 TREE_STATIC (array_arg) = 1;
772 DECL_ARTIFICIAL (array_arg) = 0;
773 TREE_READONLY (array_arg) = 1;
774 DECL_IGNORED_P (array_arg) = 0;
775 DECL_PRESERVE_P (array_arg) = 0;
776 DECL_VISIBILITY (array_arg) = VISIBILITY_HIDDEN;
777
778 for (k = 0; k < num_args; ++k)
779 {
780 CONSTRUCTOR_APPEND_ELT (array_elements, NULL_TREE, (*vtbl_ptr_array)[k]);
781 }
782
783 initial = build_constructor (TREE_TYPE (array_arg), array_elements);
784
785 TREE_CONSTANT (initial) = 1;
786 TREE_STATIC (initial) = 1;
787 DECL_INITIAL (array_arg) = initial;
788 relayout_decl (array_arg);
789 varpool_node::finalize_decl (decl: array_arg);
790
791 arg3 = build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (array_arg)), array_arg);
792
793 TREE_TYPE (arg3) = build_pointer_type (TREE_TYPE (array_arg));
794
795 call_expr = build_call_expr (vlt_register_set_fndecl, 5, arg1,
796 arg2, /* set_symbol_key */
797 size_hint_arg, build_int_cst (size_type_node,
798 num_args),
799 arg3);
800 append_to_statement_list (call_expr, &body);
801 num_calls_to_regset++;
802}
803
804static void
805insert_call_to_register_pair (vec<tree> *vtbl_ptr_array, tree arg1,
806 tree arg2, tree size_hint_arg, tree str1,
807 tree str2, tree body)
808{
809 tree call_expr;
810 int num_args = vtbl_ptr_array->length();
811 tree vtable_address = NULL_TREE;
812
813 if (num_args == 0)
814 vtable_address = build_int_cst (build_pointer_type (void_type_node), 0);
815 else
816 vtable_address = (*vtbl_ptr_array)[0];
817
818 if (flag_vtv_debug)
819 call_expr = build_call_expr (vlt_register_pairs_fndecl, 6, arg1, arg2,
820 size_hint_arg, vtable_address, str1, str2);
821 else
822 call_expr = build_call_expr (vlt_register_pairs_fndecl, 4, arg1, arg2,
823 size_hint_arg, vtable_address);
824
825 append_to_statement_list (call_expr, &body);
826 num_calls_to_regpair++;
827}
828
829static void
830output_set_info (tree record_type, vec<tree> vtbl_ptr_array)
831{
832 static int vtv_debug_log_fd = -1;
833 char buffer[1024];
834 int bytes_written __attribute__ ((unused));
835 int array_len = vtbl_ptr_array.length();
836 const char *class_name =
837 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (record_type)));
838 char *file_name = get_log_file_name (fname: "vtv_set_ptr_data.log");
839
840 if (vtv_debug_log_fd == -1)
841 vtv_debug_log_fd = open (file: file_name,
842 O_WRONLY | O_APPEND | O_CREAT, S_IRWXU);
843 if (vtv_debug_log_fd == -1)
844 {
845 warning_at (UNKNOWN_LOCATION, 0,
846 "unable to open log file %<vtv_set_ptr_data.log%>: %m");
847 return;
848 }
849
850 for (int i = 0; i < array_len; ++i)
851 {
852 const char *vptr_name = "unknown";
853 int vptr_offset = 0;
854
855 if (TREE_CODE (vtbl_ptr_array[i]) == POINTER_PLUS_EXPR)
856 {
857 tree arg0 = TREE_OPERAND (vtbl_ptr_array[i], 0);
858 tree arg1 = TREE_OPERAND (vtbl_ptr_array[i], 1);
859
860 if (TREE_CODE (arg0) == ADDR_EXPR)
861 arg0 = TREE_OPERAND (arg0, 0);
862
863 if (VAR_P (arg0))
864 vptr_name = IDENTIFIER_POINTER (DECL_NAME (arg0));
865
866 if (TREE_CODE (arg1) == INTEGER_CST)
867 vptr_offset = TREE_INT_CST_LOW (arg1);
868 }
869
870 snprintf (s: buffer, maxlen: sizeof (buffer), format: "%s %s %s + %d\n",
871 main_input_filename, class_name, vptr_name, vptr_offset);
872 bytes_written = write (fd: vtv_debug_log_fd, buf: buffer, n: strlen(s: buffer));
873 }
874
875}
876
877/* This function goes through our internal class hierarchy & vtable
878 pointer data structure and outputs calls to __VLTRegisterPair for
879 every class-vptr pair (for those classes whose vtable would be
880 output in the current compilation unit). These calls get put into
881 our constructor initialization function. BODY is the function
882 body, so far, of our constructor initialization function, to which we
883 add the calls. */
884
885static bool
886register_all_pairs (tree body)
887{
888 bool registered_at_least_one = false;
889 vec<tree> *vtbl_ptr_array = NULL;
890 unsigned j;
891
892 for (j = 0; j < num_vtable_map_nodes; ++j)
893 {
894 struct vtbl_map_node *current = vtbl_map_nodes_vec[j];
895 unsigned i = 0;
896 tree base_class = current->class_info->class_type;
897 tree base_ptr_var_decl = current->vtbl_map_decl;
898 tree arg1;
899 tree arg2;
900 tree new_type;
901 tree str1 = NULL_TREE;
902 tree str2 = NULL_TREE;
903 size_t size_hint;
904 tree size_hint_arg;
905
906 gcc_assert (current->class_info != NULL);
907
908
909 if (flag_vtv_debug)
910 str1 = build_string_literal (DECL_NAME (base_ptr_var_decl));
911
912 new_type = build_pointer_type (TREE_TYPE (base_ptr_var_decl));
913 arg1 = build1 (ADDR_EXPR, new_type, base_ptr_var_decl);
914
915 /* We need a fresh vector for each iteration. */
916 if (vtbl_ptr_array)
917 vec_free (v&: vtbl_ptr_array);
918
919 vec_alloc (v&: vtbl_ptr_array, nelems: 10);
920
921 for (i = 0; i < num_vtable_map_nodes; ++i)
922 if (bitmap_bit_p (map: current->class_info->descendants, bitno: i))
923 {
924 struct vtbl_map_node *vtbl_class_node = vtbl_map_nodes_vec[i];
925 tree class_type = vtbl_class_node->class_info->class_type;
926
927 if (class_type
928 && (TREE_CODE (class_type) == RECORD_TYPE))
929 {
930 bool already_registered;
931
932 tree binfo = TYPE_BINFO (class_type);
933 tree vtable_decl;
934 bool vtable_should_be_output = false;
935
936 vtable_decl = CLASSTYPE_VTABLES (class_type);
937
938 /* Handle main vtable for this class. */
939
940 if (vtable_decl)
941 {
942 vtable_should_be_output = TREE_ASM_WRITTEN (vtable_decl);
943 str2 = build_string_literal (DECL_NAME (vtable_decl));
944 }
945
946 if (vtable_decl && vtable_should_be_output)
947 {
948 tree vtable_address = build_vtbl_address (binfo);
949
950 already_registered = check_and_record_registered_pairs
951 (vtable_decl,
952 vptr_address: vtable_address,
953 base_class);
954
955
956 if (!already_registered)
957 {
958 vtbl_ptr_array->safe_push (obj: vtable_address);
959
960 /* Find and handle any 'extra' vtables associated
961 with this class, via virtual inheritance. */
962 register_construction_vtables (base_class, record_type: class_type,
963 vtable_ptr_array: vtbl_ptr_array);
964
965 /* Find and handle any 'extra' vtables associated
966 with this class, via multiple inheritance. */
967 register_other_binfo_vtables (binfo, base_class,
968 vtable_ptr_array: vtbl_ptr_array);
969 }
970 }
971 }
972 }
973 current_set_size = vtbl_ptr_array->length();
974
975 /* Sometimes we need to initialize the set symbol even if we are
976 not adding any vtable pointers to the set in the current
977 compilation unit. In that case, we need to initialize the
978 set to our best guess as to what the eventual size of the set
979 hash table will be (to prevent having to re-size the hash
980 table later). */
981
982 size_hint = guess_num_vtable_pointers (class_node: current->class_info);
983
984 /* If we have added vtable pointers to the set in this
985 compilation unit, adjust the size hint for the set's hash
986 table appropriately. */
987 if (vtbl_ptr_array->length() > 0)
988 {
989 unsigned len = vtbl_ptr_array->length();
990 while ((size_t) len > size_hint)
991 size_hint <<= 1;
992 }
993 size_hint_arg = build_int_cst (size_type_node, size_hint);
994
995 /* Get the key-buffer argument. */
996 arg2 = build_key_buffer_arg (base_ptr_var_decl);
997
998 if (str2 == NULL_TREE)
999 str2 = build_string_literal (p: "unknown");
1000
1001 if (flag_vtv_debug)
1002 output_set_info (record_type: current->class_info->class_type,
1003 vtbl_ptr_array: *vtbl_ptr_array);
1004
1005 if (vtbl_ptr_array->length() > 1)
1006 {
1007 insert_call_to_register_set (class_name: current->class_name,
1008 vtbl_ptr_array, body, arg1, arg2,
1009 size_hint_arg);
1010 registered_at_least_one = true;
1011 }
1012 else
1013 {
1014
1015 if (vtbl_ptr_array->length() > 0
1016 || (current->is_used
1017 || (current->registered->size() > 0)))
1018 {
1019 insert_call_to_register_pair (vtbl_ptr_array,
1020 arg1, arg2, size_hint_arg, str1,
1021 str2, body);
1022 registered_at_least_one = true;
1023 }
1024 }
1025
1026 if (flag_vtv_counts && current_set_size > 0)
1027 write_out_current_set_data (base_class, set_size: current_set_size);
1028
1029 }
1030
1031 return registered_at_least_one;
1032}
1033
1034/* Given a tree containing a class type (CLASS_TYPE), this function
1035 finds and returns the class hierarchy node for that class in our
1036 data structure. */
1037
1038static struct vtv_graph_node *
1039find_graph_node (tree class_type)
1040{
1041 struct vtbl_map_node *vtbl_node;
1042
1043 vtbl_node = vtbl_map_get_node (TYPE_MAIN_VARIANT (class_type));
1044 if (vtbl_node)
1045 return vtbl_node->class_info;
1046
1047 return NULL;
1048}
1049
1050/* Add base class/derived class pair to our internal class hierarchy
1051 data structure. BASE_NODE is our vtv_graph_node that corresponds
1052 to a base class. DERIVED_NODE is our vtv_graph_node that
1053 corresponds to a class that is a descendant of the base class
1054 (possibly the base class itself). */
1055
1056static void
1057add_hierarchy_pair (struct vtv_graph_node *base_node,
1058 struct vtv_graph_node *derived_node)
1059{
1060 (base_node->children).safe_push (obj: derived_node);
1061 (derived_node->parents).safe_push (obj: base_node);
1062}
1063
1064/* This functions adds a new base class/derived class relationship to
1065 our class hierarchy data structure. Both parameters are trees
1066 representing the class types, i.e. RECORD_TYPE trees.
1067 DERIVED_CLASS can be the same as BASE_CLASS. */
1068
1069static void
1070update_class_hierarchy_information (tree base_class,
1071 tree derived_class)
1072{
1073 struct vtv_graph_node *base_node = find_graph_node (class_type: base_class);
1074 struct vtv_graph_node *derived_node = find_graph_node (class_type: derived_class);
1075
1076 add_hierarchy_pair (base_node, derived_node);
1077}
1078
1079
1080static void
1081write_out_vtv_count_data (void)
1082{
1083 static int vtv_count_log_fd = -1;
1084 char buffer[1024];
1085 int unused_vtbl_map_vars = 0;
1086 int bytes_written __attribute__ ((unused));
1087 char *file_name = get_log_file_name (fname: "vtv_count_data.log");
1088
1089 if (vtv_count_log_fd == -1)
1090 vtv_count_log_fd = open (file: file_name,
1091 O_WRONLY | O_APPEND | O_CREAT, S_IRWXU);
1092 if (vtv_count_log_fd == -1)
1093 {
1094 warning_at (UNKNOWN_LOCATION, 0,
1095 "unable to open log file %<vtv_count_data.log%>: %m");
1096 return;
1097 }
1098
1099 for (unsigned i = 0; i < num_vtable_map_nodes; ++i)
1100 {
1101 struct vtbl_map_node *current = vtbl_map_nodes_vec[i];
1102 if (!current->is_used
1103 && current->registered->size() == 0)
1104 unused_vtbl_map_vars++;
1105 }
1106
1107 snprintf (s: buffer, maxlen: sizeof (buffer), format: "%s %d %d %d %d %d\n",
1108 main_input_filename, total_num_virtual_calls,
1109 total_num_verified_vcalls, num_calls_to_regset,
1110 num_calls_to_regpair, unused_vtbl_map_vars);
1111
1112 bytes_written = write (fd: vtv_count_log_fd, buf: buffer, n: strlen (s: buffer));
1113}
1114
1115/* This function calls register_all_pairs, which actually generates
1116 all the calls to __VLTRegisterPair (in the verification constructor
1117 init function). It also generates the calls to
1118 __VLTChangePermission, if the verification constructor init
1119 function is going into the preinit array. INIT_ROUTINE_BODY is
1120 the body of our constructior initialization function, to which we
1121 add our function calls.*/
1122
1123bool
1124vtv_register_class_hierarchy_information (tree init_routine_body)
1125{
1126 bool registered_something = false;
1127
1128 init_functions ();
1129
1130 if (num_vtable_map_nodes == 0)
1131 return false;
1132
1133 /* Add class hierarchy pairs to the vtable map data structure. */
1134 registered_something = register_all_pairs (body: init_routine_body);
1135
1136 if (flag_vtv_counts)
1137 write_out_vtv_count_data ();
1138
1139 return registered_something;
1140}
1141
1142
1143/* Generate the special constructor function that calls
1144 __VLTChangePermission and __VLTRegisterPairs, and give it a very
1145 high initialization priority. */
1146
1147void
1148vtv_generate_init_routine (void)
1149{
1150 tree init_routine_body;
1151 bool vtable_classes_found = false;
1152
1153 push_lang_context (lang_name_c);
1154
1155 /* The priority for this init function (constructor) is carefully
1156 chosen so that it will happen after the calls to unprotect the
1157 memory used for vtable verification and before the memory is
1158 protected again. */
1159 init_routine_body = vtv_start_verification_constructor_init_function ();
1160
1161 vtable_classes_found =
1162 vtv_register_class_hierarchy_information (init_routine_body);
1163
1164 if (vtable_classes_found)
1165 {
1166 tree vtv_fndecl =
1167 vtv_finish_verification_constructor_init_function (init_routine_body);
1168 TREE_STATIC (vtv_fndecl) = 1;
1169 TREE_USED (vtv_fndecl) = 1;
1170 DECL_PRESERVE_P (vtv_fndecl) = 1;
1171 /* We are running too late to generate any meaningful debug information
1172 for this routine. */
1173 DECL_IGNORED_P (vtv_fndecl) = 1;
1174 if (flag_vtable_verify == VTV_PREINIT_PRIORITY && !TARGET_PECOFF)
1175 DECL_STATIC_CONSTRUCTOR (vtv_fndecl) = 0;
1176
1177 gimplify_function_tree (vtv_fndecl);
1178 cgraph_node::add_new_function (fndecl: vtv_fndecl, lowered: false);
1179
1180 if (flag_vtable_verify == VTV_PREINIT_PRIORITY && !TARGET_PECOFF)
1181 {
1182 tree vtv_var
1183 = build_decl (BUILTINS_LOCATION, VAR_DECL,
1184 get_identifier ("__vtv_preinit"),
1185 build_pointer_type (TREE_TYPE (vtv_fndecl)));
1186 TREE_STATIC (vtv_var) = 1;
1187 DECL_ARTIFICIAL (vtv_var) = 1;
1188 DECL_INITIAL (vtv_var) = build_fold_addr_expr (vtv_fndecl);
1189 set_decl_section_name (vtv_var, ".preinit_array");
1190
1191 varpool_node::add (decl: vtv_var);
1192 }
1193 }
1194 pop_lang_context ();
1195}
1196
1197/* This funtion takes a tree containing a class type (BASE_TYPE), and
1198 it either finds the existing vtbl_map_node for that class in our
1199 data structure, or it creates a new node and adds it to the data
1200 structure if there is not one for the class already. As part of
1201 this process it also creates the global vtable map variable for the
1202 class. */
1203
1204struct vtbl_map_node *
1205vtable_find_or_create_map_decl (tree base_type)
1206{
1207 char *var_name = NULL;
1208 struct vtbl_map_node *vtable_map_node = NULL;
1209
1210 /* Verify the type has an associated vtable. */
1211 if (!TYPE_BINFO (base_type) || !BINFO_VTABLE (TYPE_BINFO (base_type)))
1212 return NULL;
1213
1214 /* Create map lookup symbol for base class */
1215 var_name = get_mangled_vtable_map_var_name (base_type);
1216
1217 /* We've already created the variable; just look it. */
1218 vtable_map_node = vtbl_map_get_node (TYPE_MAIN_VARIANT (base_type));
1219
1220 if (!vtable_map_node || (vtable_map_node->vtbl_map_decl == NULL_TREE))
1221 {
1222 /* If we haven't already created the *__vtable_map global
1223 variable for this class, do so now, and add it to the
1224 varpool, to make sure it gets saved and written out. */
1225
1226 tree var_decl = NULL;
1227 tree var_type = build_pointer_type (void_type_node);
1228 tree initial_value = integer_zero_node;
1229
1230 var_decl = build_decl (UNKNOWN_LOCATION, VAR_DECL,
1231 get_identifier (var_name), var_type);
1232
1233 DECL_EXTERNAL (var_decl) = 0;
1234 TREE_STATIC (var_decl) = 1;
1235 DECL_VISIBILITY (var_decl) = VISIBILITY_HIDDEN;
1236 SET_DECL_ASSEMBLER_NAME (var_decl, get_identifier (var_name));
1237 DECL_ARTIFICIAL (var_decl) = 1;
1238 /* We cannot mark this variable as read-only because we want to be
1239 able to write to it at runtime. */
1240 TREE_READONLY (var_decl) = 0;
1241 DECL_IGNORED_P (var_decl) = 1;
1242 DECL_PRESERVE_P (var_decl) = 1;
1243
1244 /* Put these mmap variables in thr .vtable_map_vars section, so
1245 we can find and protect them. */
1246
1247 set_decl_section_name (var_decl, ".vtable_map_vars");
1248 symtab_node::get (decl: var_decl)->implicit_section = true;
1249 DECL_INITIAL (var_decl) = initial_value;
1250
1251 comdat_linkage (var_decl);
1252
1253 varpool_node::finalize_decl (decl: var_decl);
1254 if (!vtable_map_node)
1255 vtable_map_node =
1256 find_or_create_vtbl_map_node (TYPE_MAIN_VARIANT (base_type));
1257 if (vtable_map_node->vtbl_map_decl == NULL_TREE)
1258 vtable_map_node->vtbl_map_decl = var_decl;
1259 }
1260
1261 gcc_assert (vtable_map_node);
1262 return vtable_map_node;
1263}
1264
1265/* This function is used to build up our class hierarchy data for a
1266 particular class. TYPE is the record_type tree node for the
1267 class. */
1268
1269static void
1270vtv_insert_single_class_info (tree type)
1271{
1272 if (flag_vtable_verify)
1273 {
1274 tree binfo = TYPE_BINFO (type);
1275 tree base_binfo;
1276 struct vtbl_map_node *own_map;
1277 int i;
1278
1279 /* First make sure to create the map for this record type. */
1280 own_map = vtable_find_or_create_map_decl (base_type: type);
1281 if (own_map == NULL)
1282 return;
1283
1284 /* Go through the list of all base classes for the current
1285 (derived) type, make sure the *__vtable_map global variable
1286 for the base class exists, and add the base class/derived
1287 class pair to the class hierarchy information we are
1288 accumulating (for vtable pointer verification). */
1289 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1290 {
1291 tree tree_val = BINFO_TYPE (base_binfo);
1292 struct vtbl_map_node *vtable_map_node = NULL;
1293
1294 vtable_map_node = vtable_find_or_create_map_decl (base_type: tree_val);
1295
1296 if (vtable_map_node != NULL)
1297 update_class_hierarchy_information (base_class: tree_val, derived_class: type);
1298 }
1299 }
1300}
1301
1302/* This function adds classes we are interested in to a list of
1303 classes. RECORD is the record_type node for the class we are
1304 adding to the list. */
1305
1306void
1307vtv_save_class_info (tree record)
1308{
1309 if (!flag_vtable_verify || TREE_CODE (record) == UNION_TYPE)
1310 return;
1311
1312 if (!vlt_saved_class_info)
1313 vec_alloc (v&: vlt_saved_class_info, nelems: 10);
1314
1315 gcc_assert (TREE_CODE (record) == RECORD_TYPE);
1316
1317 vec_safe_push (v&: vlt_saved_class_info, obj: record);
1318}
1319
1320
1321/* This function goes through the list of classes we saved and calls
1322 vtv_insert_single_class_info on each one, to build up our class
1323 hierarchy data structure. */
1324
1325void
1326vtv_recover_class_info (void)
1327{
1328 tree current_class;
1329 unsigned i;
1330
1331 if (vlt_saved_class_info)
1332 {
1333 for (i = 0; i < vlt_saved_class_info->length(); ++i)
1334 {
1335 current_class = (*vlt_saved_class_info)[i];
1336 gcc_assert (TREE_CODE (current_class) == RECORD_TYPE);
1337 vtv_insert_single_class_info (type: current_class);
1338 }
1339 }
1340}
1341
1342#include "gt-cp-vtable-class-hierarchy.h"
1343

source code of gcc/cp/vtable-class-hierarchy.cc