Mercurial > hg > CbC > CbC_gcc
comparison gcc/tree-vector-builder.h @ 131:84e7813d76e9
gcc-8.2
author | mir3636 |
---|---|
date | Thu, 25 Oct 2018 07:37:49 +0900 |
parents | |
children | 1830386684a0 |
comparison
equal
deleted
inserted
replaced
111:04ced10e8804 | 131:84e7813d76e9 |
---|---|
1 /* A class for building vector tree constants. | |
2 Copyright (C) 2017-2018 Free Software Foundation, Inc. | |
3 | |
4 This file is part of GCC. | |
5 | |
6 GCC is free software; you can redistribute it and/or modify it under | |
7 the terms of the GNU General Public License as published by the Free | |
8 Software Foundation; either version 3, or (at your option) any later | |
9 version. | |
10 | |
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GCC; see the file COPYING3. If not see | |
18 <http://www.gnu.org/licenses/>. */ | |
19 | |
20 #ifndef GCC_TREE_VECTOR_BUILDER_H | |
21 #define GCC_TREE_VECTOR_BUILDER_H | |
22 | |
23 #include "vector-builder.h" | |
24 | |
25 /* This class is used to build VECTOR_CSTs from a sequence of elements. | |
26 See vector_builder for more details. */ | |
27 class tree_vector_builder : public vector_builder<tree, tree_vector_builder> | |
28 { | |
29 typedef vector_builder<tree, tree_vector_builder> parent; | |
30 friend class vector_builder<tree, tree_vector_builder>; | |
31 | |
32 public: | |
33 tree_vector_builder () : m_type (0) {} | |
34 tree_vector_builder (tree, unsigned int, unsigned int); | |
35 tree build (); | |
36 | |
37 tree type () const { return m_type; } | |
38 | |
39 void new_vector (tree, unsigned int, unsigned int); | |
40 bool new_unary_operation (tree, tree, bool); | |
41 bool new_binary_operation (tree, tree, tree, bool); | |
42 | |
43 static unsigned int binary_encoded_nelts (tree, tree); | |
44 | |
45 private: | |
46 bool equal_p (const_tree, const_tree) const; | |
47 bool allow_steps_p () const; | |
48 bool integral_p (const_tree) const; | |
49 wide_int step (const_tree, const_tree) const; | |
50 tree apply_step (tree, unsigned int, const wide_int &) const; | |
51 bool can_elide_p (const_tree) const; | |
52 void note_representative (tree *, tree); | |
53 | |
54 tree m_type; | |
55 }; | |
56 | |
57 /* Create a new builder for a vector of type TYPE. Initially encode the | |
58 value as NPATTERNS interleaved patterns with NELTS_PER_PATTERN elements | |
59 each. */ | |
60 | |
61 inline | |
62 tree_vector_builder::tree_vector_builder (tree type, unsigned int npatterns, | |
63 unsigned int nelts_per_pattern) | |
64 { | |
65 new_vector (type, npatterns, nelts_per_pattern); | |
66 } | |
67 | |
68 /* Start building a new vector of type TYPE. Initially encode the value | |
69 as NPATTERNS interleaved patterns with NELTS_PER_PATTERN elements each. */ | |
70 | |
71 inline void | |
72 tree_vector_builder::new_vector (tree type, unsigned int npatterns, | |
73 unsigned int nelts_per_pattern) | |
74 { | |
75 m_type = type; | |
76 parent::new_vector (TYPE_VECTOR_SUBPARTS (type), npatterns, | |
77 nelts_per_pattern); | |
78 } | |
79 | |
80 /* Return true if elements I1 and I2 are equal. */ | |
81 | |
82 inline bool | |
83 tree_vector_builder::equal_p (const_tree elt1, const_tree elt2) const | |
84 { | |
85 return operand_equal_p (elt1, elt2, 0); | |
86 } | |
87 | |
88 /* Return true if a stepped representation is OK. We don't allow | |
89 linear series for anything other than integers, to avoid problems | |
90 with rounding. */ | |
91 | |
92 inline bool | |
93 tree_vector_builder::allow_steps_p () const | |
94 { | |
95 return INTEGRAL_TYPE_P (TREE_TYPE (m_type)); | |
96 } | |
97 | |
98 /* Return true if ELT can be interpreted as an integer. */ | |
99 | |
100 inline bool | |
101 tree_vector_builder::integral_p (const_tree elt) const | |
102 { | |
103 return TREE_CODE (elt) == INTEGER_CST; | |
104 } | |
105 | |
106 /* Return the value of element ELT2 minus the value of element ELT1. | |
107 Both elements are known to be INTEGER_CSTs. */ | |
108 | |
109 inline wide_int | |
110 tree_vector_builder::step (const_tree elt1, const_tree elt2) const | |
111 { | |
112 return wi::to_wide (elt2) - wi::to_wide (elt1); | |
113 } | |
114 | |
115 /* Return true if we can drop element ELT, even if the retained elements | |
116 are different. Return false if this would mean losing overflow | |
117 information. */ | |
118 | |
119 inline bool | |
120 tree_vector_builder::can_elide_p (const_tree elt) const | |
121 { | |
122 return !CONSTANT_CLASS_P (elt) || !TREE_OVERFLOW (elt); | |
123 } | |
124 | |
125 /* Record that ELT2 is being elided, given that ELT1_PTR points to the last | |
126 encoded element for the containing pattern. */ | |
127 | |
128 inline void | |
129 tree_vector_builder::note_representative (tree *elt1_ptr, tree elt2) | |
130 { | |
131 if (CONSTANT_CLASS_P (elt2) && TREE_OVERFLOW (elt2)) | |
132 { | |
133 gcc_assert (operand_equal_p (*elt1_ptr, elt2, 0)); | |
134 if (!TREE_OVERFLOW (elt2)) | |
135 *elt1_ptr = elt2; | |
136 } | |
137 } | |
138 | |
139 #endif |