GCC Middle and Back End API Reference
symbolic-bit-vectors.h
Go to the documentation of this file.
1/* Symbolic vectors of bits e.g. "(buf_a[0-10) + buf_b[0-len) + (0b * 8))"
2
3 Copyright (C) 2019-2026 Free Software Foundation, Inc.
4 Contributed by David Malcolm <dmalcolm@redhat.com>.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it
9under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful, but
14WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#ifndef GCC_ANALYZER_SYMBOLIC_BIT_VECTORS_H
23#define GCC_ANALYZER_SYMBOLIC_BIT_VECTORS_H
24
28#include "analyzer/store.h"
31#include "text-art/widget.h"
32
33namespace ana {
34
35/* A concrete-sized vector of tristate bits. */
36
37using concrete_tristate_vector = std::vector<tristate>;
38
39/* A bundle of options for use when printing hexdumps. */
40
58
59namespace symbolic {
60
61class bit_vector_manager;
62
63/* An abstract base class representing the contents of a buffer of memory,
64 where the size is a symbolic_bit_size.
65
66 Consider:
67
68 | size_t len_a = strlen (a));
69 | size_t len_b = strlen (b));
70 |
71 | memcpy (buf, a, len_a);
72 | memcpy (buf + len_a, b, len_b);
73 | buf[len_a + len_b] = '\0';
74
75 and then trying to analyze the contents of "buf". If len_a is known
76 concretely as 10 bytes, but len_b is only known symbolically, the contents
77 of buf might be represented as a symbolic::bit_vector as the
78 concatenation of:
79
80 - [buffer_a's bytes [0-10)],
81 - [buffer_b's [bytes 0-'len_b')],
82 - [8 zero bits])
83
84 with size (11 + 'len_b') bytes (see selftest::test_example_strcat for
85 a worked example similar to the above).
86
87 bit_vectors can be concatenated, cropped, and repeated (with folding of
88 various identities during these operations).
89
90 The class hierarchy looks like this (using indentation to show
91 inheritance, and with kinds shown for the concrete subclasses):
92
93 symbolic::bit_vector
94 concat_bit_vector (kind::concat): the concatenation of a vector of child bit_vectors
95 conjured_bit_vector (kind::conjured): a bit vector arising from a stmt
96 cropped_bit_vector (kind::cropped): another bit_vector, cropped and offset
97 named_test_bit_vector (kind::named_test): an unfoldable bit_vector for use in selftests
98 repeated_bit_vector (kind::repeated): repeating a bit_vector some number of times
99 bit_vector_from_svalue (kind::svalue): the bit representation of an svalue on the target
100 bit_vector_from_ubc (kind::from_ubc): a range of bits within an unfoldable_bit_contents
101 uniform_bit_vector (abstract): a bit vector that is "the same bit" everywhere
102 empty_bit_vector (kind::empty): the empty bit vector
103 poisoned_bit_vector (kind::poisoned): unusable data
104 tristate_bit_vector (kind::tristate): a range of bits that are all true/false/unknown. */
105
107{
108public:
109 /* An enum for discriminating between the different concrete subclasses
110 of symbolic bit_vector. */
111 enum class kind
112 {
113 concat,
114 conjured,
115 cropped,
116 empty,
117 named_test,
118 poisoned,
119 repeated,
121 from_ubc,
123 };
124
126 get_bit_vector_manager () const { return m_bv_mgr; }
127
128 const bit_vector *
129 dyn_cast_bit_vector () const final override { return this; }
130
131 void
132 print_dump_widget_label (pretty_printer *pp) const final override;
133
134 virtual void
136
137 virtual void
139
140 const char *
141 get_any_dump_color () const override { return "bit_vector"; }
142
143 virtual bool
145 const region_model &model,
146 const symbolic::node *outer_node = nullptr) const;
147
148 virtual ~bit_vector () {}
149
150 virtual enum kind get_kind () const = 0;
151
152 virtual const concat_bit_vector *
153 dyn_cast_concat_bit_vector () const { return nullptr; }
154 virtual const conjured_bit_vector *
155 dyn_cast_conjured_bit_vector () const { return nullptr; }
156 virtual const cropped_bit_vector *
157 dyn_cast_cropped_bit_vector () const { return nullptr; }
158 virtual const empty_bit_vector *
159 dyn_cast_empty_bit_vector () const { return nullptr; }
160 virtual const uniform_bit_vector *
161 dyn_cast_uniform_bit_vector () const { return nullptr; }
162 virtual const poisoned_bit_vector *
163 dyn_cast_poisoned_bit_vector () const { return nullptr; }
164 virtual const repeated_bit_vector *
165 dyn_cast_repeated_bit_vector () const { return nullptr; }
166 virtual const bit_vector_from_svalue *
167 dyn_cast_bit_vector_from_svalue () const { return nullptr; }
168 virtual const bit_vector_from_ubc *
169 dyn_cast_bit_vector_from_ubc () const { return nullptr; }
170 virtual const tristate_bit_vector *
171 dyn_cast_tristate_bit_vector () const { return nullptr; }
172
173 bool
174 operator== (const bit_vector &other) const
175 {
176 return this == &other;
177 }
178
179 const symbolic_bit_size &
180 get_size () const { return m_size_in_bits; }
181
182 const symbolic_byte_size *
184
185 bool
187
188 bool
190
191 virtual tristate
193
194 virtual string_scan
195 scan_for_first_zero_byte (concrete_byte_offset start_byte_offset) const = 0;
196
197 void
199 const hexdump_options &hexdump_opts) const;
200
201 void
202 hexdump (const hexdump_options &hexdump_opts) const;
203
204 void
205 hexdump () const;
206
207 virtual bool
208 conjured_p () const;
209
210 /* Convenience member functions (implemented using the bit_vector_manager). */
211
214
215 const bit_vector &
216 get_cropped_bits (const symbolic_bit_range &bits_to_use) const;
217
218 const bit_vector &
219 get_cropped_bits (const concrete_bit_range &bits_to_use) const;
220
221 const bit_vector &
222 get_cropped_bytes (const symbolic_byte_range &bytes_to_use) const;
223
224 const bit_vector &
225 get_cropped_bytes (const concrete_byte_range &bytes_to_use) const;
226
227 const bit_vector &
228 get_prefix (const symbolic_bit_size &size) const;
229
230 const bit_vector &
231 get_prefix (const concrete_bit_size &size) const;
232
233 const bit_vector &
234 get_prefix (const symbolic_byte_size &size) const
235 {
236 return get_prefix (bits_from_bytes (size));
237 }
238
239 const bit_vector &
240 get_prefix (const concrete_byte_size &size) const
241 {
242 return get_prefix (bits_from_bytes (size));
243 }
244
245 const bit_vector &
246 get_suffix (const symbolic_bit_size &size) const;
247
248 const bit_vector &
249 get_suffix (const concrete_bit_size &size) const;
250
251 const bit_vector &
252 get_suffix (const symbolic_byte_size &size) const
253 {
254 return get_suffix (bits_from_bytes (size));
255 }
256
257 const bit_vector &
258 get_suffix (const concrete_byte_size &size) const
259 {
260 return get_suffix (bits_from_bytes (size));
261 }
262
263 const bit_vector &
264 get_byte_at_offset (const symbolic_byte_offset &byte_offset) const;
265
266 const bit_vector &
267 get_byte_at_offset (const concrete_byte_offset &byte_offset) const;
268
269 virtual const bit_vector *
270 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use) const;
271
272 bool
273 maybe_as_uint8 (uint8_t *out) const;
274
275 static const bit_vector *
277 const bit_vector &bv_b,
278 tree type,
279 model_merger *merger);
280
281 bool
283
285
286protected:
288 complexity c,
289 const symbolic_bit_size &size_in_bits);
290
291 std::unique_ptr<json::object>
292 make_json_obj (const char *type_name) const;
293
296};
297
298/* A sequence of bit_vectors concatenated together.
299
300 Consolidation/canonicalization:
301 - we must have at least two child bit_vectors
302 - all child bit_vectors must have non-zero size
303 - no nesting: children must not be concat_bit_vector instances
304 - consecutive children must not:
305 - be the same bit_vector
306 - be uniform_bit_vectors with the same underlying bit
307 - be repeated_bit_vectors of the same underlying
308 bit vector
309 - be a bit_vector and a repeated_bit_vector of that
310 bit_vector (in either order)
311 - be bit_vectors taken from the same UBC at
312 consecutive bit ranges. */
313
315{
316public:
317 struct key
318 {
319 key (std::vector<const bit_vector *> bit_vectors)
320 : m_bit_vectors (std::move (bit_vectors))
321 {
322 }
323
324 bool operator< (const key &other) const;
325
328
329 const symbolic_bit_size &
331
332 std::vector<const bit_vector *> m_bit_vectors;
333 };
334
335 enum kind get_kind () const final override
336 {
337 return kind::concat;
338 }
339
340 const concat_bit_vector *
341 dyn_cast_concat_bit_vector () const final override { return this; }
342
344 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
345
348 const final override;
349
350 std::vector<const bit_vector *>::const_iterator
351 begin () const { return m_bit_vectors.begin (); }
352 std::vector<const bit_vector *>::const_iterator
353 end () const { return m_bit_vectors.end (); }
354
356 const key &k);
357
358 bool implicitly_live_p (symbolic::liveness_context &) const final override;
359
360 const bit_vector *
361 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
362 const final override;
363
364 std::unique_ptr<json::object>
365 to_json () const final override;
366
367 std::unique_ptr<diagnostics::markup::node>
368 make_markup_node (markup_context &markup_ctxt) const final override;
369
371 for_each_svalue (iter_result (*cb) (const svalue &sval,
372 void *user_data),
373 void *user_data) const final override;
374private:
375 void
377
378 void
380 node_dump_state &nds) const final override;
381
382 void
384
385 std::vector<const bit_vector *> m_bit_vectors;
386};
387
388/* A defined bit_vector arising from a statement, where we want to identify a
389 particular unknown bundle of bits, so that the value can have sm-state.
390
391 Comparisons of variables that share the same conjured_bit_vector are known
392 to be equal, even if we don't know what the value is.
393
394 For example, this is used for the values of regions of known size
395 that may have been touched when calling an unknown function.
396
397 The bit_vector captures a region as well as a stmt in order to avoid falsely
398 aliasing the various bit vectors that could arise in one statement. For
399 example, after:
400 unknown_fn (&a, &b);
401 we want nodes to clobber a and b with, but we don't want to use the
402 same node, or it would falsely implicitly assume that a == b. */
403
405{
406public:
407 struct key
408 {
409 key (const gimple *stmt,
410 const region *id_reg,
411 unsigned idx)
412 : m_stmt (stmt), m_id_reg (id_reg), m_idx (idx)
413 {
414 }
415
416 bool operator< (const key &other) const;
417
420
421 const symbolic_bit_size &
423
426 unsigned m_idx;
427 };
428
429 enum kind get_kind () const final override
430 {
431 return kind::conjured;
432 }
433
434 const conjured_bit_vector *
435 dyn_cast_conjured_bit_vector () const final override { return this; }
436
438 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
439
442 const final override;
443
444 bool
445 conjured_p () const final override
446 {
447 return true;
448 }
449
451 const key &k);
452
453 std::unique_ptr<json::object>
454 to_json () const final override;
455
456 std::unique_ptr<diagnostics::markup::node>
457 make_markup_node (markup_context &markup_ctxt) const final override;
458
460 for_each_svalue (iter_result (*cb) (const svalue &sval,
461 void *user_data),
462 void *user_data) const final override;
463
464 const gimple *get_stmt () const { return m_stmt; }
465 const region *get_id_reg () const { return m_id_reg; }
466 unsigned get_idx () const { return m_idx; }
467
468private:
469 void
471
472 void
474 node_dump_state &nds) const final override;
475
476 void
477 accept_node_visitor (node_visitor &v) const final override;
478
481 unsigned m_idx;
482};
483
484/* A cropping of another bit_vector.
485 Visually, the cropped bit_vector is within the uncropped bit_vector:
486 .
487 . uncropped_bit_vector:
488 . +--------------------------+
489 . | |
490 . +--------------------------+
491 .
492 . +----+------------------+--+
493 . | |cropped_bit_vector| |
494 . +----+------------------+--+
495 . ^
496 . |
497 . crop_start_bit_offset (relative to uncropped)
498 .
499 but in terms of the object hierarchy the uncropped bit_vector is a child
500 of the cropped bit_vector.
501
502 The bounds can be concrete or symbolic.
503
504 Consolidation/canonicalization:
505 - no nesting: children must not be concat_bit_vector instances
506 - we never have a cropped_bit_vector of a uniform_bit_vector, as
507 these can be expressed simply as a uniform_bit_vector of the appropriate
508 subclass of smaller size. */
509
511{
512public:
513 struct key
514 {
515 key (const bit_vector *uncropped_bv,
516 symbolic_bit_range bits_to_use)
517 : m_uncropped_bv (uncropped_bv),
518 m_bits_to_use (bits_to_use)
519 {
520 }
521
522 bool operator< (const key &other) const;
523
524 const symbolic_bit_size &
525 get_size () const
526 {
527 return m_bits_to_use.get_size ();
528 }
529
532 };
533
534 enum kind get_kind () const final override
535 {
536 return kind::cropped;
537 }
538
539 const cropped_bit_vector *
540 dyn_cast_cropped_bit_vector () const final override { return this; }
541
543 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
544
547 const final override;
548
550 const key &k);
551
552 const bit_vector &
554
555 /* Get bit range of this bit_vector relative to the uncropped_bit_vector. */
561
562 /* Try to get byte range of this bit_vector relative to the
563 uncropped_bit_vector. */
564 bool
569
570 bool
572
573 const bit_vector *
574 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
575 const final override;
576
577 std::unique_ptr<json::object>
578 to_json () const final override;
579
580 std::unique_ptr<diagnostics::markup::node>
581 make_markup_node (markup_context &markup_ctxt) const final override;
582
584 for_each_svalue (iter_result (*cb) (const svalue &sval,
585 void *user_data),
586 void *user_data) const final override;
587
588private:
589 void
591
592 void
594 const final override;
595
596 void
598 node_dump_state &nds) const final override;
599
600 void
602
605 // relative to the uncropped bit vector
606};
607
608/* An unfoldable bit_vector with a name, for use in selftests. */
609
610#if CHECKING_P
611
612class named_test_bit_vector : public bit_vector
613{
614public:
615 enum kind get_kind () const final override
616 {
617 return kind::named_test;
618 }
619
621 get_tristate_at_offset (const symbolic_bit_offset &bit) const override;
622
625 const override;
626
627 named_test_bit_vector (bit_vector_manager &mgr,
628 const symbolic_bit_size &size_in_bits,
629 std::string label);
630
631 std::unique_ptr<json::object>
632 to_json () const final override;
633
634 std::unique_ptr<diagnostics::markup::node>
635 make_markup_node (markup_context &markup_ctxt) const final override;
636
638 for_each_svalue (iter_result (*cb) (const svalue &sval,
639 void *user_data),
640 void *user_data) const final override;
641private:
642 void
643 print_prefix_for_dump_widget_label (pretty_printer *pp) const final override;
644
645 void
647 const final override;
648
649 void
651 node_dump_state &nds) const final override;
652
653 void
654 accept_node_visitor (node_visitor &v) const final override;
655
656 std::string m_label;
657};
658
659#endif /* #if CHECKING_P */
660
661/* An abstract subclass for bit_vector subclasses that are the same
662 at every bit offset (and for which we can thus simplify away "crop",
663 "concatentate", and "repeat" operations by using a like-kinded
664 instance of the appropriate size). */
665
667{
668protected:
670 complexity c,
671 const symbolic_bit_size &size_in_bits)
672 : bit_vector (mgr, c, size_in_bits)
673 {
674 }
675};
676
677/* The empty bit vector.
678
679 This is a uniform_bit_vector because, having no elements, all its
680 elements are trivially equal. This allows more canonicalization
681 rules to be expresed purely in terms of uniform_bit_vector.
682
683 Consolidation/canonicalization:
684 - The only bit_vector with zero size should be the singleton
685 empty_bit_vector; instances of all other subclasses should have
686 non-zero size. */
687
689{
690public:
691 enum kind get_kind () const final override
692 {
693 return kind::empty;
694 }
695
696 const empty_bit_vector *
697 dyn_cast_empty_bit_vector () const final override { return this; }
698
700 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
701
704 const final override;
705
707
708 std::unique_ptr<json::object>
709 to_json () const final override;
710
711 std::unique_ptr<diagnostics::markup::node>
712 make_markup_node (markup_context &markup_ctxt) const final override;
713
715 for_each_svalue (iter_result (*cb) (const svalue &sval,
716 void *user_data),
717 void *user_data) const final override;
718private:
719 void
721
722 void
724 node_dump_state &nds) const final override;
725
726 void
728};
729
730/* A run of bits that are unusable (e.g. uninitialized data). */
731
733{
734public:
735 struct key
736 {
737 key (const symbolic_bit_size &size_in_bits,
738 enum poison_kind kind)
739 : m_size_in_bits (size_in_bits),
741 {
742 }
743
744 bool operator< (const key &other) const;
745
748 };
749
750 enum kind get_kind () const final override
751 {
752 return kind::poisoned;
753 }
754
755 const poisoned_bit_vector *
756 dyn_cast_poisoned_bit_vector () const final override { return this; }
757
759 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
760
763 const final override;
764
766 const key &k);
767
768 enum poison_kind get_poison_kind () const { return m_poison_kind; }
769
770 const bit_vector *
771 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
772 const final override;
773
774 std::unique_ptr<json::object>
775 to_json () const final override;
776
777 std::unique_ptr<diagnostics::markup::node>
778 make_markup_node (markup_context &markup_ctxt) const final override;
779
781 for_each_svalue (iter_result (*cb) (const svalue &sval,
782 void *user_data),
783 void *user_data) const final override;
784private:
785 void
787
788 void
790 const final override;
791
792 void
794 node_dump_state &nds) const final override;
795
796 void
798
800};
801
802/* Concrete bit_vector subclass: N repeated copies of an underlying
803 bit vector, where N could be symbolic.
804
805 Consolidation/canonicalization:
806 - we never have a concrete repeat count of zero or one, as these are
807 trivially foldable to empty/inner_bv
808 - no nesting: we never have a repeated_bit_vector of a inner_bv
809 - we never have a repeated_bit_vector of a uniform_bit_vector, as
810 these can be expressed simply as a uniform_bit_vector (of the appropriate
811 subclass) of larger size. */
812
814{
815public:
816 struct key
817 {
818 key (const bit_vector *inner_bv,
819 const symbolic_integer *repeat_count)
820 : m_inner_bv (inner_bv),
821 m_repeat_count (repeat_count)
822 {
823 }
824
825 bool operator< (const key &other) const;
826
827 const symbolic_bit_size &
828 get_size () const
829 {
830 return m_inner_bv->get_size () * (*m_repeat_count);
831 }
832
835 };
836
837 enum kind get_kind () const final override
838 {
839 return kind::repeated;
840 }
841
842 const repeated_bit_vector *
843 dyn_cast_repeated_bit_vector () const final override { return this; }
844
847 const final override;
848
850 const key &k);
851
852 const bit_vector &
853 get_inner_bit_vector () const { return m_inner_bv; }
854
855 const symbolic_integer &
856 get_repeat_count () const { return m_repeat_count; }
857
858 const bit_vector *
859 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
860 const final override;
861
862 std::unique_ptr<json::object>
863 to_json () const final override;
864
865 std::unique_ptr<diagnostics::markup::node>
866 make_markup_node (markup_context &markup_ctxt) const final override;
867
869 for_each_svalue (iter_result (*cb) (const svalue &sval,
870 void *user_data),
871 void *user_data) const final override;
872private:
873 void
875
876 void
878 node_dump_state &nds) const final override;
879
880 void
882
885};
886
887/* Concrete bit_vector subclass: the bit representation of an svalue
888 on the target.
889
890 Consolidation/canonicalization:
891 - no nesting: inner svalue can't be a svalue_from_bit_vector
892 - the inner svalue must not have zero size (or we'd have an empty_bit_vector)
893 - no all zeros or all ones (we fold to tristate_bit_vector for this)
894 - all other concrete 8-bit vectors are canonicalized to m_cached_bytes,
895 each of which is the bit_vector_from_svalue of an unsigned char of the
896 relevant value. */
897
899{
900public:
901 struct key
902 {
903 key (const svalue *sval)
904 : m_sval (sval)
905 {
906 }
907
908 bool operator< (const key &other) const;
909
910 const symbolic_bit_size &
912
914 };
915
916 enum kind get_kind () const final override
917 {
918 return kind::svalue;
919 }
920
922 dyn_cast_bit_vector_from_svalue () const final override { return this; }
923
924 bool
926 const region_model &model,
927 const symbolic::node *outer_node = nullptr)
928 const final override;
929
932
935 const final override;
936
938 const key &k);
939
940 const svalue &get_svalue () const { return m_sval; }
941
942 const bit_vector *
943 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
944 const final override;
945
946 bool implicitly_live_p (symbolic::liveness_context &) const final override;
947
948 std::unique_ptr<json::object>
949 to_json () const final override;
950
951 std::unique_ptr<diagnostics::markup::node>
952 make_markup_node (markup_context &markup_ctxt) const final override;
953
955 for_each_svalue (iter_result (*cb) (const svalue &sval,
956 void *user_data),
957 void *user_data) const final override;
958private:
959 void
961
962 void
964 node_dump_state &nds) const final override;
965
966 void
968
969 const bit_vector *
970 maybe_fold_crop_from_cst (const concrete_bit_range &inner_bits_to_use) const;
971
972 const bit_vector *
974 const;
975
976 const bit_vector *
978 const;
979
981};
982
983/* Concrete bit_vector subclass: a range of bits from an unfoldable_bit_contents
984 instance. These are managed by their unfoldable_bit_contents instance.
985
986 Consolidation/canonicalization:
987 - TODO. */
988
990{
991public:
992 enum kind get_kind () const final override
993 {
994 return kind::from_ubc;
995 }
996
997 const bit_vector_from_ubc *
998 dyn_cast_bit_vector_from_ubc () const final override { return this; }
999
1000 tristate
1001 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
1002
1005 const final override;
1006
1009
1012
1013 const symbolic_bit_range &
1014 get_bit_range () const { return m_bit_range; }
1015
1016 const bit_vector *
1017 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
1018 const final override;
1019
1020 std::unique_ptr<json::object>
1021 to_json () const final override;
1022
1023 std::unique_ptr<diagnostics::markup::node>
1024 make_markup_node (markup_context &markup_ctxt) const final override;
1025
1028 void *user_data),
1029 void *user_data) const final override;
1030
1032
1033 bool
1034 conjured_p () const final override;
1035
1036 private:
1037 void
1039
1040 void
1042 node_dump_state &nds) const final override;
1043
1044 void
1046
1049};
1050
1051/* A run of bits that are all 0, all 1, or all unknown. */
1052
1054{
1055public:
1056 struct key
1057 {
1058 key (const symbolic_bit_size &size_in_bits,
1059 tristate bit_value)
1060 : m_size_in_bits (size_in_bits),
1061 m_bit_value (bit_value)
1062 {
1063 }
1064
1065 bool operator< (const key &other) const;
1066
1069 };
1070
1071 enum kind get_kind () const final override
1072 {
1073 return kind::tristate;
1074 }
1075
1076 const tristate_bit_vector *
1077 dyn_cast_tristate_bit_vector () const final override { return this; }
1078
1079 tristate
1080 get_tristate_at_offset (const symbolic_bit_offset &bit) const final override;
1081
1084 const final override;
1085
1087 const key &k);
1088
1089 tristate
1090 get_bit_value () const { return m_bit_value; }
1091
1092 const bit_vector *
1093 maybe_fold_crop (const symbolic_bit_range &inner_bits_to_use)
1094 const final override;
1095
1096 std::unique_ptr<json::object>
1097 to_json () const final override;
1098
1099 std::unique_ptr<diagnostics::markup::node>
1100 make_markup_node (markup_context &markup_ctxt) const final override;
1101
1104 void *user_data),
1105 void *user_data) const final override;
1106
1107private:
1108 void
1110
1111 void
1113 const final override;
1114
1115 void
1117 node_dump_state &nds) const final override;
1118 void
1120
1122};
1123
1124/* A class with responsibility for allocating/consolidating
1125 bit_vector instances. A singleton relative to a node_manager. */
1126
1128{
1129public:
1131
1133
1134 /* bit_vector consolidation. */
1135
1136 const bit_vector &
1138
1139 const bit_vector &
1141
1142 const bit_vector &
1144 {
1145 return get_tristate_bits (num_bits, tristate (false));
1146 }
1147
1148 const bit_vector &
1150 {
1151 return get_tristate_bits (num_bits, tristate (false));
1152 }
1153
1154 const bit_vector &
1156 {
1157 return get_tristate_bits (bits_from_bytes (num_bytes), tristate (false));
1158 }
1159
1160 const bit_vector &
1162 {
1163 return get_tristate_bits (bits_from_bytes (num_bytes), tristate (false));
1164 }
1165
1166 const bit_vector &
1168 {
1169 return get_tristate_bits (num_bits, tristate (true));
1170 }
1171
1172 const bit_vector &
1174 {
1175 return get_tristate_bits (num_bits, tristate (true));
1176 }
1177
1178 const bit_vector &
1180 {
1181 return get_tristate_bits (bits_from_bytes (num_bytes), tristate (true));
1182 }
1183
1184 const bit_vector &
1186 {
1187 return get_tristate_bits (bits_from_bytes (num_bytes), tristate (true));
1188 }
1189
1190 const bit_vector &
1191 get_concat_bits (std::vector<const bit_vector *> vec_of_bit_vectors);
1192
1193 const bit_vector &
1195 const region *id_reg,
1196 const conjured_purge &p,
1197 unsigned idx);
1198
1199 const bit_vector &
1201
1202 const bit_vector &
1203 get_empty () const { return m_empty_bv; }
1204
1205 const bit_vector &
1207 {
1208 return get_tristate_bits (num_bits, tristate::unknown ());
1209 }
1210
1211 const bit_vector &
1213 {
1214 return get_tristate_bits (bits_from_bytes (num_bytes),
1216 }
1217
1218 const bit_vector &
1220 {
1221 return get_tristate_bits (num_bits, tristate::unknown ());
1222 }
1223
1224 const bit_vector &
1226 {
1227 return get_tristate_bits (bits_from_bytes (num_bytes), tristate::unknown ());
1228 }
1229
1230 // Unknown bits of unknown length
1231 const bit_vector &
1233
1234 const bit_vector &
1236 enum poison_kind kind);
1237
1238 const bit_vector &
1240 enum poison_kind kind);
1241
1242 const bit_vector &
1244 enum poison_kind kind)
1245 {
1246 return get_poisoned_bits (bits_from_bytes (num_bytes), kind);
1247 }
1248
1249 const bit_vector &
1251 {
1252 return get_poisoned_bits (num_bits, poison_kind::uninit);
1253 }
1254
1255 const bit_vector &
1257 {
1258 return get_poisoned_bits (bits_from_bytes (num_bytes),
1260 }
1261
1262 const bit_vector &
1264 {
1265 return get_poisoned_bits (bits_from_bytes (num_bytes),
1267 }
1268
1269 const bit_vector &
1270 get_cropped_bits (const bit_vector &uncropped_bv,
1271 const symbolic_bit_range &bits_to_use);
1272
1273 const bit_vector &
1274 get_cropped_bytes (const bit_vector &uncropped_bv,
1275 const symbolic_byte_range &bytes_to_use);
1276
1277 const bit_vector &
1279 const symbolic_integer &repeat_count);
1280
1281 const bit_vector &
1283 const concrete_integer &repeat_count);
1284
1285 const bit_vector &
1287
1288 const bit_vector *
1290
1291 const bit_vector &
1292 get_uint8 (uint8_t value)
1293 {
1294 gcc_assert (m_cached_bytes[value]);
1295 return *m_cached_bytes[value];
1296 }
1297
1298#if CHECKING_P
1299 const bit_vector &
1300 get_named_test_bit_vector (const symbolic_bit_size &size_in_bits,
1301 std::string label);
1302
1303 const bit_vector &
1304 get_named_test_bit_vector (const symbolic_byte_size &size_in_bytes,
1305 std::string label);
1306
1307 const bit_vector &
1308 get_named_test_bit_vector (const concrete_bit_size &size_in_bits,
1309 std::string label);
1310
1311 const bit_vector &
1312 get_named_test_bit_vector (const concrete_byte_size &size_in_bytes,
1313 std::string label);
1314#endif /* #if CHECKING_P */
1315
1316 node_manager &
1317 get_node_manager () const { return m_node_mgr; }
1318
1321 {
1322 return m_node_mgr.get_scalars ().get_bits ();
1323 }
1324
1326 get_svalue_manager () const { return m_node_mgr.get_svalue_manager (); }
1327
1328 const bit_vector &
1330 baseline_state bs);
1331
1332 const bit_vector *
1334 concrete_byte_range conc_bytes);
1335 const bit_vector *
1337
1338private:
1339 const bit_vector *
1340 maybe_fold_concat_bits (const std::vector<const bit_vector *> &vec);
1341
1342 std::vector<const bit_vector *>
1343 canonicalize_concat_bits (const std::vector<const bit_vector *> &vec);
1344
1345 const bit_vector *
1347
1348 const bit_vector *
1350 concrete_byte_range conc_bytes);
1351 const bit_vector *
1353 concrete_byte_range conc_bytes);
1354
1355 const bit_vector *
1357 const symbolic_bit_range &inner_bits_to_use);
1358
1359 const bit_vector &
1361
1362 const bit_vector *
1364 const symbolic_integer &repeat_count);
1365
1367
1368 std::map<concat_bit_vector::key,
1369 std::unique_ptr<concat_bit_vector>> m_concat_map;
1370 std::map<conjured_bit_vector::key,
1371 std::unique_ptr<conjured_bit_vector>> m_conjured_map;
1372 std::map<cropped_bit_vector::key,
1373 std::unique_ptr<cropped_bit_vector>> m_cropped_map;
1375 std::map<poisoned_bit_vector::key,
1376 std::unique_ptr<poisoned_bit_vector>> m_poisoned_map;
1377 std::map<repeated_bit_vector::key,
1378 std::unique_ptr<repeated_bit_vector>> m_repeated_map;
1380 std::unique_ptr<bit_vector_from_svalue>> m_svalue_to_bv_map;
1381 std::map<tristate_bit_vector::key,
1382 std::unique_ptr<tristate_bit_vector>> m_tristate_map;
1383
1384 std::map<baseline_key, const bit_vector &> m_baseline_map;
1385
1386#if CHECKING_P
1387 std::vector<std::unique_ptr<named_test_bit_vector>> m_named_test_bvs;
1388#endif
1389
1391};
1392
1393} // namespace ana::symbolic
1394} // namespace ana
1395
1396#endif /* GCC_ANALYZER_SYMBOLIC_BIT_VECTORS_H */
Definition symbolic-nodes.h:585
Definition region-model-manager.h:36
Definition region-model.h:289
Definition region.h:130
Definition svalue.h:82
Definition symbolic-bit-vectors.h:899
bool maybe_print_for_user(pretty_printer *pp, const region_model &model, const symbolic::node *outer_node=nullptr) const final override
const bit_vector * maybe_fold_crop_from_cst(const concrete_bit_range &inner_bits_to_use) const
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
const bit_vector * maybe_fold_crop_from_bitmask(const concrete_bit_range &inner_bits_to_use) const
std::unique_ptr< json::object > to_json() const final override
bool implicitly_live_p(symbolic::liveness_context &) const final override
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
const bit_vector_from_svalue * dyn_cast_bit_vector_from_svalue() const final override
Definition symbolic-bit-vectors.h:922
void accept_node_visitor(node_visitor &v) const final override
bit_vector_from_svalue(bit_vector_manager &mgr, const key &k)
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
const bit_vector * maybe_fold_crop_from_initial_bits(const concrete_bit_range &inner_bits_to_use) const
const svalue & get_svalue() const
Definition symbolic-bit-vectors.h:940
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:916
const svalue & m_sval
Definition symbolic-bit-vectors.h:980
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
Definition symbolic-bit-vectors.h:990
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:992
bool conjured_p() const final override
const symbolic_bit_range & get_bit_range() const
Definition symbolic-bit-vectors.h:1014
symbolic_bit_range m_bit_range
Definition symbolic-bit-vectors.h:1048
bool implicitly_live_p(symbolic::liveness_context &) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
const unfoldable_bit_contents & m_unfoldable_bit_contents
Definition symbolic-bit-vectors.h:1047
std::unique_ptr< json::object > to_json() const final override
void accept_node_visitor(node_visitor &v) const final override
const unfoldable_bit_contents & get_bit_contents() const
Definition symbolic-bit-vectors.h:1011
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
const bit_vector_from_ubc * dyn_cast_bit_vector_from_ubc() const final override
Definition symbolic-bit-vectors.h:998
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
bit_vector_from_ubc(const unfoldable_bit_contents &bc, symbolic_bit_range bit_range)
Definition symbolic-bit-vectors.h:1128
const bit_vector & get_poisoned_bytes(const symbolic_byte_size &num_bytes, enum poison_kind kind)
Definition symbolic-bit-vectors.h:1243
const bit_vector * maybe_fold_bits_for_svalue(const svalue &sval)
std::map< poisoned_bit_vector::key, std::unique_ptr< poisoned_bit_vector > > m_poisoned_map
Definition symbolic-bit-vectors.h:1376
const bit_vector & get_unknown_bits(const symbolic_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1206
const bit_vector * maybe_fold_bytes_within_constant(tree tree_cst, concrete_byte_range conc_bytes)
const bit_vector & get_all_ones(const concrete_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1185
const bit_vector * m_cached_bytes[256]
Definition symbolic-bit-vectors.h:1390
empty_bit_vector m_empty_bv
Definition symbolic-bit-vectors.h:1374
const bit_vector & get_uninitialized_bytes(const symbolic_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1256
const bit_vector & get_all_zeros(const concrete_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1161
const bit_vector & get_poisoned_bits(const symbolic_bit_size &num_bits, enum poison_kind kind)
std::map< concat_bit_vector::key, std::unique_ptr< concat_bit_vector > > m_concat_map
Definition symbolic-bit-vectors.h:1369
std::map< repeated_bit_vector::key, std::unique_ptr< repeated_bit_vector > > m_repeated_map
Definition symbolic-bit-vectors.h:1378
const bit_vector & get_tristate_bits(const symbolic_bit_size &num_bits, tristate bit_val)
std::map< tristate_bit_vector::key, std::unique_ptr< tristate_bit_vector > > m_tristate_map
Definition symbolic-bit-vectors.h:1382
const bit_vector * maybe_fold_repeated_bits(const bit_vector &inner_bits, const symbolic_integer &repeat_count)
const bit_vector * maybe_fold_cropped_bits(const bit_vector &inner_bits, const symbolic_bit_range &inner_bits_to_use)
const bit_vector & get_concat_bits(std::vector< const bit_vector * > vec_of_bit_vectors)
const bit_vector & get_bit_vector_from_svalue(const svalue &sval)
scalar_manager< concrete_bit_size > & get_bit_manager() const
Definition symbolic-bit-vectors.h:1320
const bit_vector & get_empty() const
Definition symbolic-bit-vectors.h:1203
const bit_vector & get_unknown_bits()
const bit_vector * maybe_fold_concat_bits(const std::vector< const bit_vector * > &vec)
std::vector< const bit_vector * > canonicalize_concat_bits(const std::vector< const bit_vector * > &vec)
const bit_vector & get_all_zeros(const concrete_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1149
std::map< conjured_bit_vector::key, std::unique_ptr< conjured_bit_vector > > m_conjured_map
Definition symbolic-bit-vectors.h:1371
const bit_vector & get_poisoned_bits(const concrete_bit_size &num_bits, enum poison_kind kind)
region_model_manager & get_svalue_manager() const
Definition symbolic-bit-vectors.h:1326
const bit_vector & get_baseline_bit_vector(const region &base_reg, baseline_state bs)
const bit_vector & get_all_ones(const symbolic_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1179
const bit_vector & get_all_ones(const concrete_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1173
const bit_vector * maybe_get_bit_vector_from_svalue(const svalue &sval)
const bit_vector & get_bits_for_constant(tree tree_cst)
const bit_vector * maybe_fold_bytes_within_string_cst(tree string_cst, concrete_byte_range conc_bytes)
node_manager & get_node_manager() const
Definition symbolic-bit-vectors.h:1317
bit_vector_manager(const bit_vector_manager &)=delete
std::map< bit_vector_from_svalue::key, std::unique_ptr< bit_vector_from_svalue > > m_svalue_to_bv_map
Definition symbolic-bit-vectors.h:1380
const bit_vector & get_all_zeros(const symbolic_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1155
const bit_vector * maybe_fold_bits_for_constant(tree tree_cst)
const bit_vector & get_uninitialized_bits(const symbolic_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1250
const bit_vector & get_unknown_bytes(const concrete_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1225
const bit_vector & get_all_zeros(const symbolic_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1143
const bit_vector & get_conjured_bits(const gimple *stmt, const region *id_reg, const conjured_purge &p, unsigned idx)
const bit_vector & get_all_ones(const symbolic_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1167
const bit_vector & get_unknown_bits(const concrete_bit_size &num_bits)
Definition symbolic-bit-vectors.h:1219
const bit_vector & get_unknown_bytes(const symbolic_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1212
const bit_vector & make_baseline_bit_vector(baseline_key k)
const bit_vector & get_repeated_bits(const bit_vector &inner_bv, const symbolic_integer &repeat_count)
const bit_vector & get_tristate_bits(const concrete_bit_size &num_bits, tristate bit_val)
bit_vector_manager(node_manager &node_mgr)
const bit_vector & get_cropped_bits(const bit_vector &uncropped_bv, const symbolic_bit_range &bits_to_use)
const bit_vector * maybe_fold_bytes_within_raw_data_cst(tree raw_data_cst, concrete_byte_range conc_bytes)
const bit_vector & get_repeated_bits(const bit_vector &inner_bv, const concrete_integer &repeat_count)
const bit_vector & get_uninitialized_bytes(const concrete_byte_size &num_bytes)
Definition symbolic-bit-vectors.h:1263
const bit_vector & get_cropped_bytes(const bit_vector &uncropped_bv, const symbolic_byte_range &bytes_to_use)
std::map< cropped_bit_vector::key, std::unique_ptr< cropped_bit_vector > > m_cropped_map
Definition symbolic-bit-vectors.h:1373
std::map< baseline_key, const bit_vector & > m_baseline_map
Definition symbolic-bit-vectors.h:1384
const bit_vector & get_uint8(uint8_t value)
Definition symbolic-bit-vectors.h:1292
node_manager & m_node_mgr
Definition symbolic-bit-vectors.h:1366
Definition symbolic-bit-vectors.h:107
kind
Definition symbolic-bit-vectors.h:112
@ conjured
Definition symbolic-bit-vectors.h:114
@ cropped
Definition symbolic-bit-vectors.h:115
@ from_ubc
Definition symbolic-bit-vectors.h:121
@ concat
Definition symbolic-bit-vectors.h:113
@ svalue
Definition symbolic-bit-vectors.h:120
@ repeated
Definition symbolic-bit-vectors.h:119
@ empty
Definition symbolic-bit-vectors.h:116
@ poisoned
Definition symbolic-bit-vectors.h:118
@ tristate
Definition symbolic-bit-vectors.h:122
@ named_test
Definition symbolic-bit-vectors.h:117
void hexdump(const hexdump_options &hexdump_opts) const
bool derived_from_initial_value_p() const
tristate get_tristate_at_offset(const concrete_bit_offset &bit) const
virtual ~bit_vector()
Definition symbolic-bit-vectors.h:148
virtual const cropped_bit_vector * dyn_cast_cropped_bit_vector() const
Definition symbolic-bit-vectors.h:157
const bit_vector & get_byte_at_offset(const symbolic_byte_offset &byte_offset) const
virtual const bit_vector_from_svalue * dyn_cast_bit_vector_from_svalue() const
Definition symbolic-bit-vectors.h:167
const symbolic_bit_size & m_size_in_bits
Definition symbolic-bit-vectors.h:295
virtual enum kind get_kind() const =0
const bit_vector & get_cropped_bits(const symbolic_bit_range &bits_to_use) const
bool maybe_get_irange_bitmask(irange_bitmask *out) const
bool maybe_get_concrete_size_in_bytes(concrete_byte_size *out) const
virtual const tristate_bit_vector * dyn_cast_tristate_bit_vector() const
Definition symbolic-bit-vectors.h:171
void hexdump_to_pp(pretty_printer *, const hexdump_options &hexdump_opts) const
virtual bool conjured_p() const
bool maybe_as_uint8(uint8_t *out) const
const bit_vector & get_byte_at_offset(const concrete_byte_offset &byte_offset) const
virtual void print_any_suffix_for_dump_widget_label(pretty_printer *) const
Definition symbolic-bit-vectors.h:138
const bit_vector & get_prefix(const symbolic_byte_size &size) const
Definition symbolic-bit-vectors.h:234
const symbolic_byte_size * maybe_get_size_in_bytes() const
virtual const repeated_bit_vector * dyn_cast_repeated_bit_vector() const
Definition symbolic-bit-vectors.h:165
virtual const bit_vector_from_ubc * dyn_cast_bit_vector_from_ubc() const
Definition symbolic-bit-vectors.h:169
bit_vector_manager & get_bit_vector_manager() const
Definition symbolic-bit-vectors.h:126
const symbolic_bit_size & get_size() const
Definition symbolic-bit-vectors.h:180
const bit_vector & get_cropped_bits(const concrete_bit_range &bits_to_use) const
const bit_vector & get_suffix(const symbolic_byte_size &size) const
Definition symbolic-bit-vectors.h:252
const char * get_any_dump_color() const override
Definition symbolic-bit-vectors.h:141
const bit_vector & get_cropped_bytes(const concrete_byte_range &bytes_to_use) const
virtual const uniform_bit_vector * dyn_cast_uniform_bit_vector() const
Definition symbolic-bit-vectors.h:161
const bit_vector & get_prefix(const symbolic_bit_size &size) const
bool maybe_get_concrete_size_in_bits(concrete_bit_size *out) const
const bit_vector & get_suffix(const concrete_byte_size &size) const
Definition symbolic-bit-vectors.h:258
bit_vector_manager & m_bv_mgr
Definition symbolic-bit-vectors.h:294
virtual bool maybe_print_for_user(pretty_printer *pp, const region_model &model, const symbolic::node *outer_node=nullptr) const
const bit_vector & get_prefix(const concrete_byte_size &size) const
Definition symbolic-bit-vectors.h:240
virtual const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const
const bit_vector & get_cropped_bytes(const symbolic_byte_range &bytes_to_use) const
virtual const concat_bit_vector * dyn_cast_concat_bit_vector() const
Definition symbolic-bit-vectors.h:153
virtual const conjured_bit_vector * dyn_cast_conjured_bit_vector() const
Definition symbolic-bit-vectors.h:155
const bit_vector & get_prefix(const concrete_bit_size &size) const
virtual const poisoned_bit_vector * dyn_cast_poisoned_bit_vector() const
Definition symbolic-bit-vectors.h:163
static const bit_vector * can_merge_p(const bit_vector &bv_a, const bit_vector &bv_b, tree type, model_merger *merger)
const bit_vector * dyn_cast_bit_vector() const final override
Definition symbolic-bit-vectors.h:129
const bit_vector & get_suffix(const concrete_bit_size &size) const
virtual void print_prefix_for_dump_widget_label(pretty_printer *pp) const =0
bool operator==(const bit_vector &other) const
Definition symbolic-bit-vectors.h:174
std::unique_ptr< json::object > make_json_obj(const char *type_name) const
virtual tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const
void print_dump_widget_label(pretty_printer *pp) const final override
virtual string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const =0
const bit_vector & get_suffix(const symbolic_bit_size &size) const
bit_vector(bit_vector_manager &mgr, complexity c, const symbolic_bit_size &size_in_bits)
virtual const empty_bit_vector * dyn_cast_empty_bit_vector() const
Definition symbolic-bit-vectors.h:159
Definition symbolic-bit-vectors.h:315
bool implicitly_live_p(symbolic::liveness_context &) const final override
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
std::vector< constbit_vector * >::const_iterator begin() const
Definition symbolic-bit-vectors.h:351
const concat_bit_vector * dyn_cast_concat_bit_vector() const final override
Definition symbolic-bit-vectors.h:341
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
std::vector< constbit_vector * >::const_iterator end() const
Definition symbolic-bit-vectors.h:353
std::vector< const bit_vector * > m_bit_vectors
Definition symbolic-bit-vectors.h:385
void accept_node_visitor(node_visitor &v) const final override
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
std::unique_ptr< json::object > to_json() const final override
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:335
concat_bit_vector(bit_vector_manager &mgr, const key &k)
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
Definition symbolic-bit-vectors.h:405
bool conjured_p() const final override
Definition symbolic-bit-vectors.h:445
const region * get_id_reg() const
Definition symbolic-bit-vectors.h:465
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:429
const gimple * get_stmt() const
Definition symbolic-bit-vectors.h:464
unsigned get_idx() const
Definition symbolic-bit-vectors.h:466
unsigned m_idx
Definition symbolic-bit-vectors.h:481
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
conjured_bit_vector(bit_vector_manager &mgr, const key &k)
std::unique_ptr< json::object > to_json() const final override
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
const conjured_bit_vector * dyn_cast_conjured_bit_vector() const final override
Definition symbolic-bit-vectors.h:435
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
void accept_node_visitor(node_visitor &v) const final override
const region * m_id_reg
Definition symbolic-bit-vectors.h:480
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
const gimple * m_stmt
Definition symbolic-bit-vectors.h:479
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
Definition symbolic-bit-vectors.h:511
void print_any_suffix_for_dump_widget_label(pretty_printer *pp) const final override
const bit_vector & m_uncropped_bv
Definition symbolic-bit-vectors.h:603
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
const cropped_bit_vector * dyn_cast_cropped_bit_vector() const final override
Definition symbolic-bit-vectors.h:540
symbolic_bit_range get_uncropped_bits_to_use() const
Definition symbolic-bit-vectors.h:557
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
bool implicitly_live_p(symbolic::liveness_context &) const final override
void accept_node_visitor(node_visitor &v) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
cropped_bit_vector(bit_vector_manager &mgr, const key &k)
bool get_uncropped_bytes_to_use(symbolic_byte_range *out) const
Definition symbolic-bit-vectors.h:565
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:534
const bit_vector & get_uncropped_bit_vector() const
Definition symbolic-bit-vectors.h:553
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
const symbolic_bit_offset & m_crop_start_bit_offset
Definition symbolic-bit-vectors.h:604
std::unique_ptr< json::object > to_json() const final override
Definition symbolic-bit-vectors.h:689
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
void accept_node_visitor(node_visitor &v) const final override
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
empty_bit_vector(bit_vector_manager &mgr)
std::unique_ptr< json::object > to_json() const final override
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
const empty_bit_vector * dyn_cast_empty_bit_vector() const final override
Definition symbolic-bit-vectors.h:697
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:691
Definition liveness-context.h:33
Definition symbolic-nodes.h:48
Definition symbolic-nodes.h:502
Definition symbolic-nodes.h:116
Definition symbolic-bit-vectors.h:733
poisoned_bit_vector(bit_vector_manager &mgr, const key &k)
void print_any_suffix_for_dump_widget_label(pretty_printer *pp) const final override
enum poison_kind m_poison_kind
Definition symbolic-bit-vectors.h:799
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:750
std::unique_ptr< json::object > to_json() const final override
void accept_node_visitor(node_visitor &v) const final override
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
const poisoned_bit_vector * dyn_cast_poisoned_bit_vector() const final override
Definition symbolic-bit-vectors.h:756
enum poison_kind get_poison_kind() const
Definition symbolic-bit-vectors.h:768
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
Definition symbolic-bit-vectors.h:814
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
const bit_vector & m_inner_bv
Definition symbolic-bit-vectors.h:883
const symbolic_integer & m_repeat_count
Definition symbolic-bit-vectors.h:884
void accept_node_visitor(node_visitor &v) const final override
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:837
const bit_vector & get_inner_bit_vector() const
Definition symbolic-bit-vectors.h:853
std::unique_ptr< json::object > to_json() const final override
repeated_bit_vector(bit_vector_manager &mgr, const key &k)
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
const repeated_bit_vector * dyn_cast_repeated_bit_vector() const final override
Definition symbolic-bit-vectors.h:843
const symbolic_integer & get_repeat_count() const
Definition symbolic-bit-vectors.h:856
Definition symbolic-scalars.h:660
Definition symbolic-bit-vectors.h:1054
enum kind get_kind() const final override
Definition symbolic-bit-vectors.h:1071
void print_any_suffix_for_dump_widget_label(pretty_printer *pp) const final override
tristate get_bit_value() const
Definition symbolic-bit-vectors.h:1090
std::unique_ptr< diagnostics::markup::node > make_markup_node(markup_context &markup_ctxt) const final override
tristate m_bit_value
Definition symbolic-bit-vectors.h:1121
void accept_node_visitor(node_visitor &v) const final override
const tristate_bit_vector * dyn_cast_tristate_bit_vector() const final override
Definition symbolic-bit-vectors.h:1077
iter_result for_each_svalue(iter_result(*cb)(const svalue &sval, void *user_data), void *user_data) const final override
tristate get_tristate_at_offset(const symbolic_bit_offset &bit) const final override
const bit_vector * maybe_fold_crop(const symbolic_bit_range &inner_bits_to_use) const final override
void add_dump_widget_children(text_art::tree_widget &, node_dump_state &nds) const final override
void print_prefix_for_dump_widget_label(pretty_printer *pp) const final override
string_scan scan_for_first_zero_byte(concrete_byte_offset start_byte_offset) const final override
std::unique_ptr< json::object > to_json() const final override
tristate_bit_vector(bit_vector_manager &mgr, const key &k)
Definition symbolic-bit-contents.h:476
Definition symbolic-bit-vectors.h:667
uniform_bit_vector(bit_vector_manager &mgr, complexity c, const symbolic_bit_size &size_in_bits)
Definition symbolic-bit-vectors.h:669
Definition symbolic-nodes.h:468
Definition type.h:29
Definition value-range.h:152
Definition pretty-print.h:241
Definition tree-widget.h:32
Definition tristate.h:26
static tristate unknown()
Definition tristate.h:36
union tree_node * tree
Definition coretypes.h:97
void final(rtx_insn *first, FILE *file, int optimize_p)
Definition final.cc:2004
bool operator<(const pattern_pos &e1, const pattern_pos &e2)
Definition genrecog.cc:3942
Definition common.h:74
Definition access-diagram.h:30
symbolic::scalar< integer_with_unit< units::bit > > symbolic_bit_size
Definition symbolic-scalars.h:194
integer_with_unit< units::bit > concrete_bit_offset
Definition integer-with-unit.h:329
@ stmt
Definition checker-event.h:38
symbolic::range< integer_with_unit< units::bit > > symbolic_bit_range
Definition common.h:124
concrete::range< integer_with_unit< units::byte > > concrete_byte_range
Definition concrete-ranges.h:118
symbolic::scalar< integer_with_unit< units::byte > > symbolic_byte_size
Definition symbolic-scalars.h:197
symbolic::scalar< integer > symbolic_integer
Definition symbolic-scalars.h:191
bool maybe_bytes_from_bits(concrete_bit_range bits, concrete_byte_range *out)
concrete::range< integer_with_unit< units::bit > > concrete_bit_range
Definition concrete-ranges.h:117
integer_with_unit< units::bit > concrete_bit_size
Definition integer-with-unit.h:328
std::vector< tristate > concrete_tristate_vector
Definition symbolic-bit-vectors.h:37
poison_kind
Definition common.h:520
@ uninit
Definition common.h:522
@ other
Definition common.h:535
iter_result
Definition common.h:563
concrete_bit_range bits_from_bytes(concrete_byte_range bytes)
Definition concrete-ranges.h:121
symbolic::range< integer_with_unit< units::byte > > symbolic_byte_range
Definition common.h:125
integer_with_unit< units::byte > concrete_byte_offset
Definition integer-with-unit.h:331
integer concrete_integer
Definition integer.h:276
baseline_state
Definition common.h:546
symbolic::scalar< integer_with_unit< units::byte > > symbolic_byte_offset
Definition symbolic-scalars.h:196
integer_with_unit< units::byte > concrete_byte_size
Definition integer-with-unit.h:330
symbolic::scalar< integer_with_unit< units::bit > > symbolic_bit_offset
Definition symbolic-scalars.h:193
Definition custom-sarif-properties/state-graphs.h:33
Definition cfghooks.h:26
Definition analyzer-logging.h:28
Definition store.h:398
Definition complexity.h:31
Definition symbolic-bit-vectors.h:42
concrete_byte_size m_bytes_per_line
Definition symbolic-bit-vectors.h:56
bool m_show_ascii
Definition symbolic-bit-vectors.h:55
bool m_show_headings
Definition symbolic-bit-vectors.h:52
hexdump_options()
Definition symbolic-bit-vectors.h:43
bool m_show_hex
Definition symbolic-bit-vectors.h:54
bool m_show_binary
Definition symbolic-bit-vectors.h:53
Definition region-model.h:1295
Definition string-scan.h:41
Definition symbolic-nodes.h:561
Definition symbolic-bit-vectors.h:902
const svalue * m_sval
Definition symbolic-bit-vectors.h:913
key(const svalue *sval)
Definition symbolic-bit-vectors.h:903
const symbolic_bit_size & get_size(scalar_manager< concrete_bit_size > &bit_mgr) const
Definition symbolic-bit-vectors.h:318
bool operator<(const key &other) const
std::vector< const bit_vector * > m_bit_vectors
Definition symbolic-bit-vectors.h:332
const symbolic_bit_size & get_size(scalar_manager< concrete_bit_size > &bit_mgr) const
key(std::vector< const bit_vector * > bit_vectors)
Definition symbolic-bit-vectors.h:319
Definition symbolic-bit-vectors.h:408
const gimple * m_stmt
Definition symbolic-bit-vectors.h:424
key(const gimple *stmt, const region *id_reg, unsigned idx)
Definition symbolic-bit-vectors.h:409
const region * m_id_reg
Definition symbolic-bit-vectors.h:425
const symbolic_bit_size & get_size(scalar_manager< concrete_bit_size > &bit_mgr) const
unsigned m_idx
Definition symbolic-bit-vectors.h:426
Definition symbolic-bit-vectors.h:514
key(const bit_vector *uncropped_bv, symbolic_bit_range bits_to_use)
Definition symbolic-bit-vectors.h:515
symbolic_bit_range m_bits_to_use
Definition symbolic-bit-vectors.h:531
const symbolic_bit_size & get_size() const
Definition symbolic-bit-vectors.h:525
const bit_vector * m_uncropped_bv
Definition symbolic-bit-vectors.h:530
Definition symbolic-nodes.h:88
Definition symbolic-nodes.h:276
Definition symbolic-bit-vectors.h:736
const symbolic_bit_size & m_size_in_bits
Definition symbolic-bit-vectors.h:746
key(const symbolic_bit_size &size_in_bits, enum poison_kind kind)
Definition symbolic-bit-vectors.h:737
enum poison_kind m_poison_kind
Definition symbolic-bit-vectors.h:747
Definition symbolic-bit-vectors.h:817
const symbolic_bit_size & get_size() const
Definition symbolic-bit-vectors.h:828
key(const bit_vector *inner_bv, const symbolic_integer *repeat_count)
Definition symbolic-bit-vectors.h:818
const symbolic_integer * m_repeat_count
Definition symbolic-bit-vectors.h:834
const bit_vector * m_inner_bv
Definition symbolic-bit-vectors.h:833
Definition symbolic-bit-vectors.h:1057
const symbolic_bit_size & m_size_in_bits
Definition symbolic-bit-vectors.h:1067
tristate m_bit_value
Definition symbolic-bit-vectors.h:1068
key(const symbolic_bit_size &size_in_bits, tristate bit_value)
Definition symbolic-bit-vectors.h:1058
Definition gimple.h:225
Definition ira-emit.cc:158
Definition vec.h:450
#define gcc_assert(EXPR)
Definition system.h:772
#define true
Definition system.h:845
#define false
Definition system.h:846
tree size_in_bytes(const_tree t)
Definition tree.h:5560