libabigail
abg-fwd.h
Go to the documentation of this file.
1 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
2 // -*- Mode: C++ -*-
3 //
4 // Copyright (C) 2013-2023 Red Hat, Inc.
5 
6 /// @file
7 
8 #ifndef __ABG_IRFWD_H__
9 #define __ABG_IRFWD_H__
10 
11 #include <stdint.h>
12 #include <cstddef>
13 #include <cstdlib>
14 #include <regex.h>
15 #include <list>
16 #include <memory>
17 #include <ostream>
18 #include <string>
19 #include <typeinfo>
20 #include <unordered_map>
21 #include <unordered_set>
22 #include <utility> // for std::rel_ops, at least.
23 #include <vector>
24 #include "abg-interned-str.h"
25 #include "abg-hash.h"
26 
27 /// Toplevel namespace for libabigail.
28 namespace abigail
29 {
30 /**
31  @mainpage libabigail
32 
33  This is the API documentation of the Application Binary
34  Interface Generic Analysis and Instrumentation Library, aka,
35  <em>libabigail</em>.
36 
37  Check out <a href="http://sourceware.org/libabigail"> the project
38  homepage</a>!
39 
40  The current libabigail source code can be browsed at
41  http://sourceware.org/git/gitweb.cgi?p=libabigail.git
42 
43  It can be checked out with:
44  <em>git clone git://sourceware.org/git/libabigail.git</em>
45 
46  The mailing list to send messages and patches to is
47  libabigail@sourceware.org.
48 
49  You can hang out with libabigail developers and users on irc at
50  irc://irc.oftc.net\#libabigail.
51 */
52 
53 // Inject some types.
54 using std::shared_ptr;
55 using std::weak_ptr;
56 using std::unordered_map;
57 using std::string;
58 using std::vector;
59 using std::unordered_set;
60 
61 typedef unordered_set<string> string_set_type;
62 
63 // Pull in relational operators.
64 using namespace std::rel_ops;
65 
66 namespace comparison
67 {
69 
70 /// Convenience typedef for a shared pointer of @ref diff_context.
71 typedef shared_ptr<diff_context> diff_context_sptr;
72 
73 /// Convenience typedef for a weak pointer of @ref diff_context.
74 typedef weak_ptr<diff_context> diff_context_wptr;
75 
76 class diff;
77 
78 /// Convenience typedef for a shared_ptr for the @ref diff class
79 typedef shared_ptr<diff> diff_sptr;
80 
81 /// Convenience typedef for a weak_ptr for the @ref diff class
82 typedef weak_ptr<diff> diff_wptr;
83 }
84 
85 namespace regex
86 {
87 /// A convenience typedef for a shared pointer of regex_t.
88 typedef std::shared_ptr<regex_t> regex_t_sptr;
89 }// end namespace regex
90 
91 namespace ir
92 {
93 
94 // Forward declarations for corpus.
95 
96 class corpus;
97 typedef shared_ptr<corpus> corpus_sptr;
98 
99 class corpus_group;
100 typedef shared_ptr<corpus_group> corpus_group_sptr;
101 
102 // Forward declarations for ir.
103 
104 class ir_node_visitor;
105 
107 
108 /// Convenience typedef for a shared pointer to @ref
109 /// ir_traversable_base.
110 typedef shared_ptr<ir_traversable_base> ir_traversable_base_sptr;
111 
113 /// Convenience typedef for a shared pointer to an @ref environment
114 typedef shared_ptr<environment> environment_sptr;
115 
116 class location;
117 class location_manager;
118 
120 /// A convenience typedef for a shared_ptr to @ref type_or_decl_base.
121 typedef shared_ptr<type_or_decl_base> type_or_decl_base_sptr;
122 
123 class type_base;
124 
125 // Convenience typedef for a shared pointer on a @ref type_base
126 typedef shared_ptr<type_base> type_base_sptr;
127 
128 /// Convenience typedef for a weak pointer on a @ref type_base
129 typedef weak_ptr<type_base> type_base_wptr;
130 
131 /// Convenience typedef for a weak pointer to a @ref corpus.
132 typedef weak_ptr<corpus> corpus_wptr;
133 
135 /// Convenience typedef for a shared pointer on a @ref
136 /// translation_unit type.
137 typedef shared_ptr<translation_unit> translation_unit_sptr;
138 /// Convenience typedef for a map that associates a string to a
139 /// translation unit.
140 typedef unordered_map<string, translation_unit_sptr> string_tu_map_type;
141 
142 /// A convenience typedef for a vector of type_base_wptr.
143 typedef vector<type_base_wptr> type_base_wptrs_type;
144 
145 /// A convenience typedef for a map which key is an interned_string
146 /// and which value is a vector of type_base_wptr.
147 typedef unordered_map<interned_string,
150 
151 class decl_base;
152 
153 // Convenience typedef for a smart pointer on @ref decl_base.
154 typedef shared_ptr<decl_base> decl_base_sptr;
155 
156 class type_decl;
157 /// Convenience typedef for a shared pointer on a @ref type_decl.
158 typedef shared_ptr<type_decl> type_decl_sptr;
159 
160 
162 
163 /// Convenience typedef for a shared pointer on a @ref typedef_decl.
164 typedef shared_ptr<typedef_decl> typedef_decl_sptr;
165 
166 /// Convenience typedef for a weak pointer on a @ref typedef_decl.
167 typedef weak_ptr<typedef_decl> typedef_decl_wptr;
168 
170 
171 /// Convenience typedef for shared pointer to a @ref enum_type_decl.
172 typedef shared_ptr<enum_type_decl> enum_type_decl_sptr;
173 
174 /// Convenience typedef for a vector of @ref enum_type_decl_sptr
175 typedef vector<enum_type_decl_sptr> enums_type;
176 
177 /// Convenience typedef for a weak pointer to a @ref decl_base.
178 typedef weak_ptr<decl_base> decl_base_wptr;
179 
180 class class_or_union;
181 
182 typedef shared_ptr<class_or_union> class_or_union_sptr;
183 typedef weak_ptr<class_or_union> class_or_union_wptr;
184 
185 class scope_type_decl;
186 
188 
189 /// Convenience typedef for a shared pointer on a @ref class_decl
190 typedef shared_ptr<class_decl> class_decl_sptr;
191 
192 /// Convenience typedef for a vector of @ref class_decl_sptr
193 typedef vector<class_decl_sptr> classes_type;
194 
195 /// Convenience typedef for a vector of @ref class_or_union_sptr
196 typedef vector<class_or_union_sptr> classes_or_unions_type;
197 
198 /// Convenience typedef for a weak pointer on a @ref class_decl.
199 typedef weak_ptr<class_decl> class_decl_wptr;
200 
201 class union_decl;
202 
203 typedef shared_ptr<union_decl> union_decl_sptr;
204 
206 /// Convenience typedef for a shared pointer on a @ref function_type
207 typedef shared_ptr<function_type> function_type_sptr;
208 
209 /// Convenience typedef fo a vector of @ref function_type_sptr
210 typedef vector<function_type_sptr> function_types_type;
211 
212 /// Convenience typedef for a weak pointer on a @ref function_type
213 typedef weak_ptr<function_type> function_type_wptr;
214 
216 
217 /// Convenience typedef for shared pointer to @ref method_type.
218 typedef shared_ptr<method_type> method_type_sptr;
219 
221 
222 /// Convenience typedef for a shared pointer on a @ref pointer_type_def
223 typedef shared_ptr<pointer_type_def> pointer_type_def_sptr;
224 
225 class qualified_type_def;
226 
227 typedef shared_ptr<qualified_type_def> qualified_type_def_sptr;
228 
230 
231 /// Convenience typedef for a shared pointer on a @ref reference_type_def
232 typedef shared_ptr<reference_type_def> reference_type_def_sptr;
233 
235 
236 /// Convenience typedef for a shared pointer on a @ref array_type_def
237 typedef shared_ptr<array_type_def> array_type_def_sptr;
238 
239 class subrange_type;
240 
242 
243 /// A convenience typedef for a shared pointer to dm_context_rel.
244 typedef shared_ptr<dm_context_rel> dm_context_rel_sptr;
245 
246 class var_decl;
247 
248 /// Convenience typedef for a shared pointer on a @ref var_decl
249 typedef shared_ptr<var_decl> var_decl_sptr;
250 
251 /// Convenience typedef for a weak pointer on a @ref var_decl
252 typedef weak_ptr<var_decl> var_decl_wptr;
253 
254 typedef unordered_map<interned_string,
255  var_decl*,
256  hash_interned_string> istring_var_decl_ptr_map_type;
257 
259 
260 /// Convenience typedef for a shared pointer on a @ref scope_decl.
261 typedef shared_ptr<scope_decl> scope_decl_sptr;
262 
264 
265 /// Convenience typedef for a shared pointer on a @ref function_decl
266 typedef shared_ptr<function_decl> function_decl_sptr;
267 
268 typedef unordered_map<interned_string,
269  function_decl*,
270  hash_interned_string> istring_function_decl_ptr_map_type;
271 
272 class method_decl;
273 
274 typedef shared_ptr<method_decl> method_decl_sptr;
275 
277 
278 /// A convenience typedef for a shared pointer to @ref
279 /// mem_fn_context_rel.
280 typedef shared_ptr<mem_fn_context_rel> mem_fn_context_rel_sptr;
281 
283 
284 /// Convenience typedef for a shared pointer on namespace_decl.
285 typedef shared_ptr<namespace_decl> namespace_decl_sptr;
286 
288 
289 /// Convenience typedef for a shared pointer on a @ref class_tdecl
290 typedef shared_ptr<class_tdecl> class_tdecl_sptr;
291 
293 
294 /// Convenience typedef for a shared pointer on a @ref function_tdecl
295 typedef shared_ptr<function_tdecl> function_tdecl_sptr;
296 
298 
299 /// Convenience typedef for shared pointer on @ref global_scope.
300 typedef shared_ptr<global_scope> global_scope_sptr;
301 
302 class node_visitor;
303 
305 
306 /// Convenience typedef for a shared pointer to @ref template_decl
307 typedef shared_ptr<template_decl> template_decl_sptr;
308 
309 /// Convenience typedef for a weak pointer to template_decl
310 typedef weak_ptr<template_decl> template_decl_wptr;
311 
313 
314 /// Convenience typedef for shared pointer to template parameter
315 typedef shared_ptr<template_parameter> template_parameter_sptr;
316 
318 
319 /// Convenience typedef for shared pointer to @ref
320 /// non_type_template_parameter
321 typedef shared_ptr<non_type_tparameter> non_type_tparameter_sptr;
322 
323 class type_tparameter;
324 
326 
327 /// Convenience typedef for a shared_ptr to @ref template_tparameter.
328 typedef shared_ptr<template_tparameter> template_tparameter_sptr;
329 
330 /// Convenience typedef for a shared pointer to @ref type_tparameter.
331 typedef shared_ptr<type_tparameter> type_tparameter_sptr;
332 
333 class type_composition;
334 
336 typedef shared_ptr<member_function_template> member_function_template_sptr;
337 typedef vector<member_function_template_sptr> member_function_templates;
338 
340 typedef shared_ptr<member_class_template> member_class_template_sptr;
341 typedef vector<member_class_template_sptr> member_class_templates;
342 
343 /// Convenience typedef for shared pointer to type_composition
344 typedef shared_ptr<type_composition> type_composition_sptr;
345 
346 decl_base_sptr
347 add_decl_to_scope(decl_base_sptr, scope_decl*);
348 
349 decl_base_sptr
350 add_decl_to_scope(decl_base_sptr, const scope_decl_sptr&);
351 
352 const global_scope*
354 
355 const global_scope*
357 
358 const global_scope*
359 get_global_scope(const decl_base_sptr);
360 
363 
366 
368 get_translation_unit(const decl_base_sptr);
369 
370 bool
372 
373 const global_scope*
375 
376 bool
377 is_global_scope(const scope_decl_sptr);
378 
379 bool
381 
382 bool
383 is_at_global_scope(const decl_base_sptr);
384 
385 bool
387 
389 is_at_class_scope(const decl_base_sptr);
390 
393 
396 
397 bool
398 is_at_template_scope(const decl_base_sptr);
399 
400 bool
401 is_template_parameter(const decl_base_sptr);
402 
403 function_decl*
405 
406 function_decl_sptr
407 is_function_decl(const type_or_decl_base_sptr&);
408 
409 bool
411 
412 decl_base*
413 is_decl(const type_or_decl_base*);
414 
415 decl_base_sptr
416 is_decl(const type_or_decl_base_sptr&);
417 
418 decl_base*
420 
421 decl_base_sptr
422 is_decl_slow(const type_or_decl_base_sptr&);
423 
424 bool
425 is_type(const type_or_decl_base&);
426 
427 type_base*
428 is_type(const type_or_decl_base*);
429 
430 type_base_sptr
431 is_type(const type_or_decl_base_sptr& tod);
432 
433 bool
435 
436 bool
437 is_anonymous_type(const type_base_sptr&);
438 
439 const type_decl*
441 
442 type_decl_sptr
443 is_type_decl(const type_or_decl_base_sptr&);
444 
445 type_decl*
447 
448 type_decl_sptr
449 is_integral_type(const type_or_decl_base_sptr&);
450 
451 typedef_decl_sptr
452 is_typedef(const type_or_decl_base_sptr);
453 
454 const typedef_decl*
456 
457 const typedef_decl*
458 is_typedef(const type_base*);
459 
462 
463 enum_type_decl_sptr
464 is_compatible_with_enum_type(const type_base_sptr&);
465 
466 enum_type_decl_sptr
467 is_compatible_with_enum_type(const decl_base_sptr&);
468 
469 enum_type_decl_sptr
470 is_enum_type(const type_or_decl_base_sptr&);
471 
472 const enum_type_decl*
474 
475 bool
477 
478 class_decl*
480 
481 class_decl_sptr
482 is_class_type(const type_or_decl_base_sptr&);
483 
484 var_decl_sptr
486 
487 var_decl_sptr
489 
490 var_decl_sptr
491 has_flexible_array_data_member(const class_decl_sptr&);
492 
493 bool
495  bool look_through_decl_only = false);
496 
497 bool
498 is_declaration_only_class_or_union_type(const type_base_sptr& t,
499  bool look_through_decl_only = false);
500 
503 
504 class_or_union_sptr
505 is_class_or_union_type(const type_or_decl_base_sptr&);
506 
507 bool
509  const class_or_union*);
510 
511 bool
512 class_or_union_types_of_same_kind(const class_or_union_sptr&,
513  const class_or_union_sptr&);
514 
515 bool
517 
518 union_decl*
520 
521 union_decl_sptr
522 is_union_type(const type_or_decl_base_sptr&);
523 
524 class_decl_sptr
525 is_compatible_with_class_type(const type_base_sptr&);
526 
527 class_decl_sptr
528 is_compatible_with_class_type(const decl_base_sptr&);
529 
532 
533 const pointer_type_def*
535 
536 pointer_type_def_sptr
537 is_pointer_type(const type_or_decl_base_sptr&);
538 
539 bool
541 
544 
545 const reference_type_def*
547 
548 reference_type_def_sptr
549 is_reference_type(const type_or_decl_base_sptr&);
550 
551 const type_base*
553 
554 const type_base_sptr
555 is_void_pointer_type(const type_base_sptr&);
556 
557 const type_base*
559 
560 const type_base*
562 
565 
566 qualified_type_def_sptr
567 is_qualified_type(const type_or_decl_base_sptr&);
568 
569 function_type_sptr
570 is_function_type(const type_or_decl_base_sptr&);
571 
574 
575 const function_type*
577 
578 method_type_sptr
579 is_method_type(const type_or_decl_base_sptr&);
580 
581 const method_type*
583 
586 
587 class_or_union_sptr
589 
590 class_or_union_sptr
591 look_through_decl_only_class(class_or_union_sptr);
592 
595 
596 enum_type_decl_sptr
598 
599 enum_type_decl_sptr
600 look_through_decl_only_enum(enum_type_decl_sptr);
601 
602 decl_base_sptr
604 
605 decl_base*
607 
608 decl_base_sptr
609 look_through_decl_only(const decl_base_sptr&);
610 
611 var_decl*
613 
614 var_decl_sptr
615 is_var_decl(const type_or_decl_base_sptr&);
616 
617 namespace_decl_sptr
618 is_namespace(const decl_base_sptr&);
619 
621 is_namespace(const decl_base*);
622 
623 bool
624 is_template_parm_composition_type(const decl_base_sptr);
625 
626 bool
627 is_template_decl(const decl_base_sptr);
628 
629 bool
630 is_function_template_pattern(const decl_base_sptr);
631 
632 
633 decl_base_sptr
634 insert_decl_into_scope(decl_base_sptr,
635  vector<decl_base_sptr >::iterator,
636  scope_decl*);
637 
638 decl_base_sptr
639 insert_decl_into_scope(decl_base_sptr,
640  vector<decl_base_sptr >::iterator,
641  scope_decl_sptr);
642 
643 bool
644 has_scope(const decl_base&);
645 
646 bool
647 has_scope(const decl_base_sptr);
648 
649 bool
650 is_member_decl(const decl_base_sptr);
651 
652 bool
653 is_member_decl(const decl_base*);
654 
655 bool
656 is_member_decl(const decl_base&);
657 
658 scope_decl*
660 
661 scope_decl_sptr
662 is_scope_decl(const decl_base_sptr&);
663 
664 bool
665 is_member_type(const type_base_sptr&);
666 
667 bool
669 
670 bool
671 is_user_defined_type(const type_base_sptr&);
672 
673 void
674 remove_decl_from_scope(decl_base_sptr);
675 
676 bool
678 
679 bool
681 
682 bool
683 get_member_is_static(const decl_base_sptr&);
684 
685 void
687 
688 void
689 set_member_is_static(const decl_base_sptr&, bool);
690 
691 bool
692 is_data_member(const var_decl&);
693 
694 var_decl*
696 
697 bool
698 is_data_member(const var_decl*);
699 
700 var_decl_sptr
701 is_data_member(const type_or_decl_base_sptr&);
702 
703 bool
704 is_data_member(const var_decl_sptr);
705 
706 var_decl_sptr
707 is_data_member(const decl_base_sptr&);
708 
709 var_decl*
710 is_data_member(const decl_base *);
711 
712 var_decl*
713 is_data_member(const decl_base *);
714 
715 const var_decl_sptr
716 get_next_data_member(const class_or_union_sptr&, const var_decl_sptr&);
717 
718 var_decl_sptr
720 
721 var_decl_sptr
723 
724 var_decl_sptr
725 get_last_data_member(const class_or_union_sptr&);
726 
727 bool
729 
730 const var_decl*
732 
733 const var_decl*
735 
736 var_decl_sptr
737 is_anonymous_data_member(const type_or_decl_base_sptr&);
738 
739 var_decl_sptr
740 is_anonymous_data_member(const decl_base_sptr&);
741 
742 var_decl_sptr
743 is_anonymous_data_member(const var_decl_sptr&);
744 
745 const var_decl*
746 is_anonymous_data_member(const var_decl*);
747 
748 bool
749 is_anonymous_data_member(const var_decl&);
750 
751 bool
753 
754 bool
756 
757 bool
758 is_data_member_of_anonymous_class_or_union(const var_decl_sptr&);
759 
760 const var_decl_sptr
761 get_first_non_anonymous_data_member(const var_decl_sptr);
762 
763 var_decl_sptr
765  const string&);
766 
769 
770 class_or_union_sptr
771 anonymous_data_member_to_class_or_union(const var_decl_sptr&);
772 
773 class_or_union_sptr
775 
776 bool
777 anonymous_data_member_exists_in_class(const var_decl& anon_dm,
778  const class_or_union& clazz);
779 
780 bool
782 
783 const class_or_union_sptr
784 data_member_has_anonymous_type(const var_decl& d);
785 
786 const class_or_union_sptr
787 data_member_has_anonymous_type(const var_decl* d);
788 
789 const class_or_union_sptr
790 data_member_has_anonymous_type(const var_decl_sptr& d);
791 
793 is_array_type(const type_or_decl_base* decl);
794 
795 array_type_def_sptr
796 is_array_type(const type_or_decl_base_sptr& decl);
797 
798 array_type_def_sptr
799 is_array_of_qualified_element(const type_base_sptr&);
800 
801 qualified_type_def_sptr
802 is_array_of_qualified_element(const array_type_def_sptr&);
803 
804 array_type_def_sptr
805 is_typedef_of_array(const type_base_sptr&);
806 
807 void
808 set_data_member_offset(var_decl_sptr, uint64_t);
809 
810 uint64_t
811 get_data_member_offset(const var_decl&);
812 
813 uint64_t
814 get_data_member_offset(const var_decl_sptr);
815 
816 uint64_t
817 get_data_member_offset(const decl_base_sptr);
818 
819 uint64_t
820 get_absolute_data_member_offset(const var_decl&);
821 
822 bool
824  const var_decl_sptr&,
825  uint64_t&);
826 
827 bool
828 get_next_data_member_offset(const class_or_union_sptr&,
829  const var_decl_sptr&,
830  uint64_t&);
831 
832 uint64_t
833 get_var_size_in_bits(const var_decl_sptr&);
834 
835 void
836 set_data_member_is_laid_out(var_decl_sptr, bool);
837 
838 bool
839 get_data_member_is_laid_out(const var_decl&);
840 
841 bool
842 get_data_member_is_laid_out(const var_decl_sptr);
843 
844 bool
845 is_member_function(const function_decl&);
846 
847 bool
848 is_member_function(const function_decl*);
849 
850 bool
851 is_member_function(const function_decl_sptr&);
852 
853 bool
854 get_member_function_is_ctor(const function_decl&);
855 
856 bool
857 get_member_function_is_ctor(const function_decl_sptr&);
858 
859 void
860 set_member_function_is_ctor(const function_decl&, bool);
861 
862 void
863 set_member_function_is_ctor(const function_decl_sptr&, bool);
864 
865 bool
866 get_member_function_is_dtor(const function_decl&);
867 
868 bool
869 get_member_function_is_dtor(const function_decl_sptr&);
870 
871 void
872 set_member_function_is_dtor(function_decl&, bool);
873 
874 void
875 set_member_function_is_dtor(const function_decl_sptr&, bool);
876 
877 bool
878 get_member_function_is_const(const function_decl&);
879 
880 bool
881 get_member_function_is_const(const function_decl_sptr&);
882 
883 void
884 set_member_function_is_const(function_decl&, bool);
885 
886 void
887 set_member_function_is_const(const function_decl_sptr&, bool);
888 
889 bool
890 member_function_has_vtable_offset(const function_decl&);
891 
892 ssize_t
893 get_member_function_vtable_offset(const function_decl&);
894 
895 ssize_t
896 get_member_function_vtable_offset(const function_decl_sptr&);
897 
898 void
899 set_member_function_vtable_offset(const function_decl& f,
900  ssize_t s);
901 
902 void
903 set_member_function_vtable_offset(const function_decl_sptr &f,
904  ssize_t s);
905 
906 bool
907 get_member_function_is_virtual(const function_decl&);
908 
909 bool
910 get_member_function_is_virtual(const function_decl_sptr&);
911 
912 bool
913 get_member_function_is_virtual(const function_decl*);
914 
915 void
916 set_member_function_is_virtual(function_decl&, bool);
917 
918 void
919 set_member_function_is_virtual(const function_decl_sptr&, bool);
920 
921 type_base_sptr
922 strip_typedef(const type_base_sptr);
923 
924 decl_base_sptr
925 strip_useless_const_qualification(const qualified_type_def_sptr t);
926 
927 void
928 strip_redundant_quals_from_underyling_types(const qualified_type_def_sptr&);
929 
930 type_base_sptr
931 peel_typedef_type(const type_base_sptr&);
932 
933 const type_base*
935 
936 type_base_sptr
937 peel_pointer_type(const type_base_sptr&);
938 
939 const type_base*
941 
942 type_base_sptr
943 peel_reference_type(const type_base_sptr&);
944 
945 const type_base*
947 
948 const type_base_sptr
949 peel_array_type(const type_base_sptr&);
950 
951 const type_base*
952 peel_array_type(const type_base*);
953 
954 const type_base*
956 
957 const type_base_sptr
958 peel_qualified_type(const type_base_sptr&);
959 
960 type_base*
962 
963 type_base_sptr
964 peel_qualified_or_typedef_type(const type_base_sptr &type);
965 
966 type_base_sptr
967 peel_typedef_pointer_or_reference_type(const type_base_sptr);
968 
969 type_base*
971 
972 type_base*
974  bool peel_qual_type);
975 
976 type_base*
978  bool peel_qualified_type = true);
979 
980 array_type_def_sptr
981 clone_array(const array_type_def_sptr& array);
982 
983 typedef_decl_sptr
984 clone_typedef(const typedef_decl_sptr& t);
985 
986 qualified_type_def_sptr
987 clone_qualified_type(const qualified_type_def_sptr& t);
988 
989 type_base_sptr
990 clone_array_tree(const type_base_sptr t);
991 
992 string
993 get_name(const type_or_decl_base*, bool qualified = true);
994 
995 string
996 get_name(const type_or_decl_base_sptr&,
997  bool qualified = true);
998 
999 location
1000 get_location(const type_base_sptr& type);
1001 
1002 location
1003 get_location(const decl_base_sptr& decl);
1004 
1005 string
1006 build_qualified_name(const scope_decl* scope, const string& name);
1007 
1008 string
1009 build_qualified_name(const scope_decl* scope,
1010  const type_base_sptr& type);
1011 
1012 scope_decl*
1014 
1015 scope_decl*
1016 get_type_scope(const type_base_sptr&);
1017 
1018 interned_string
1019 get_type_name(const type_base_sptr&,
1020  bool qualified = true,
1021  bool internal = false);
1022 
1023 interned_string
1024 get_type_name(const type_base*,
1025  bool qualified = true,
1026  bool internal = false);
1027 
1028 interned_string
1029 get_type_name(const type_base&,
1030  bool qualified = true,
1031  bool internal = false);
1032 
1033 interned_string
1034 get_name_of_pointer_to_type(const type_base& pointed_to_type,
1035  bool qualified = true,
1036  bool internal = false);
1037 
1038 interned_string
1039 get_name_of_reference_to_type(const type_base& pointed_to_type,
1040  bool lvalue_reference = false,
1041  bool qualified = true,
1042  bool internal = false);
1043 
1044 interned_string
1045 get_function_type_name(const function_type_sptr&,
1046  bool internal = false);
1047 
1048 interned_string
1049 get_function_type_name(const function_type*, bool internal = false);
1050 
1051 interned_string
1052 get_function_type_name(const function_type&, bool internal = false);
1053 
1054 interned_string
1055 get_function_id_or_pretty_representation(function_decl *fn);
1056 
1057 interned_string
1058 get_method_type_name(const method_type_sptr&, bool internal = false);
1059 
1060 interned_string
1061 get_method_type_name(const method_type*, bool internal = false);
1062 
1063 interned_string
1064 get_method_type_name(const method_type&, bool internal = false);
1065 
1066 string
1067 get_pretty_representation(const decl_base*, bool internal = false);
1068 
1069 string
1070 get_pretty_representation(const type_base*, bool internal = false);
1071 
1072 string
1073 get_pretty_representation(const type_or_decl_base*, bool internal = false);
1074 
1075 string
1076 get_pretty_representation(const type_or_decl_base_sptr&,
1077  bool internal = false);
1078 
1079 string
1080 get_pretty_representation(const decl_base_sptr&, bool internal = false);
1081 
1082 string
1083 get_pretty_representation(const type_base_sptr&, bool internal = false);
1084 
1085 string
1086 get_pretty_representation(const function_type&, bool internal = false);
1087 
1088 string
1089 get_pretty_representation(const function_type*, bool internal = false);
1090 
1091 string
1092 get_pretty_representation(const function_type_sptr&,
1093  bool internal = false);
1094 
1095 string
1096 get_pretty_representation(const method_type&, bool internal = false);
1097 
1098 string
1099 get_pretty_representation(const method_type*, bool internal = false);
1100 
1101 string
1102 get_pretty_representation(const method_type_sptr&,
1103  bool internal = false);
1104 
1105 string
1107  const string& indent,
1108  bool one_line,
1109  bool internal,
1110  bool qualified_name = true);
1111 
1112 string
1114  const string& indent,
1115  bool one_line,
1116  bool internal,
1117  bool qualified_name = true);
1118 
1119 string
1120 get_class_or_union_flat_representation(const class_or_union_sptr& cou,
1121  const string& indent,
1122  bool one_line,
1123  bool internal,
1124  bool qualified_name = true);
1125 
1126 string
1128  const string& indent,
1129  bool one_line,
1130  bool internal,
1131  bool qualified_names);
1132 
1133 string
1135  const string& indent,
1136  bool one_line,
1137  bool internal,
1138  bool qualified_names);
1139 
1140 string
1141 get_enum_flat_representation(const enum_type_decl_sptr& enum_type,
1142  const string& indent,
1143  bool one_line,
1144  bool qualified_names);
1145 
1146 string
1148  const string& indent,
1149  bool one_line,
1150  bool internal,
1151  bool qualified_name);
1152 
1153 string
1155 
1156 var_decl_sptr
1157 get_data_member(class_or_union *, const char*);
1158 
1159 var_decl_sptr
1160 get_data_member(type_base *clazz, const char* member_name);
1161 
1162 const location&
1164 
1165 const location&
1167 
1169 debug(const type_or_decl_base* artifact);
1170 
1171 type_base*
1172 debug(const type_base* artifact);
1173 
1174 decl_base*
1175 debug(const decl_base* artifact);
1176 
1177 bool
1179 
1180 void
1181 debug_comp_stack(const environment& env);
1182 
1183 bool
1185 
1186 const decl_base*
1188 
1189 decl_base*
1191 
1192 decl_base_sptr
1193 get_type_declaration(const type_base_sptr);
1194 
1195 bool
1196 types_are_compatible(const type_base_sptr,
1197  const type_base_sptr);
1198 
1199 bool
1200 types_are_compatible(const decl_base_sptr,
1201  const decl_base_sptr);
1202 
1203 const scope_decl*
1205  const scope_decl*);
1206 
1207 const scope_decl*
1208 get_top_most_scope_under(const decl_base_sptr,
1209  const scope_decl*);
1210 
1211 const scope_decl*
1212 get_top_most_scope_under(const decl_base_sptr,
1213  const scope_decl_sptr);
1214 
1215 void
1216 fqn_to_components(const std::string&,
1217  std::list<string>&);
1218 
1219 string
1220 components_to_type_name(const std::list<string>&);
1221 
1222 type_decl_sptr
1224 
1225 type_decl_sptr
1226 lookup_basic_type(const interned_string&, const translation_unit&);
1227 
1228 type_decl_sptr
1229 lookup_basic_type(const string&, const translation_unit&);
1230 
1231 type_decl_sptr
1232 lookup_basic_type(const type_decl&, const corpus&);
1233 
1234 type_decl_sptr
1235 lookup_basic_type(const string&, const corpus&);
1236 
1237 type_decl_sptr
1238 lookup_basic_type(const interned_string&, const corpus&);
1239 
1240 type_decl_sptr
1241 lookup_basic_type_per_location(const interned_string&, const corpus&);
1242 
1243 type_decl_sptr
1244 lookup_basic_type_per_location(const string&, const corpus&);
1245 
1246 class_decl_sptr
1248 
1249 class_decl_sptr
1250 lookup_class_type(const interned_string&, const translation_unit&);
1251 
1252 class_decl_sptr
1253 lookup_class_type(const string&, const translation_unit&);
1254 
1255 class_decl_sptr
1256 lookup_class_type(const class_decl&, const corpus&);
1257 
1258 class_decl_sptr
1259 lookup_class_type(const interned_string&, const corpus&);
1260 
1261 const type_base_wptrs_type*
1262 lookup_class_types(const interned_string&, const corpus&);
1263 
1264 const type_base_wptrs_type*
1265 lookup_union_types(const interned_string&, const corpus&);
1266 
1267 bool
1268 lookup_decl_only_class_types(const interned_string&,
1269  const corpus&,
1270  type_base_wptrs_type&);
1271 
1272 const type_base_wptrs_type*
1273 lookup_class_types(const string&, const corpus&);
1274 
1275 const type_base_wptrs_type*
1276 lookup_union_types(const string&, const corpus&);
1277 
1278 class_decl_sptr
1279 lookup_class_type_per_location(const interned_string&, const corpus&);
1280 
1281 class_decl_sptr
1282 lookup_class_type_per_location(const string&, const corpus&);
1283 
1284 class_decl_sptr
1285 lookup_class_type(const string&, const corpus&);
1286 
1287 class_decl_sptr
1288 lookup_class_type_through_scopes(const std::list<string>&,
1289  const translation_unit&);
1290 
1291 union_decl_sptr
1292 lookup_union_type(const interned_string&, const translation_unit&);
1293 
1294 union_decl_sptr
1295 lookup_union_type(const interned_string&, const corpus&);
1296 
1297 union_decl_sptr
1298 lookup_union_type_per_location(const interned_string&, const corpus&);
1299 
1300 union_decl_sptr
1301 lookup_union_type_per_location(const string&, const corpus&);
1302 
1303 union_decl_sptr
1304 lookup_union_type(const string&, const corpus&);
1305 
1306 enum_type_decl_sptr
1308 
1309 enum_type_decl_sptr
1310 lookup_enum_type(const string&, const translation_unit&);
1311 
1312 enum_type_decl_sptr
1313 lookup_enum_type(const enum_type_decl&, const corpus&);
1314 
1315 enum_type_decl_sptr
1316 lookup_enum_type(const string&, const corpus&);
1317 
1318 enum_type_decl_sptr
1319 lookup_enum_type(const interned_string&, const corpus&);
1320 
1321 const type_base_wptrs_type*
1322 lookup_enum_types(const interned_string&, const corpus&);
1323 
1324 const type_base_wptrs_type*
1325 lookup_enum_types(const string&, const corpus&);
1326 
1327 enum_type_decl_sptr
1328 lookup_enum_type_per_location(const interned_string&, const corpus&);
1329 
1330 enum_type_decl_sptr
1331 lookup_enum_type_per_location(const string&, const corpus&);
1332 
1333 typedef_decl_sptr
1335 
1336 typedef_decl_sptr
1337 lookup_typedef_type(const typedef_decl&, const corpus&);
1338 
1339 typedef_decl_sptr
1340 lookup_typedef_type(const interned_string& type_name,
1341  const translation_unit& tu);
1342 
1343 typedef_decl_sptr
1344 lookup_typedef_type(const string& type_name, const translation_unit& tu);
1345 
1346 typedef_decl_sptr
1347 lookup_typedef_type(const interned_string&, const corpus&);
1348 
1349 typedef_decl_sptr
1350 lookup_typedef_type_per_location(const interned_string&, const corpus &);
1351 
1352 typedef_decl_sptr
1353 lookup_typedef_type_per_location(const string&, const corpus &);
1354 
1355 typedef_decl_sptr
1356 lookup_typedef_type(const string&, const corpus&);
1357 
1358 type_base_sptr
1359 lookup_class_or_typedef_type(const string&, const translation_unit&);
1360 
1361 type_base_sptr
1363 
1364 type_base_sptr
1365 lookup_class_or_typedef_type(const string&, const corpus&);
1366 
1367 type_base_sptr
1368 lookup_class_typedef_or_enum_type(const string&, const corpus&);
1369 
1370 qualified_type_def_sptr
1372 
1373 qualified_type_def_sptr
1374 lookup_qualified_type(const string&, const translation_unit&);
1375 
1376 qualified_type_def_sptr
1378 
1379 qualified_type_def_sptr
1380 lookup_qualified_type(const interned_string&, const corpus&);
1381 
1382 pointer_type_def_sptr
1384 
1385 pointer_type_def_sptr
1386 lookup_pointer_type(const string&, const translation_unit&);
1387 
1388 pointer_type_def_sptr
1389 lookup_pointer_type(const type_base_sptr& pointed_to_type,
1390  const translation_unit& tu);
1391 
1392 pointer_type_def_sptr
1394 
1395 pointer_type_def_sptr
1396 lookup_pointer_type(const interned_string&, const corpus&);
1397 
1398 const reference_type_def_sptr
1400 
1401 const reference_type_def_sptr
1402 lookup_reference_type(const string&, const translation_unit&);
1403 
1404 const reference_type_def_sptr
1405 lookup_reference_type(const type_base_sptr& pointed_to_type,
1406  bool lvalue_reference,
1407  const translation_unit& tu);
1408 
1409 reference_type_def_sptr
1411 
1412 reference_type_def_sptr
1413 lookup_reference_type(const interned_string&, const corpus&);
1414 
1415 array_type_def_sptr
1417 
1418 array_type_def_sptr
1419 lookup_array_type(const string&, const translation_unit&);
1420 
1421 array_type_def_sptr
1422 lookup_array_type(const array_type_def&, const corpus&);
1423 
1424 array_type_def_sptr
1425 lookup_array_type(const interned_string&, const corpus&);
1426 
1427 function_type_sptr
1428 lookup_function_type(const string&,
1429  const translation_unit&);
1430 
1431 function_type_sptr
1432 lookup_function_type(const interned_string&,
1433  const translation_unit&);
1434 
1435 function_type_sptr
1437  const translation_unit&);
1438 
1439 function_type_sptr
1440 lookup_function_type(const function_type_sptr&,
1441  const translation_unit&);
1442 
1443 function_type_sptr
1444 lookup_function_type(const function_type&, const corpus&);
1445 
1446 function_type_sptr
1447 lookup_function_type(const function_type_sptr&, const corpus&);
1448 
1449 function_type_sptr
1450 lookup_function_type(const function_type&, const corpus&);
1451 
1452 function_type_sptr
1453 lookup_function_type(const interned_string&, const corpus&);
1454 
1455 type_base_sptr
1456 lookup_type(const string&, const translation_unit&);
1457 
1458 const type_base_sptr
1459 lookup_type(const type_base_sptr, const translation_unit&);
1460 
1461 type_base_sptr
1462 lookup_type(const interned_string&, const corpus&);
1463 
1464 type_base_sptr
1465 lookup_type_per_location(const interned_string&, const corpus&);
1466 
1467 type_base_sptr
1468 lookup_type(const type_base&, const corpus&);
1469 
1470 type_base_sptr
1471 lookup_type(const type_base_sptr&, const corpus&);
1472 
1473 type_base_sptr
1474 lookup_type_through_scopes(const std::list<string>&,
1475  const translation_unit&);
1476 
1477 type_base_sptr
1478 lookup_type_through_translation_units(const string&, const corpus&);
1479 
1480 type_base_sptr
1481 lookup_type_from_translation_unit(const string& type_name,
1482  const string& tu_path,
1483  const corpus& corp);
1484 
1485 function_type_sptr
1486 lookup_or_synthesize_fn_type(const function_type_sptr&,
1487  const corpus&);
1488 
1489 type_base_sptr
1490 synthesize_type_from_translation_unit(const type_base_sptr&,
1491  translation_unit&);
1492 
1493 function_type_sptr
1495  translation_unit&);
1496 
1497 const type_base_sptr
1498 lookup_type_in_scope(const string&,
1499  const scope_decl_sptr&);
1500 
1501 const type_base_sptr
1502 lookup_type_in_scope(const std::list<string>&,
1503  const scope_decl_sptr&);
1504 
1505 const decl_base_sptr
1506 lookup_var_decl_in_scope(const string&,
1507  const scope_decl_sptr&);
1508 
1509 const decl_base_sptr
1510 lookup_var_decl_in_scope(const std::list<string>&,
1511  const scope_decl_sptr&);
1512 
1513 string
1514 demangle_cplus_mangled_name(const string&);
1515 
1516 type_base_sptr
1517 type_or_void(const type_base_sptr, const environment&);
1518 
1519 type_base_sptr
1520 canonicalize(type_base_sptr);
1521 
1522 type_base*
1523 type_has_non_canonicalized_subtype(type_base_sptr t);
1524 
1525 bool
1526 type_has_sub_type_changes(type_base_sptr t_v1,
1527  type_base_sptr t_v2);
1528 
1529 void
1530 keep_type_alive(type_base_sptr t);
1531 
1532 size_t
1533 hash_type(const type_base *t);
1534 
1535 size_t
1537 
1538 size_t
1539 hash_type_or_decl(const type_or_decl_base_sptr &);
1540 
1541 bool
1543 
1544 bool
1545 is_non_canonicalized_type(const type_base_sptr&);
1546 
1547 bool
1548 is_unique_type(const type_base_sptr&);
1549 
1550 bool
1551 is_unique_type(const type_base*);
1552 
1553 /// For a given type, return its exemplar type.
1554 ///
1555 /// For a given type, its exemplar type is either its canonical type
1556 /// or the canonical type of the definition type of a given
1557 /// declaration-only type. If the neither of those two types exist,
1558 /// then the exemplar type is the given type itself.
1559 ///
1560 /// @param type the input to consider.
1561 ///
1562 /// @return the exemplar type.
1563 type_base*
1564 get_exemplar_type(const type_base* type);
1565 
1566 bool
1567 function_decl_is_less_than(const function_decl&f, const function_decl &s);
1568 
1569 bool
1570 types_have_similar_structure(const type_base_sptr& first,
1571  const type_base_sptr& second,
1572  bool indirect_type = false);
1573 
1574 bool
1576  const type_base* second,
1577  bool indirect_type = false);
1578 
1579 string
1581  bool is_anonymous,
1582  uint64_t size);
1583 
1584 var_decl_sptr
1586  const regex::regex_t_sptr& r);
1587 
1588 var_decl_sptr
1590  const regex::regex_t_sptr& regex);
1591 } // end namespace ir
1592 
1593 using namespace abigail::ir;
1594 
1595 namespace suppr
1596 {
1598 
1599 /// Convenience typedef for a shared pointer to a @ref suppression.
1600 typedef shared_ptr<suppression_base> suppression_sptr;
1601 
1602 /// Convenience typedef for a vector of @ref suppression_sptr
1603 typedef vector<suppression_sptr> suppressions_type;
1604 
1605 } // end namespace suppr
1606 
1607 namespace symtab_reader
1608 {
1609 
1610 class symtab;
1611 /// Convenience typedef for a shared pointer to a @ref symtab
1612 typedef std::shared_ptr<symtab> symtab_sptr;
1613 
1614 } // end namespace symtab_reader
1615 
1616 void
1617 dump(const decl_base_sptr, std::ostream&);
1618 
1619 void
1620 dump(const decl_base_sptr);
1621 
1622 void
1623 dump(const type_base_sptr, std::ostream&);
1624 
1625 void
1626 dump(const type_base_sptr);
1627 
1628 void
1629 dump(const var_decl_sptr, std::ostream&);
1630 
1631 void
1632 dump(const var_decl_sptr);
1633 
1634 void
1635 dump(const translation_unit&, std::ostream&);
1636 
1637 void
1638 dump(const translation_unit&);
1639 
1640 void
1641 dump(const translation_unit_sptr, std::ostream&);
1642 
1643 void
1645 
1646 void
1648 
1649 void
1651 
1652 void
1653 dump_decl_location(const decl_base_sptr&);
1654 
1655 #ifndef ABG_ASSERT
1656 /// This is a wrapper around the 'assert' glibc call. It allows for
1657 /// its argument to have side effects, so that it keeps working when
1658 /// the code of libabigail is compiled with the NDEBUG macro defined.
1659 #define ABG_ASSERT(cond) do {({bool __abg_cond__ = bool(cond); assert(__abg_cond__); !!__abg_cond__;});} while (false)
1660 #endif
1661 
1662 } // end namespace abigail
1663 #endif // __ABG_IRFWD_H__
interned_string get_name_of_reference_to_type(const type_base &pointed_to_type, bool lvalue_reference, bool qualified, bool internal)
Get the name of the reference to a given type.
Definition: abg-ir.cc:8978
void remove_decl_from_scope(decl_base_sptr decl)
Remove a given decl from its scope.
Definition: abg-ir.cc:8420
decl_base_sptr add_decl_to_scope(decl_base_sptr decl, scope_decl *scope)
Appends a declaration to a given scope, if the declaration doesn't already belong to one and if the d...
Definition: abg-ir.cc:8396
string get_class_or_enum_flat_representation(const type_base &coe, const string &indent, bool one_line, bool internal, bool qualified_name)
Get the flat representation of an instance of enum_type_decl type.
Definition: abg-ir.cc:9759
bool is_type(const type_or_decl_base &tod)
Test whether a declaration is a type.
Definition: abg-ir.cc:10469
The abstraction of an array type.
Definition: abg-ir.h:2454
bool get_member_function_is_virtual(const function_decl &f)
Test if a given member function is virtual.
Definition: abg-ir.cc:6723
The base type of all declarations.
Definition: abg-ir.h:1524
vector< class_decl_sptr > classes_type
Convenience typedef for a vector of class_decl_sptr.
Definition: abg-fwd.h:193
string components_to_type_name(const list< string > &comps)
Turn a set of qualified name components (that name a type) into a qualified name string.
Definition: abg-ir.cc:11630
const var_decl_sptr get_first_non_anonymous_data_member(const var_decl_sptr anon_dm)
Get the first non-anonymous data member of a given anonymous data member.
Definition: abg-ir.cc:5868
The abstraction of a change between two ABI artifacts, a.k.a an artifact change.
class_decl_sptr is_compatible_with_class_type(const type_base_sptr &t)
Test if a type is a class. This function looks through typedefs.
Definition: abg-ir.cc:10701
bool is_declaration_only_class_or_union_type(const type_base *t, bool look_through_decl_only)
Test wheter a type is a declaration-only class.
Definition: abg-ir.cc:10835
vector< type_base_wptr > type_base_wptrs_type
A convenience typedef for a vector of type_base_wptr.
Definition: abg-fwd.h:143
type_base * peel_pointer_or_reference_type(const type_base *type, bool peel_qual_type)
Return the leaf underlying or pointed-to type node of a, pointer_type_def, reference_type_def or qual...
Definition: abg-ir.cc:7495
bool type_has_sub_type_changes(const type_base_sptr t_v1, const type_base_sptr t_v2)
Tests if the change of a given type effectively comes from just its sub-types. That is...
Definition: abg-ir.cc:26982
unordered_map< string, translation_unit_sptr > string_tu_map_type
Convenience typedef for a map that associates a string to a translation unit.
Definition: abg-fwd.h:140
type_decl_sptr lookup_basic_type(const interned_string &type_name, const translation_unit &tu)
Lookup a basic type from a translation unit.
Definition: abg-ir.cc:11740
const type_decl * is_type_decl(const type_or_decl_base *t)
Test whether a type is a type_decl (a builtin type).
Definition: abg-ir.cc:10553
string build_qualified_name(const scope_decl *scope, const string &name)
Build and return a qualified name from a name and its scope.
Definition: abg-ir.cc:8678
void dump(const decl_base_sptr d, std::ostream &o, const bool annotate)
Serialize a pointer to decl_base to an output stream.
Definition: abg-writer.cc:4713
Abstracts a member class template template.
Definition: abg-ir.h:4691
decl_base_sptr insert_decl_into_scope(decl_base_sptr decl, scope_decl::declarations::iterator before, scope_decl *scope)
Inserts a declaration into a given scope, before a given IR child node of the scope.
Definition: abg-ir.cc:8440
shared_ptr< suppression_base > suppression_sptr
Convenience typedef for a shared pointer to a suppression.
Definition: abg-fwd.h:1597
A type that introduces a scope.
Definition: abg-ir.h:2157
interned_string get_method_type_name(const method_type_sptr fn_type, bool internal)
Get the name of a given method type and return a copy of it.
Definition: abg-ir.cc:9162
bool is_data_member(const var_decl &v)
Test if a var_decl is a data member.
Definition: abg-ir.cc:5763
bool is_class_type(const type_or_decl_base &t)
Test whether a type is a class.
Definition: abg-ir.cc:10733
bool class_or_union_types_of_same_kind(const class_or_union *first, const class_or_union *second)
Test if two class or union types are of the same kind.
Definition: abg-ir.cc:10904
typedef_decl_sptr lookup_typedef_type(const interned_string &type_name, const translation_unit &tu)
Lookup a typedef type from a translation unit.
Definition: abg-ir.cc:11923
shared_ptr< function_type > function_type_sptr
Convenience typedef for a shared pointer on a function_type.
Definition: abg-fwd.h:205
bool is_member_function(const function_decl &f)
Test whether a function_decl is a member function.
Definition: abg-ir.cc:6450
An abstraction helper for type declarations.
Definition: abg-ir.h:1959
shared_ptr< method_type > method_type_sptr
Convenience typedef for shared pointer to method_type.
Definition: abg-fwd.h:215
type_or_decl_base * debug(const type_or_decl_base *artifact)
Emit a textual representation of an artifact to std error stream for debugging purposes.
Definition: abg-ir.cc:9967
interned_string get_function_id_or_pretty_representation(function_decl *fn)
Get the ID of a function, or, if the ID can designate several different functions, get its pretty representation.
Definition: abg-ir.cc:9134
This is the abstraction of a set of translation units (themselves seen as bundles of unitary abi arte...
Definition: abg-corpus.h:24
weak_ptr< function_type > function_type_wptr
Convenience typedef for a weak pointer on a function_type.
Definition: abg-fwd.h:213
The base class of both types and declarations.
Definition: abg-ir.h:1353
pointer_type_def_sptr lookup_pointer_type(const interned_string &type_name, const translation_unit &tu)
Lookup a pointer type from a translation unit.
Definition: abg-ir.cc:12009
A declaration that introduces a scope.
Definition: abg-ir.h:1795
const location & get_artificial_or_natural_location(const decl_base *decl)
Get the artificial location of a decl.
Definition: abg-ir.cc:9947
var_decl_sptr find_data_member_from_anonymous_data_member(const var_decl_sptr &anon_dm, const string &name)
Find a data member inside an anonymous data member.
Definition: abg-ir.cc:10312
weak_ptr< typedef_decl > typedef_decl_wptr
Convenience typedef for a weak pointer on a typedef_decl.
Definition: abg-fwd.h:167
Abstracts a reference type.
Definition: abg-ir.h:2386
The abstraction of a qualified type.
Definition: abg-ir.h:2212
const type_base * is_void_pointer_type(const type_base *t)
Test if a type is a pointer to void type.
Definition: abg-ir.cc:11096
void set_member_function_is_virtual(function_decl &f, bool is_virtual)
Set the virtual-ness of a member function.
Definition: abg-ir.cc:6761
function_type_sptr is_function_type(const type_or_decl_base_sptr &t)
Test whether a type is a function_type.
Definition: abg-ir.cc:11167
void keep_type_alive(type_base_sptr t)
Make sure that the life time of a given (smart pointer to a) type is the same as the life time of the...
Definition: abg-ir.cc:26998
The base class of templates.
Definition: abg-ir.h:3474
type_base_sptr peel_pointer_type(const type_base_sptr &type)
Return the leaf pointed-to type node of a pointer_type_def node.
Definition: abg-ir.cc:7150
This is the abstraction of the set of relevant artefacts (types, variable declarations, functions, templates, etc) bundled together into a translation unit.
Definition: abg-ir.h:671
shared_ptr< diff_context > diff_context_sptr
Convenience typedef for a shared pointer of diff_context.
Definition: abg-fwd.h:68
ssize_t get_member_function_vtable_offset(const function_decl &f)
Get the vtable offset of a member function.
Definition: abg-ir.cc:6660
A functor to hash instances of interned_string.
bool is_user_defined_type(const type_base *t)
Test if a type is user-defined.
Definition: abg-ir.cc:5629
array_type_def_sptr lookup_array_type(const interned_string &type_name, const translation_unit &tu)
Lookup an array type from a translation unit.
Definition: abg-ir.cc:12115
type_base_sptr synthesize_type_from_translation_unit(const type_base_sptr &type, translation_unit &tu)
In a translation unit, lookup a given type or synthesize it if it's a qualified type.
Definition: abg-ir.cc:14531
Abstracts the type of a class member function.
Definition: abg-ir.h:3418
shared_ptr< var_decl > var_decl_sptr
Convenience typedef for a shared pointer on a var_decl.
Definition: abg-fwd.h:246
void set_member_function_is_const(function_decl &f, bool is_const)
set the const-ness property of a member function.
Definition: abg-ir.cc:6620
string get_class_or_union_flat_representation(const class_or_union &cou, const string &indent, bool one_line, bool internal, bool qualified_names)
Get the flat representation of an instance of class_or_union type.
Definition: abg-ir.cc:9482
bool is_member_decl(const decl_base_sptr d)
Tests if a declaration is a class member.
Definition: abg-ir.cc:5567
const global_scope * get_global_scope(const decl_base &decl)
return the global scope as seen by a given declaration.
Definition: abg-ir.cc:8489
uint64_t get_absolute_data_member_offset(const var_decl &m)
Get the absolute offset of a data member.
Definition: abg-ir.cc:6355
type_decl * is_integral_type(const type_or_decl_base *t)
Test if a type is an integral type.
Definition: abg-ir.cc:10571
Abstraction of the declaration of a method.
Definition: abg-ir.h:3859
const location & get_natural_or_artificial_location(const decl_base *decl)
Get the non-artificial (natural) location of a decl.
Definition: abg-ir.cc:9928
class_or_union * is_class_or_union_type(const type_or_decl_base *t)
Test if a type is a class_or_union.
Definition: abg-ir.cc:10883
decl_base * is_decl_slow(const type_or_decl_base *t)
Test if an ABI artifact is a declaration.
Definition: abg-ir.cc:10449
shared_ptr< translation_unit > translation_unit_sptr
Convenience typedef for a shared pointer on a translation_unit type.
Definition: abg-fwd.h:134
Abstracts a class declaration.
Definition: abg-ir.h:4163
shared_ptr< typedef_decl > typedef_decl_sptr
Convenience typedef for a shared pointer on a typedef_decl.
Definition: abg-fwd.h:161
bool is_at_global_scope(const decl_base &decl)
Tests whether a given declaration is at global scope.
Definition: abg-ir.cc:10242
bool types_have_similar_structure(const type_base_sptr &first, const type_base_sptr &second, bool indirect_type)
Test if two types have similar structures, even though they are (or can be) different.
Definition: abg-ir.cc:27340
size_t hash_type(const type_base *t)
Hash an ABI artifact that is either a type.
Definition: abg-ir.cc:27102
Abstraction of a member function context relationship. This relates a member function to its parent c...
Definition: abg-ir.h:4488
Declaration of types pertaining to the interned string pool used throughout Libabigail, for performance reasons.
class_or_union * anonymous_data_member_to_class_or_union(const var_decl *d)
Get the class_or_union type of a given anonymous data member.
Definition: abg-ir.cc:6112
shared_ptr< type_composition > type_composition_sptr
Convenience typedef for shared pointer to type_composition.
Definition: abg-fwd.h:344
Abstracts a variable declaration.
Definition: abg-ir.h:2943
enum_type_decl_sptr is_compatible_with_enum_type(const type_base_sptr &t)
Test if a type is an enum. This function looks through typedefs.
Definition: abg-ir.cc:10650
Abstract a class template.
Definition: abg-ir.h:3764
bool get_member_function_is_dtor(const function_decl &f)
Test whether a member function is a destructor.
Definition: abg-ir.cc:6536
string build_internal_underlying_enum_type_name(const string &base_name, bool is_anonymous, uint64_t size)
Build the internal name of the underlying type of an enum.
Definition: abg-ir.cc:27619
Abstract a member function template.
Definition: abg-ir.h:4638
Abstracts a type template parameter.
Definition: abg-ir.h:3555
var_decl * is_var_decl(const type_or_decl_base *tod)
Tests if a declaration is a variable declaration.
Definition: abg-ir.cc:11368
weak_ptr< var_decl > var_decl_wptr
Convenience typedef for a weak pointer on a var_decl.
Definition: abg-fwd.h:252
union_decl_sptr lookup_union_type(const interned_string &type_name, const translation_unit &tu)
Lookup a union type from a translation unit.
Definition: abg-ir.cc:11817
weak_ptr< decl_base > decl_base_wptr
Convenience typedef for a weak pointer to a decl_base.
Definition: abg-fwd.h:178
bool is_non_canonicalized_type(const type_base *t)
Test if a given type is allowed to be non canonicalized.
Definition: abg-ir.cc:27125
bool odr_is_relevant(const type_or_decl_base &artifact)
By looking at the language of the TU a given ABI artifact belongs to, test if the ONE Definition Rule...
Definition: abg-ir.cc:10083
decl_base_sptr strip_useless_const_qualification(const qualified_type_def_sptr t)
Strip qualification from a qualified type, when it makes sense.
Definition: abg-ir.cc:6948
type_base_sptr canonicalize(type_base_sptr t)
Compute the canonical type of a given type.
Definition: abg-ir.cc:15326
type_decl_sptr lookup_basic_type_per_location(const interned_string &loc, const corpus &corp)
Lookup a type_decl type from a given corpus, by its location.
Definition: abg-ir.cc:12976
weak_ptr< type_base > type_base_wptr
Convenience typedef for a weak pointer on a type_base.
Definition: abg-fwd.h:129
bool is_data_member_of_anonymous_class_or_union(const var_decl &d)
Test if a var_decl is a data member belonging to an anonymous type.
Definition: abg-ir.cc:6072
type_base_sptr lookup_type_from_translation_unit(const string &type_name, const string &tu_path, const corpus &corp)
Lookup a type from a given translation unit present in a give corpus.
Definition: abg-ir.cc:12880
const var_decl_sptr get_next_data_member(const class_or_union *klass, const var_decl_sptr &data_member)
In the context of a given class or union, this function returns the data member that is located after...
Definition: abg-ir.cc:5892
const type_base_sptr lookup_type(const interned_string &fqn, const translation_unit &tu)
Lookup a type in a translation unit.
Definition: abg-ir.cc:12186
type_base_sptr lookup_class_typedef_or_enum_type(const string &qualified_name, const corpus &corp)
Look into a corpus to find a class, typedef or enum type which has a given qualified name...
Definition: abg-ir.cc:13508
bool is_unique_type(const type_base_sptr &t)
Test if a type is unique in the entire environment.
Definition: abg-ir.cc:27161
Abstracts a declaration for an enum type.
Definition: abg-ir.h:2685
typedef_decl_sptr is_typedef(const type_or_decl_base_sptr t)
Test whether a type is a typedef.
Definition: abg-ir.cc:10611
type_base * get_exemplar_type(const type_base *type)
For a given type, return its exemplar type.
Definition: abg-ir.cc:27196
type_base_sptr lookup_type_through_translation_units(const string &qn, const corpus &abi_corpus)
Lookup a type definition in all the translation units of a given ABI corpus.
Definition: abg-ir.cc:12855
uint64_t get_data_member_offset(const var_decl &m)
Get the offset of a data member.
Definition: abg-ir.cc:6266
string get_enum_flat_representation(const enum_type_decl &enum_type, const string &indent, bool one_line, bool qualified_names)
Get the flat representation of an instance of enum_type_decl type.
Definition: abg-ir.cc:9638
Toplevel namespace for libabigail.
void set_member_function_is_dtor(function_decl &f, bool d)
Set the destructor-ness property of a member function.
Definition: abg-ir.cc:6564
type_base * type_has_non_canonicalized_subtype(type_base_sptr t)
Test if a type has sub-types that are non-canonicalized.
Definition: abg-ir.cc:26960
shared_ptr< scope_decl > scope_decl_sptr
Convenience typedef for a shared pointer on a scope_decl.
Definition: abg-fwd.h:258
void set_member_function_is_ctor(function_decl &f, bool c)
Setter for the is_ctor property of the member function.
Definition: abg-ir.cc:6507
shared_ptr< function_decl > function_decl_sptr
Convenience typedef for a shared pointer on a function_decl.
Definition: abg-fwd.h:263
decl_base * is_decl(const type_or_decl_base *d)
Test if an ABI artifact is a declaration.
Definition: abg-ir.cc:10409
const enum_type_decl * is_enum_type(const type_or_decl_base *d)
Test if a decl is an enum_type_decl.
Definition: abg-ir.cc:10683
shared_ptr< template_tparameter > template_tparameter_sptr
Convenience typedef for a shared_ptr to template_tparameter.
Definition: abg-fwd.h:325
Abstracts a union type declaration.
Definition: abg-ir.h:4418
size_t hash_type_or_decl(const type_or_decl_base *tod)
Hash an ABI artifact that is either a type or a decl.
Definition: abg-ir.cc:27023
shared_ptr< function_tdecl > function_tdecl_sptr
Convenience typedef for a shared pointer on a function_tdecl.
Definition: abg-fwd.h:292
class_or_union * is_at_class_scope(const decl_base_sptr decl)
Tests whether a given decl is at class scope.
Definition: abg-ir.cc:10269
shared_ptr< environment > environment_sptr
Convenience typedef for a shared pointer to an environment.
Definition: abg-fwd.h:112
enum_type_decl_sptr lookup_enum_type(const interned_string &type_name, const translation_unit &tu)
Lookup an enum type from a translation unit.
Definition: abg-ir.cc:11885
Abstraction for a function declaration.
Definition: abg-ir.h:3046
typedef_decl_sptr clone_typedef(const typedef_decl_sptr &t)
Clone a typedef type.
Definition: abg-ir.cc:7574
qualified_type_def_sptr clone_qualified_type(const qualified_type_def_sptr &t)
Clone a qualifiend type.
Definition: abg-ir.cc:7599
bool is_template_parm_composition_type(const shared_ptr< decl_base > decl)
Tests whether a decl is a template parameter composition type.
Definition: abg-ir.cc:11405
string get_debug_representation(const type_or_decl_base *artifact)
Get the textual representation of a type for debugging purposes.
Definition: abg-ir.cc:9787
vector< class_or_union_sptr > classes_or_unions_type
Convenience typedef for a vector of class_or_union_sptr.
Definition: abg-fwd.h:196
enum_type_decl_sptr lookup_enum_type_per_location(const interned_string &loc, const corpus &corp)
Look up an enum_type_decl from a given corpus, by its location.
Definition: abg-ir.cc:13351
type_base_sptr lookup_class_or_typedef_type(const string &qualified_name, const corpus &corp)
Look into a corpus to find a class, union or typedef type which has a given qualified name...
Definition: abg-ir.cc:13483
The context of the diff. This type holds various bits of information that is going to be used through...
The base type of class_decl and union_decl.
Definition: abg-ir.h:3961
const decl_base * get_type_declaration(const type_base *t)
Get the declaration for a given type.
Definition: abg-ir.cc:10102
const type_base * peel_qualified_type(const type_base *type)
Return the leaf underlying type of a qualified type.
Definition: abg-ir.cc:7297
The source location of a token.
Definition: abg-ir.h:298
const scope_decl * get_top_most_scope_under(const decl_base *decl, const scope_decl *scope)
Return the a scope S containing a given declaration and that is right under a given scope P...
Definition: abg-ir.cc:8533
The base of an entity of the intermediate representation that is to be traversed. ...
Definition: abg-ir.h:461
weak_ptr< class_decl > class_decl_wptr
Convenience typedef for a weak pointer on a class_decl.
Definition: abg-fwd.h:199
shared_ptr< type_or_decl_base > type_or_decl_base_sptr
A convenience typedef for a shared_ptr to type_or_decl_base.
Definition: abg-fwd.h:119
shared_ptr< type_decl > type_decl_sptr
Convenience typedef for a shared pointer on a type_decl.
Definition: abg-fwd.h:156
Abstracts non type template parameters.
Definition: abg-ir.h:3592
location get_location(const type_base_sptr &type)
Get the location of the declaration of a given type.
Definition: abg-ir.cc:8712
void set_member_is_static(decl_base &d, bool s)
Sets the static-ness property of a class member.
Definition: abg-ir.cc:25423
unordered_map< interned_string, type_base_wptrs_type, hash_interned_string > istring_type_base_wptrs_map_type
A convenience typedef for a map which key is an interned_string and which value is a vector of type_b...
Definition: abg-fwd.h:149
var_decl_sptr get_data_member(class_or_union *clazz, const char *member_name)
Get a given data member, referred to by its name, of a class type.
Definition: abg-ir.cc:9900
This is an abstraction of the set of resources necessary to manage several aspects of the internal re...
Definition: abg-ir.h:139
qualified_type_def_sptr lookup_qualified_type(const interned_string &type_name, const translation_unit &tu)
Lookup a qualified type from a translation unit.
Definition: abg-ir.cc:11963
Abstract a function template declaration.
Definition: abg-ir.h:3715
The abstraction for a data member context relationship. This relates a data member to its parent clas...
Definition: abg-ir.h:2889
bool get_next_data_member_offset(const class_or_union *klass, const var_decl_sptr &dm, uint64_t &offset)
Get the offset of the non-static data member that comes after a given one.
Definition: abg-ir.cc:6311
translation_unit * get_translation_unit(const decl_base &decl)
Return the translation unit a declaration belongs to.
Definition: abg-ir.cc:10185
weak_ptr< corpus > corpus_wptr
Convenience typedef for a weak pointer to a corpus.
Definition: abg-fwd.h:132
decl_base_sptr look_through_decl_only(const decl_base &d)
If a decl is decl-only get its definition. Otherwise, just return nil.
Definition: abg-ir.cc:11276
function_type_sptr lookup_or_synthesize_fn_type(const function_type_sptr &fn_t, const corpus &corpus)
Look into an ABI corpus for a function type.
Definition: abg-ir.cc:12905
shared_ptr< reference_type_def > reference_type_def_sptr
Convenience typedef for a shared pointer on a reference_type_def.
Definition: abg-fwd.h:229
array_type_def_sptr is_typedef_of_array(const type_base_sptr &t)
Test if a type is a typedef of an array.
Definition: abg-ir.cc:11489
std::shared_ptr< regex_t > regex_t_sptr
A convenience typedef for a shared pointer of regex_t.
Definition: abg-fwd.h:88
Base type of a direct suppression specifications types.
shared_ptr< mem_fn_context_rel > mem_fn_context_rel_sptr
A convenience typedef for a shared pointer to mem_fn_context_rel.
Definition: abg-fwd.h:276
bool get_data_member_is_laid_out(const var_decl &m)
Test whether a data member is laid out.
Definition: abg-ir.cc:6426
interned_string get_function_type_name(const function_type_sptr &fn_type, bool internal)
Get the name of a given function type and return a copy of it.
Definition: abg-ir.cc:9055
type_base * peel_qualified_or_typedef_type(const type_base *type)
Return the leaf underlying type of a qualified or typedef type.
Definition: abg-ir.cc:7342
var_decl_sptr find_first_data_member_matching_regexp(const class_or_union &t, const regex::regex_t_sptr &r)
Find the first data member of a class or union which name matches a regular expression.
Definition: abg-ir.cc:27644
vector< suppression_sptr > suppressions_type
Convenience typedef for a vector of suppression_sptr.
Definition: abg-fwd.h:1603
type_base_sptr lookup_type_per_location(const interned_string &loc, const corpus &corp)
Lookup a type from a corpus, by its location.
Definition: abg-ir.cc:13813
enum_type_decl_sptr look_through_decl_only_enum(const enum_type_decl &the_enum)
If an enum is a decl-only enum, get its definition. Otherwise, just return the initial enum...
Definition: abg-ir.cc:11257
bool is_union_type(const type_or_decl_base &t)
Test if a type is a union_decl.
Definition: abg-ir.cc:10932
var_decl_sptr find_last_data_member_matching_regexp(const class_or_union &t, const regex::regex_t_sptr &regex)
Find the last data member of a class or union which name matches a regular expression.
Definition: abg-ir.cc:27665
function_decl * is_function_decl(const type_or_decl_base *d)
Test whether a declaration is a function_decl.
Definition: abg-ir.cc:10357
void set_member_function_vtable_offset(function_decl &f, ssize_t s)
Set the vtable offset of a member function.
Definition: abg-ir.cc:6693
type_base_sptr strip_typedef(const type_base_sptr type)
Recursively returns the the underlying type of a typedef. The return type should not be a typedef of ...
Definition: abg-ir.cc:6813
type_base_sptr type_or_void(const type_base_sptr t, const environment &env)
Return either the type given in parameter if it's non-null, or the void type.
Definition: abg-ir.cc:14718
const type_base_sptr peel_array_type(const type_base_sptr &type)
Return the leaf element type of an array.
Definition: abg-ir.cc:7255
shared_ptr< dm_context_rel > dm_context_rel_sptr
A convenience typedef for a shared pointer to dm_context_rel.
Definition: abg-fwd.h:241
bool is_anonymous_type(const type_base *t)
Test whether a declaration is a type.
Definition: abg-ir.cc:10520
reference_type_def_sptr lookup_reference_type(const interned_string &type_name, const translation_unit &tu)
Lookup a reference type from a translation unit.
Definition: abg-ir.cc:12071
bool is_template_parameter(const shared_ptr< decl_base > decl)
Tests whether a decl is a template parameter.
Definition: abg-ir.cc:10343
The abstraction of a pointer type.
Definition: abg-ir.h:2323
shared_ptr< class_tdecl > class_tdecl_sptr
Convenience typedef for a shared pointer on a class_tdecl.
Definition: abg-fwd.h:287
array_type_def * is_array_type(const type_or_decl_base *type)
Test if a type is an array_type_def.
Definition: abg-ir.cc:11432
class_decl_sptr lookup_class_type_through_scopes(const list< string > &fqn, const translation_unit &tu)
Lookup a class type from a translation unit by walking its scopes in sequence and by looking into the...
Definition: abg-ir.cc:12615
const type_base_wptrs_type * lookup_enum_types(const interned_string &qualified_name, const corpus &corp)
Look into a given corpus to find the enum type*s* that have a given qualified name.
Definition: abg-ir.cc:13321
scope_decl * get_type_scope(type_base *t)
Get the scope of a given type.
Definition: abg-ir.cc:8746
shared_ptr< namespace_decl > namespace_decl_sptr
Convenience typedef for a shared pointer on namespace_decl.
Definition: abg-fwd.h:282
bool get_member_function_is_ctor(const function_decl &f)
Test whether a member function is a constructor.
Definition: abg-ir.cc:6477
bool is_anonymous_or_typedef_named(const decl_base &d)
Test if a given decl is anonymous or has a naming typedef.
Definition: abg-ir.cc:6236
The base class for the visitor type hierarchy used for traversing a translation unit.
Definition: abg-ir.h:4887
A basic type declaration that introduces no scope.
Definition: abg-ir.h:2094
const type_base_wptrs_type * lookup_union_types(const interned_string &qualified_name, const corpus &corp)
Look into a given corpus to find the union type*s* that have a given qualified name.
Definition: abg-ir.cc:13139
shared_ptr< enum_type_decl > enum_type_decl_sptr
Convenience typedef for shared pointer to a enum_type_decl.
Definition: abg-fwd.h:169
string demangle_cplus_mangled_name(const string &mangled_name)
Demangle a C++ mangled name and return the resulting string.
Definition: abg-ir.cc:14688
shared_ptr< class_decl > class_decl_sptr
Convenience typedef for a shared pointer on a class_decl.
Definition: abg-fwd.h:187
void dump_decl_location(const decl_base &d, ostream &o)
Serialize the source location of a decl to an output stream for debugging purposes.
Definition: abg-writer.cc:4853
vector< enum_type_decl_sptr > enums_type
Convenience typedef for a vector of enum_type_decl_sptr.
Definition: abg-fwd.h:175
const decl_base_sptr lookup_var_decl_in_scope(const string &fqn, const scope_decl_sptr &skope)
Lookup a var_decl in a scope.
Definition: abg-ir.cc:12270
interned_string get_type_name(const type_base_sptr &t, bool qualified, bool internal)
Get the name of a given type and return a copy of it.
Definition: abg-ir.cc:8781
qualified_type_def * is_qualified_type(const type_or_decl_base *t)
Test whether a type is a reference_type_def.
Definition: abg-ir.cc:11147
class_decl_sptr lookup_class_type(const string &fqn, const translation_unit &tu)
Lookup a class type from a translation unit.
Definition: abg-ir.cc:11780
shared_ptr< ir_traversable_base > ir_traversable_base_sptr
Convenience typedef for a shared pointer to ir_traversable_base.
Definition: abg-fwd.h:106
string get_name(const type_or_decl_base *tod, bool qualified)
Build and return a copy of the name of an ABI artifact that is either a type or a decl...
Definition: abg-ir.cc:8632
bool is_function_template_pattern(const shared_ptr< decl_base > decl)
Test whether a decl is the pattern of a function template.
Definition: abg-ir.cc:11419
bool is_template_decl(const decl_base_sptr &decl)
Tests whether a decl is a template.
Definition: abg-ir.cc:11533
bool function_decl_is_less_than(const function_decl &f, const function_decl &s)
Test if the pretty representation of a given function_decl is lexicographically less then the pretty ...
Definition: abg-ir.cc:27288
uint64_t get_var_size_in_bits(const var_decl_sptr &v)
Get the size of a given variable.
Definition: abg-ir.cc:6398
const type_base_sptr lookup_type_in_scope(const string &fqn, const scope_decl_sptr &skope)
Lookup a type in a scope.
Definition: abg-ir.cc:12253
function_type_sptr lookup_function_type(const interned_string &type_name, const translation_unit &tu)
Lookup a function type from a translation unit.
Definition: abg-ir.cc:12135
bool is_at_template_scope(const shared_ptr< decl_base > decl)
Tests whether a given decl is at template scope.
Definition: abg-ir.cc:10334
bool debug_equals(const type_or_decl_base *l, const type_or_decl_base *r)
Test if two ABI artifacts are equal.
Definition: abg-ir.cc:10018
vector< function_type_sptr > function_types_type
Convenience typedef fo a vector of function_type_sptr.
Definition: abg-fwd.h:210
This abstracts the global scope of a given translation unit.
Definition: abg-ir.h:1938
shared_ptr< non_type_tparameter > non_type_tparameter_sptr
Convenience typedef for shared pointer to non_type_template_parameter.
Definition: abg-fwd.h:317
union_decl_sptr lookup_union_type_per_location(const interned_string &loc, const corpus &corp)
Lookup a union type in a given corpus, from its location.
Definition: abg-ir.cc:11850
bool get_member_is_static(const decl_base &d)
Gets a flag saying if a class member is static or not.
Definition: abg-ir.cc:5725
The abstraction of an interned string.
class_decl_sptr lookup_class_type_per_location(const interned_string &loc, const corpus &corp)
Look up a class_decl from a given corpus by its location.
Definition: abg-ir.cc:13184
bool get_member_function_is_const(const function_decl &f)
Test whether a member function is const.
Definition: abg-ir.cc:6592
type_base_sptr peel_typedef_pointer_or_reference_type(const type_base_sptr type)
Return the leaf underlying or pointed-to type node of a typedef_decl, pointer_type_def, reference_type_def, or array_type_def node.
Definition: abg-ir.cc:7393
namespace_decl_sptr is_namespace(const decl_base_sptr &d)
Tests if a declaration is a namespace declaration.
Definition: abg-ir.cc:11387
type_base_sptr peel_reference_type(const type_base_sptr &type)
Return the leaf pointed-to type node of a reference_type_def node.
Definition: abg-ir.cc:7206
void strip_redundant_quals_from_underyling_types(const qualified_type_def_sptr &t)
Merge redundant qualifiers from a tree of qualified types.
Definition: abg-ir.cc:7071
typedef_decl_sptr lookup_typedef_type_per_location(const interned_string &loc, const corpus &corp)
Lookup a typedef_decl from a corpus, by its location.
Definition: abg-ir.cc:13446
bool member_function_has_vtable_offset(const function_decl &f)
Test if a virtual member function has a vtable offset set.
Definition: abg-ir.cc:6649
bool types_are_compatible(const type_base_sptr type1, const type_base_sptr type2)
Test if two types are equal modulo a typedef.
Definition: abg-ir.cc:10136
class_or_union * look_through_decl_only_class(class_or_union *the_class)
If a class (or union) is a decl-only class, get its definition. Otherwise, just return the initial cl...
Definition: abg-ir.cc:11227
weak_ptr< diff_context > diff_context_wptr
Convenience typedef for a weak pointer of diff_context.
Definition: abg-fwd.h:74
reference_type_def * is_reference_type(type_or_decl_base *t)
Test whether a type is a reference_type_def.
Definition: abg-ir.cc:11026
Abstracts a template template parameter.
Definition: abg-ir.h:3639
interned_string get_name_of_pointer_to_type(const type_base &pointed_to_type, bool qualified, bool internal)
Get the name of the pointer to a given type.
Definition: abg-ir.cc:8956
Abstraction of a group of corpora.
Definition: abg-corpus.h:352
array_type_def_sptr clone_array(const array_type_def_sptr &array)
Clone an array type.
Definition: abg-ir.cc:7532
bool anonymous_data_member_exists_in_class(const var_decl &anon_dm, const class_or_union &clazz)
Test if a given anonymous data member exists in a class or union.
Definition: abg-ir.cc:6196
scope_decl * is_scope_decl(decl_base *d)
Test if a declaration is a scope_decl.
Definition: abg-ir.cc:5595
bool is_anonymous_data_member(const decl_base &d)
Test if a decl is an anonymous data member.
Definition: abg-ir.cc:5954
void fqn_to_components(const string &fqn, list< string > &comps)
Decompose a fully qualified name into the list of its components.
Definition: abg-ir.cc:11604
shared_ptr< template_decl > template_decl_sptr
Convenience typedef for a shared pointer to template_decl.
Definition: abg-fwd.h:304
void set_data_member_is_laid_out(var_decl_sptr m, bool l)
Set a flag saying if a data member is laid out.
Definition: abg-ir.cc:6412
var_decl_sptr get_last_data_member(const class_or_union &klass)
Get the last data member of a class type.
Definition: abg-ir.cc:5931
const type_base_wptrs_type * lookup_class_types(const interned_string &qualified_name, const corpus &corp)
Look into a given corpus to find the class type*s* that have a given qualified name.
Definition: abg-ir.cc:13088
bool is_typedef_ptr_or_ref_to_decl_only_class_or_union_type(const type_base *t)
Test if a type is a typedef, pointer or reference to a decl-only class/union.
Definition: abg-ir.cc:11007
shared_ptr< template_parameter > template_parameter_sptr
Convenience typedef for shared pointer to template parameter.
Definition: abg-fwd.h:312
bool is_global_scope(const scope_decl &scope)
Tests whether if a given scope is the global scope.
Definition: abg-ir.cc:10214
bool has_scope(const decl_base &d)
Tests if a declaration has got a scope.
Definition: abg-ir.cc:5549
The abstraction of a typedef declaration.
Definition: abg-ir.h:2824
This abstracts a composition of types based on template type parameters. The result of the compositio...
Definition: abg-ir.h:3677
bool lookup_decl_only_class_types(const interned_string &qualified_name, const corpus &corp, type_base_wptrs_type &result)
Look into a given corpus to find the class type*s* that have a given qualified name and that are decl...
Definition: abg-ir.cc:13108
type_base_sptr clone_array_tree(const type_base_sptr t)
Clone a type tree made of an array or a typedef of array.
Definition: abg-ir.cc:7652
pointer_type_def * is_pointer_type(type_or_decl_base *t)
Test whether a type is a pointer_type_def.
Definition: abg-ir.cc:10962
shared_ptr< diff > diff_sptr
Convenience typedef for a shared_ptr for the diff class.
Definition: abg-fwd.h:76
const class_or_union_sptr data_member_has_anonymous_type(const var_decl &d)
Test if a data member has annonymous type or not.
Definition: abg-ir.cc:6140
Base class for a template parameter. Client code should use the more specialized type_template_parame...
Definition: abg-ir.h:3509
void debug_comp_stack(const environment &env)
Emit a trace of the two comparison operands stack on the standard error stream.
Definition: abg-ir.cc:10068
var_decl_sptr has_flexible_array_data_member(const class_decl &klass)
Test if the last data member of a class is an array with non-finite data member.
Definition: abg-ir.cc:10774
void set_data_member_offset(var_decl_sptr m, uint64_t o)
Set the offset of a data member into its containing class.
Definition: abg-ir.cc:6249
shared_ptr< global_scope > global_scope_sptr
Convenience typedef for shared pointer on global_scope.
Definition: abg-fwd.h:297
function_type_sptr synthesize_function_type_from_translation_unit(const function_type &fn_type, translation_unit &tu)
In a translation unit, lookup the sub-types that make up a given function type and if the sub-types a...
Definition: abg-ir.cc:14614
shared_ptr< array_type_def > array_type_def_sptr
Convenience typedef for a shared pointer on a array_type_def.
Definition: abg-fwd.h:234
shared_ptr< pointer_type_def > pointer_type_def_sptr
Convenience typedef for a shared pointer on a pointer_type_def.
Definition: abg-fwd.h:220
method_type_sptr is_method_type(const type_or_decl_base_sptr &t)
Test whether a type is a method_type.
Definition: abg-ir.cc:11197
bool base_name(string const &path, string &file_name)
Return the file name part of a file part.
The namespace of the internal representation of ABI artifacts like types and decls.
shared_ptr< type_tparameter > type_tparameter_sptr
Convenience typedef for a shared pointer to type_tparameter.
Definition: abg-fwd.h:331
type_base_sptr peel_typedef_type(const type_base_sptr &type)
Return the leaf underlying type node of a typedef_decl node.
Definition: abg-ir.cc:7096
string get_pretty_representation(diff *d)
Get a copy of the pretty representation of a diff node.
const type_base * is_void_pointer_type_equivalent(const type_base *type)
Test if a type is equivalent to a pointer to void type.
Definition: abg-ir.cc:11059
qualified_type_def_sptr is_array_of_qualified_element(const array_type_def_sptr &array)
Tests if the element of a given array is a qualified type.
Definition: abg-ir.cc:11451
weak_ptr< diff > diff_wptr
Convenience typedef for a weak_ptr for the diff class.
Definition: abg-fwd.h:82
const type_base_sptr lookup_type_through_scopes(const type_base_sptr type, const translation_unit &tu)
Lookup a type from a translation unit by walking the scopes of the translation unit in sequence and l...
Definition: abg-ir.cc:12547
Abstraction of a function type.
Definition: abg-ir.h:3322
weak_ptr< template_decl > template_decl_wptr
Convenience typedef for a weak pointer to template_decl.
Definition: abg-fwd.h:310
The entry point to manage locations.
Definition: abg-ir.h:440
bool is_member_type(const type_base_sptr &t)
Tests if a type is a class member.
Definition: abg-ir.cc:5614
The abstraction of a namespace declaration.
Definition: abg-ir.h:2183