bindgen/ir/analysis/
has_float.rs

1//! Determining which types has float.
2
3use super::{generate_dependencies, ConstrainResult, MonotoneFramework};
4use crate::ir::comp::Field;
5use crate::ir::comp::FieldMethods;
6use crate::ir::context::{BindgenContext, ItemId};
7use crate::ir::traversal::EdgeKind;
8use crate::ir::ty::TypeKind;
9use crate::{HashMap, HashSet};
10
11/// An analysis that finds for each IR item whether it has float or not.
12///
13/// We use the monotone constraint function `has_float`,
14/// defined as follows:
15///
16/// * If T is float or complex float, T trivially has.
17/// * If T is a type alias, a templated alias or an indirection to another type,
18///   it has float if the type T refers to has.
19/// * If T is a compound type, it has float if any of base memter or field
20///   has.
21/// * If T is an instantiation of an abstract template definition, T has
22///   float if any of the template arguments or template definition
23///   has.
24#[derive(Debug, Clone)]
25pub(crate) struct HasFloat<'ctx> {
26    ctx: &'ctx BindgenContext,
27
28    // The incremental result of this analysis's computation. Everything in this
29    // set has float.
30    has_float: HashSet<ItemId>,
31
32    // Dependencies saying that if a key ItemId has been inserted into the
33    // `has_float` set, then each of the ids in Vec<ItemId> need to be
34    // considered again.
35    //
36    // This is a subset of the natural IR graph with reversed edges, where we
37    // only include the edges from the IR graph that can affect whether a type
38    // has float or not.
39    dependencies: HashMap<ItemId, Vec<ItemId>>,
40}
41
42impl HasFloat<'_> {
43    fn consider_edge(kind: EdgeKind) -> bool {
44        match kind {
45            EdgeKind::BaseMember |
46            EdgeKind::Field |
47            EdgeKind::TypeReference |
48            EdgeKind::VarType |
49            EdgeKind::TemplateArgument |
50            EdgeKind::TemplateDeclaration |
51            EdgeKind::TemplateParameterDefinition => true,
52
53            EdgeKind::Constructor |
54            EdgeKind::Destructor |
55            EdgeKind::FunctionReturn |
56            EdgeKind::FunctionParameter |
57            EdgeKind::InnerType |
58            EdgeKind::InnerVar |
59            EdgeKind::Method => false,
60            EdgeKind::Generic => false,
61        }
62    }
63
64    fn insert<Id: Into<ItemId>>(&mut self, id: Id) -> ConstrainResult {
65        let id = id.into();
66        trace!("inserting {id:?} into the has_float set");
67
68        let was_not_already_in_set = self.has_float.insert(id);
69        assert!(
70            was_not_already_in_set,
71            "We shouldn't try and insert {id:?} twice because if it was \
72             already in the set, `constrain` should have exited early."
73        );
74
75        ConstrainResult::Changed
76    }
77}
78
79impl<'ctx> MonotoneFramework for HasFloat<'ctx> {
80    type Node = ItemId;
81    type Extra = &'ctx BindgenContext;
82    type Output = HashSet<ItemId>;
83
84    fn new(ctx: &'ctx BindgenContext) -> HasFloat<'ctx> {
85        let has_float = HashSet::default();
86        let dependencies = generate_dependencies(ctx, Self::consider_edge);
87
88        HasFloat {
89            ctx,
90            has_float,
91            dependencies,
92        }
93    }
94
95    fn initial_worklist(&self) -> Vec<ItemId> {
96        self.ctx.allowlisted_items().iter().copied().collect()
97    }
98
99    fn constrain(&mut self, id: ItemId) -> ConstrainResult {
100        trace!("constrain: {id:?}");
101
102        if self.has_float.contains(&id) {
103            trace!("    already know it do not have float");
104            return ConstrainResult::Same;
105        }
106
107        let item = self.ctx.resolve_item(id);
108        let Some(ty) = item.as_type() else {
109            trace!("    not a type; ignoring");
110            return ConstrainResult::Same;
111        };
112
113        match *ty.kind() {
114            TypeKind::Void |
115            TypeKind::NullPtr |
116            TypeKind::Int(..) |
117            TypeKind::Function(..) |
118            TypeKind::Enum(..) |
119            TypeKind::Reference(..) |
120            TypeKind::TypeParam |
121            TypeKind::Opaque |
122            TypeKind::Pointer(..) |
123            TypeKind::UnresolvedTypeRef(..) |
124            TypeKind::ObjCInterface(..) |
125            TypeKind::ObjCId |
126            TypeKind::ObjCSel => {
127                trace!("    simple type that do not have float");
128                ConstrainResult::Same
129            }
130
131            TypeKind::Float(..) | TypeKind::Complex(..) => {
132                trace!("    float type has float");
133                self.insert(id)
134            }
135
136            TypeKind::Array(t, _) => {
137                if self.has_float.contains(&t.into()) {
138                    trace!(
139                        "    Array with type T that has float also has float"
140                    );
141                    return self.insert(id);
142                }
143                trace!("    Array with type T that do not have float also do not have float");
144                ConstrainResult::Same
145            }
146            TypeKind::Vector(t, _) => {
147                if self.has_float.contains(&t.into()) {
148                    trace!(
149                        "    Vector with type T that has float also has float"
150                    );
151                    return self.insert(id);
152                }
153                trace!("    Vector with type T that do not have float also do not have float");
154                ConstrainResult::Same
155            }
156
157            TypeKind::ResolvedTypeRef(t) |
158            TypeKind::TemplateAlias(t, _) |
159            TypeKind::Alias(t) |
160            TypeKind::BlockPointer(t) => {
161                if self.has_float.contains(&t.into()) {
162                    trace!(
163                        "    aliases and type refs to T which have float \
164                         also have float"
165                    );
166                    self.insert(id)
167                } else {
168                    trace!("    aliases and type refs to T which do not have float \
169                            also do not have floaarrayt");
170                    ConstrainResult::Same
171                }
172            }
173
174            TypeKind::Comp(ref info) => {
175                let bases_have = info
176                    .base_members()
177                    .iter()
178                    .any(|base| self.has_float.contains(&base.ty.into()));
179                if bases_have {
180                    trace!("    bases have float, so we also have");
181                    return self.insert(id);
182                }
183                let fields_have = info.fields().iter().any(|f| match *f {
184                    Field::DataMember(ref data) => {
185                        self.has_float.contains(&data.ty().into())
186                    }
187                    Field::Bitfields(ref bfu) => bfu
188                        .bitfields()
189                        .iter()
190                        .any(|b| self.has_float.contains(&b.ty().into())),
191                });
192                if fields_have {
193                    trace!("    fields have float, so we also have");
194                    return self.insert(id);
195                }
196
197                trace!("    comp doesn't have float");
198                ConstrainResult::Same
199            }
200
201            TypeKind::TemplateInstantiation(ref template) => {
202                let args_have = template
203                    .template_arguments()
204                    .iter()
205                    .any(|arg| self.has_float.contains(&arg.into()));
206                if args_have {
207                    trace!(
208                        "    template args have float, so \
209                         instantiation also has float"
210                    );
211                    return self.insert(id);
212                }
213
214                let def_has = self
215                    .has_float
216                    .contains(&template.template_definition().into());
217                if def_has {
218                    trace!(
219                        "    template definition has float, so \
220                         instantiation also has"
221                    );
222                    return self.insert(id);
223                }
224
225                trace!("    template instantiation do not have float");
226                ConstrainResult::Same
227            }
228        }
229    }
230
231    fn each_depending_on<F>(&self, id: ItemId, mut f: F)
232    where
233        F: FnMut(ItemId),
234    {
235        if let Some(edges) = self.dependencies.get(&id) {
236            for item in edges {
237                trace!("enqueue {item:?} into worklist");
238                f(*item);
239            }
240        }
241    }
242}
243
244impl<'ctx> From<HasFloat<'ctx>> for HashSet<ItemId> {
245    fn from(analysis: HasFloat<'ctx>) -> Self {
246        analysis.has_float
247    }
248}
bindgen/ir/analysis/has_float.rs

bindgen/ir/analysis/
has_float.rs
