MimIR 0.1
MimIR is my Intermediate Representation
Loading...
Searching...
No Matches
def.cpp
Go to the documentation of this file.
1#include "mim/def.h"
2
3#include <algorithm>
4
5#include <absl/container/fixed_array.h>
6#include <fe/assert.h>
7
8#include "mim/world.h"
9
10#include "mim/util/hash.h"
11
12using namespace std::literals;
13
14namespace mim {
15
16template void Sets<const Var>::dot();
17template void Sets<Def>::dot();
18
19/*
20 * constructors
21 */
22
23Def::Def(World* world, Node node, const Def* type, Defs ops, flags_t flags)
24 : world_(world)
25 , flags_(flags)
26 , node_(node)
27 , mut_(false)
28 , external_(false)
29 , dep_(node == Node::Hole ? unsigned(Dep::Hole)
30 : node == Node::Proxy ? unsigned(Dep::Proxy)
31 : node == Node::Var ? (Dep::Var | Dep::Mut)
32 : 0)
33 , num_ops_(ops.size())
34 , type_(type) {
35 if (node == Node::Univ) {
36 gid_ = world->next_gid();
38 } else if (auto var = isa<Var>()) {
39 assert(flags_ == 0); // if we ever need flags here, we need to hash that
40 auto& world = type->world();
41 gid_ = world.next_gid();
42 vars_ = world.vars().insert(type->local_vars(), var);
43 muts_ = type->local_muts();
44 dep_ |= type->dep_;
45 auto op = ops[0];
46 ops_ptr()[0] = op;
47 hash_ = hash_begin(node_t(Node::Var));
48 hash_ = hash_combine(hash_, type->gid());
49 hash_ = hash_combine(hash_, op->gid());
50 } else {
51 hash_ = hash_begin(u8(node));
52 hash_ = hash_combine(hash_, flags_);
53
54 if (type) {
55 world = &type->world();
56 dep_ |= type->dep_;
57 vars_ = type->local_vars();
58 muts_ = type->local_muts();
59 hash_ = hash_combine(hash_, type->gid());
60 } else {
61 world = &ops[0]->world();
62 }
63
64 auto vars = &world->vars();
65 auto muts = &world->muts();
66 auto ptr = ops_ptr();
67 gid_ = world->next_gid();
68
69 for (size_t i = 0, e = ops.size(); i != e; ++i) {
70 auto op = ops[i];
71 ptr[i] = op;
72 dep_ |= op->dep_;
73 vars_ = vars->merge(vars_, op->local_vars());
74 muts_ = muts->merge(muts_, op->local_muts());
75 hash_ = hash_combine(hash_, op->gid());
76 }
77 }
78}
79
80Def::Def(Node n, const Def* type, Defs ops, flags_t flags)
81 : Def(nullptr, n, type, ops, flags) {}
82
83Def::Def(Node node, const Def* type, size_t num_ops, flags_t flags)
84 : flags_(flags)
85 , node_(node)
86 , mut_(true)
87 , external_(false)
88 , dep_(Dep::Mut | (node == Node::Hole ? Dep::Hole : Dep::None))
89 , num_ops_(num_ops)
90 , type_(type) {
91 gid_ = world().next_gid();
92 hash_ = mim::hash(gid());
93 var_ = nullptr;
94 std::fill_n(ops_ptr(), num_ops, nullptr);
95}
96
97Nat::Nat(World& world)
98 : Def(Node, world.type(), Defs{}, 0) {}
99
100UMax::UMax(World& world, Defs ops)
101 : Def(Node, world.univ(), ops, 0) {}
102
103// clang-format off
104
105/*
106 * rebuild
107 */
108
109const Def* Hole ::rebuild_(World&, const Def*, Defs ) const { fe::unreachable(); }
110const Def* Global ::rebuild_(World&, const Def*, Defs ) const { fe::unreachable(); }
111const Def* Idx ::rebuild_(World& w, const Def* , Defs ) const { return w.type_idx(); }
112const Def* Nat ::rebuild_(World& w, const Def* , Defs ) const { return w.type_nat(); }
113const Def* Univ ::rebuild_(World& w, const Def* , Defs ) const { return w.univ(); }
114const Def* App ::rebuild_(World& w, const Def* , Defs o) const { return w.app(o[0], o[1]); }
115const Def* Arr ::rebuild_(World& w, const Def* , Defs o) const { return w.arr(o[0], o[1]); }
116const Def* Extract::rebuild_(World& w, const Def* , Defs o) const { return w.extract(o[0], o[1]); }
117const Def* Inj ::rebuild_(World& w, const Def* t, Defs o) const { return w.inj(t, o[0])->set(dbg()); }
118const Def* Insert ::rebuild_(World& w, const Def* , Defs o) const { return w.insert(o[0], o[1], o[2]); }
119const Def* Lam ::rebuild_(World& w, const Def* t, Defs o) const { return w.lam(t->as<Pi>(), o[0], o[1]); }
120const Def* Lit ::rebuild_(World& w, const Def* t, Defs ) const { return w.lit(t, get()); }
121const Def* Merge ::rebuild_(World& w, const Def* t, Defs o) const { return w.merge(t, o); }
122const Def* Pack ::rebuild_(World& w, const Def* t, Defs o) const { return w.pack(t->arity(), o[0]); }
123const Def* Pi ::rebuild_(World& w, const Def* , Defs o) const { return w.pi(o[0], o[1], is_implicit()); }
124const Def* Proxy ::rebuild_(World& w, const Def* t, Defs o) const { return w.proxy(t, o, pass(), tag()); }
125const Def* Sigma ::rebuild_(World& w, const Def* , Defs o) const { return w.sigma(o); }
126const Def* Split ::rebuild_(World& w, const Def* t, Defs o) const { return w.split(t, o[0]); }
127const Def* Match ::rebuild_(World& w, const Def* , Defs o) const { return w.match(o); }
128const Def* Tuple ::rebuild_(World& w, const Def* t, Defs o) const { return w.tuple(t, o); }
129const Def* Type ::rebuild_(World& w, const Def* , Defs o) const { return w.type(o[0]); }
130const Def* UInc ::rebuild_(World& w, const Def* , Defs o) const { return w.uinc(o[0], offset()); }
131const Def* UMax ::rebuild_(World& w, const Def* , Defs o) const { return w.umax(o); }
132const Def* Uniq ::rebuild_(World& w, const Def* , Defs o) const { return w.uniq(o[0]); }
133const Def* Var ::rebuild_(World& w, const Def* t, Defs o) const { return w.var(t, o[0]->as_mut()); }
134
135const Def* Axm ::rebuild_(World& w, const Def* t, Defs ) const {
136 if (&w != &world()) return w.axm(normalizer(), curry(), trip(), t, plugin(), tag(), sub())->set(dbg());
138 return this;
139}
140
141template<bool up> const Def* TExt <up>::rebuild_(World& w, const Def* t, Defs ) const { return w.ext <up>(t)->set(dbg()); }
142template<bool up> const Def* TBound<up>::rebuild_(World& w, const Def* , Defs o) const { return w.bound<up>(o)->set(dbg()); }
143
144/*
145 * stub
146 */
147
148Arr* Arr ::stub_(World& w, const Def* t) { return w.mut_arr (t); }
149Global* Global::stub_(World& w, const Def* t) { return w.global (t, is_mutable()); }
150Hole* Hole ::stub_(World& w, const Def* t) { return w.mut_hole (t); }
151Lam* Lam ::stub_(World& w, const Def* t) { return w.mut_lam (t->as<Pi>()); }
152Pack* Pack ::stub_(World& w, const Def* t) { return w.mut_pack (t); }
153Pi* Pi ::stub_(World& w, const Def* t) { return w.mut_pi (t, is_implicit()); }
154Sigma* Sigma ::stub_(World& w, const Def* t) { return w.mut_sigma(t, num_ops()); }
155
156/*
157 * instantiate templates
158 */
159
160#ifndef DOXYGEN
161template const Def* TExt<false> ::rebuild_(World&, const Def*, Defs) const;
162template const Def* TExt<true > ::rebuild_(World&, const Def*, Defs) const;
163template const Def* TBound<false>::rebuild_(World&, const Def*, Defs) const;
164template const Def* TBound<true >::rebuild_(World&, const Def*, Defs) const;
165#endif
166
167// clang-format on
168
169/*
170 * immutabilize
171 */
172
174 if (auto v = has_var()) {
175 for (auto op : deps())
176 if (op->free_vars().contains(v)) return false;
177 }
178 for (auto op : deps()) {
179 for (auto mut : op->local_muts())
180 if (mut == this) return false; // recursion
181 }
182 return true;
183}
184
186 if (is_immutabilizable()) return world().pi(dom(), codom());
187 return nullptr;
188}
189
191 if (is_immutabilizable()) return static_cast<const Sigma*>(world().sigma(ops()));
192 return nullptr;
193}
194
196 auto& w = world();
197 if (is_immutabilizable()) return w.arr(shape(), body());
198
199 if (auto n = Lit::isa(shape()); n && *n < w.flags().scalarize_threshold)
200 return w.sigma(DefVec(*n, [&](size_t i) { return reduce(w.lit_idx(*n, i)); }));
201
202 return nullptr;
203}
204
206 auto& w = world();
207 if (is_immutabilizable()) return w.pack(shape(), body());
208
209 if (auto n = Lit::isa(shape()); n && *n < w.flags().scalarize_threshold)
210 return w.tuple(DefVec(*n, [&](size_t i) { return reduce(w.lit_idx(*n, i)); }));
212 return nullptr;
214
215/*
216 * reduce
217 */
218
219Defs Def::reduce_(const Def* arg) const {
220 if (auto var = has_var()) return world().reduce(var, arg);
221 return {ops().begin() + reduction_offset(), num_ops() - reduction_offset()};
222}
223
224const Def* Def::refine(size_t i, const Def* new_op) const {
225 auto new_ops = absl::FixedArray<const Def*>(num_ops());
226 for (size_t j = 0, e = num_ops(); j != e; ++j) new_ops[j] = i == j ? new_op : op(j);
227 return rebuild(type(), new_ops);
228}
229
230/*
231 * Def - set
232 */
233
235 assert(ops.size() == num_ops());
236 for (size_t i = 0, e = num_ops(); i != e; ++i) set(i, ops[i]);
237 return this;
238}
239
240Def* Def::set(size_t i, const Def* def) {
241#ifdef MIM_ENABLE_CHECKS
242 if (world().watchpoints().contains(gid())) fe::breakpoint();
243#endif
244 invalidate();
245 def = check(i, def);
246 assert(def && !op(i) && curr_op_++ == i);
247 ops_ptr()[i] = def;
248
249 if (i + 1 == num_ops()) { // set last op, so check kind
250 if (auto t = check()->zonk(); t != type()) type_ = t;
251 }
252
253 return this;
254}
255
256Def* Def::set_type(const Def* type) {
257 invalidate();
258 assert(curr_op_ == 0);
259 type_ = type;
260 return this;
261}
262
264 invalidate();
265#ifndef NDEBUG
266 curr_op_ = 0;
267#endif
268 std::ranges::fill(ops_ptr(), ops_ptr() + num_ops(), nullptr);
269 return this;
270}
271
272bool Def::is_set() const {
273 if (num_ops() == 0) return true;
274 bool result = ops().back();
275 assert((!result || std::ranges::all_of(ops().rsubspan(1), [](auto op) { return op; }))
276 && "the last operand is set but others in front of it aren't");
277 return result;
278}
279
280/*
281 * free_vars
282 */
283
285 if (auto mut = isa_mut()) return Muts(mut);
286 return muts_;
287}
288
290 if (auto mut = isa_mut()) return mut->free_vars();
291
292 auto& vars = world().vars();
293 auto fvs = local_vars();
294 for (auto mut : local_muts()) fvs = vars.merge(fvs, mut->free_vars());
295
296 return fvs;
297}
298
299Vars Def::local_vars() const { return mut_ ? Vars() : vars_; }
300
302 if (mark_ == 0) {
303 // fixed-point iteration to recompute free vars:
304 // (run - 1) identifies the previous iteration; so make sure to offset run by 2 for the first iteration
305 auto& w = world();
306 w.next_run();
307 for (bool todo = true, cyclic = false; todo;) {
308 todo = false;
309 free_vars(todo, cyclic, w.next_run());
310 if (!cyclic) break; // triggers either immediately or never
311 }
312 }
313
314 return vars_;
315}
316
317Vars Def::free_vars(bool& todo, bool& cyclic, uint32_t run) {
318 assert(isa_mut());
319 // Recursively recompute free vars. If
320 // * mark_ == 0: invalid - need to recompute
321 // * mark_ == run - 1: Previous iteration - need to recompute
322 // * mark_ == run: We are running in cycles within the *current* iteration of our fixed-point loop
323 // * all other values for mark_: valid!
324 if (mark_ != 0 && mark_ != run - 1) return cyclic |= mark_ == run, vars_;
325 mark_ = run;
326
327 auto fvs0 = vars_;
328 auto fvs = fvs0;
329 auto& w = world();
330 auto& muts = w.muts();
331 auto& vars = w.vars();
332
333 for (auto op : deps()) {
334 fvs = vars.merge(fvs, op->local_vars());
335
336 for (auto mut : op->local_muts()) {
337 mut->muts_ = muts.insert(mut->muts_, this); // register "this" as user of local_mut
338 fvs = vars.merge(fvs, mut->free_vars(todo, cyclic, run));
339 }
340 }
341
342 if (auto var = has_var()) fvs = vars.erase(fvs, var); // FV(λx.e) = FV(e) \ {x}
343
344 todo |= fvs0 != fvs;
345 return vars_ = fvs;
346}
347
348void Def::invalidate() {
349 if (mark_ != 0) {
350 mark_ = 0;
351 // if (vars_) { // only necessary, if the cached free vars are non-empty
352 for (auto mut : users()) mut->invalidate();
353 vars_ = Vars();
354 // }
355 muts_ = Muts();
356 }
357}
358
359bool Def::is_closed() const {
360 if (local_vars().empty() && local_muts().empty()) return true;
361#ifdef MIM_ENABLE_CHECKS
362 assert(!is_external() || free_vars().empty());
363#endif
364 return free_vars().empty();
365}
366
367bool Def::is_open() const {
368 if (!local_vars().empty()) return true;
369 return !free_vars().empty();
370}
371
372/*
373 * Def - misc
374 */
375
376Sym Def::sym(const char* s) const { return world().sym(s); }
377Sym Def::sym(std::string_view s) const { return world().sym(s); }
378Sym Def::sym(std::string s) const { return world().sym(std::move(s)); }
379
380World& Def::world() const noexcept {
381 for (auto def = this;; def = def->type()) {
382 if (def->isa<Univ>()) return *def->world_;
383 if (auto type = def->isa<Type>()) return *type->level()->type()->as<Univ>()->world_;
384 }
385}
386
387const Def* Def::unfold_type() const {
388 if (!type_) {
389 auto& w = world();
390 if (auto t = isa<Type>()) return w.type(w.uinc(t->level()));
391 assert(isa<Univ>());
392 return nullptr;
393 }
394
395 return type_;
396}
397
398std::string_view Def::node_name() const {
399 switch (node()) {
400#define CODE(name, _, __) \
401 case Node::name: return #name;
403#undef CODE
404 default: fe::unreachable();
405 }
406}
407
408Defs Def::deps() const noexcept {
409 if (isa<Type>() || isa<Univ>()) return Defs();
410 assert(type());
411 return Defs(ops_ptr() - 1, (is_set() ? num_ops_ : 0) + 1);
412}
413
414u32 Def::judge() const noexcept {
415 switch (node()) {
416#define CODE(n, _, j) \
417 case Node::n: return u32(j);
419#undef CODE
420 default: fe::unreachable();
421 }
422}
423
424bool Def::is_term() const {
425 if (auto t = type()) {
426 if (auto u = t->type()) {
427 if (auto type = u->isa<Type>()) {
428 if (auto level = Lit::isa(type->level())) return *level == 0;
429 }
430 }
431 }
432 return false;
433}
434
435#ifndef NDEBUG
436const Def* Def::debug_prefix(std::string prefix) const { return dbg_.set(world().sym(prefix + sym().str())), this; }
437const Def* Def::debug_suffix(std::string suffix) const { return dbg_.set(world().sym(sym().str() + suffix)), this; }
438#endif
439
440// clang-format off
441
442const Def* Def::var() {
443 if (var_) return var_;
444 auto& w = world();
445
446 if (w.is_frozen()) return nullptr;
447 if (auto lam = isa<Lam >()) return w.var(lam ->dom(), lam);
448 if (auto pi = isa<Pi >()) return w.var(pi ->dom(), pi);
449 if (auto sig = isa<Sigma>()) return w.var(sig, sig);
450 if (auto arr = isa<Arr >()) return w.var(w.type_idx(arr ->shape()), arr ); // TODO shapes like (2, 3)
451 if (auto pack = isa<Pack >()) return w.var(w.type_idx(pack->shape()), pack); // TODO shapes like (2, 3)
452 if (isa<Bound >()) return w.var(this, this);
453 if (isa<Hole >()) return nullptr;
454 if (isa<Global>()) return nullptr;
455 fe::unreachable();
456}
457
458const Def* Def::arity() const {
459 if (auto sigma = isa<Sigma>()) return world().lit_nat(sigma->num_ops());
460 if (auto arr = isa<Arr >()) return arr->shape();
461 if (auto t = type()) return t->arity();
462 return world().lit_nat_1();
463}
464
465std::optional<nat_t> Def::isa_lit_arity() const {
466 if (auto sigma = isa<Sigma>()) return sigma->num_ops();
467 if (auto arr = isa<Arr >()) return Lit::isa(arr->shape());
468 if (auto t = type()) return t->isa_lit_arity();
469 return 1;
470}
471
472// clang-format on
473
474bool Def::equal(const Def* other) const {
475 if (isa<Univ>() || this->isa_mut() || other->isa_mut()) return this == other;
476
477 bool result = this->node() == other->node() && this->flags() == other->flags()
478 && this->num_ops() == other->num_ops() && this->type() == other->type();
479
480 for (size_t i = 0, e = num_ops(); result && i != e; ++i) result &= this->op(i) == other->op(i);
481
482 return result;
483}
484
485void Def::make_external() { return world().make_external(this); }
486void Def::make_internal() { return world().make_internal(this); }
487
488std::string Def::unique_name() const { return sym().str() + "_"s + std::to_string(gid()); }
489
491 if (auto a = isa_lit_arity(); a && *a < world().flags().scalarize_threshold) return *a;
492 return 1;
493}
494
495const Def* Def::proj(nat_t a, nat_t i) const {
496 World& w = world();
497
498 if (auto arr = isa<Arr>()) {
499 if (arr->arity()->isa<Top>()) return arr->body();
500 return arr->reduce(w.lit_idx(a, i));
501 } else if (auto pack = isa<Pack>()) {
502 if (pack->arity()->isa<Top>()) return pack->body();
503 assert(!w.is_frozen() && "TODO");
504 return pack->reduce(w.lit_idx(a, i));
505 }
506
507 if (a == 1) {
508 if (!type()) return this;
509 if (!isa_mut<Sigma>() && !type()->isa_mut<Sigma>()) return this;
510 }
511
512 if (isa<Tuple>() || isa<Sigma>()) return op(i);
513 if (w.is_frozen()) return nullptr;
514
515 return w.extract(this, a, i);
516}
517
518/*
519 * Idx
520 */
521
522const Def* Idx::isa(const Def* def) {
523 if (auto app = def->isa<App>()) {
524 if (app->callee()->isa<Idx>()) return app->arg();
525 }
526
527 return nullptr;
528}
529
530std::optional<nat_t> Idx::isa_lit(const Def* def) {
531 if (auto size = Idx::isa(def))
532 if (auto l = Lit::isa(size)) return l;
533 return {};
534}
535
536std::optional<nat_t> Idx::size2bitwidth(const Def* size) {
537 if (size->isa<Top>()) return 64;
538 if (auto s = Lit::isa(size)) return size2bitwidth(*s);
539 return {};
540}
541
542/*
543 * Global
544 */
545
546const App* Global::type() const { return Def::type()->as<App>(); }
547const Def* Global::alloced_type() const { return type()->arg(0); }
548
549} // namespace mim
friend class World
Definition lam.h:246
const Def * arg() const
Definition lam.h:230
const Def * shape() const final
Definition tuple.h:110
friend class World
Definition tuple.h:145
const Def * immutabilize() final
Tries to make an immutable from a mutable.
Definition def.cpp:195
const Def * reduce(const Def *arg) const
Definition tuple.h:128
tag_t tag() const
Definition axm.h:55
u8 trip() const
Definition axm.h:38
friend class World
Definition axm.h:136
NormalizeFn normalizer() const
Definition axm.h:36
sub_t sub() const
Definition axm.h:56
plugin_t plugin() const
Definition axm.h:54
u8 curry() const
Definition axm.h:37
static bool alpha(const Def *d1, const Def *d2)
Definition check.h:66
Base class for all Defs.
Definition def.h:203
bool is_set() const
Yields true if empty or the last op is set.
Definition def.cpp:272
const Def * proj(nat_t a, nat_t i) const
Similar to World::extract while assuming an arity of a, but also works on Sigmas and Arrays.
Definition def.cpp:495
constexpr Node node() const noexcept
Definition def.h:226
Def * set(size_t i, const Def *)
Successively set from left to right.
Definition def.cpp:240
void make_internal()
Definition def.cpp:486
T * as_mut() const
Asserts that this is a mutable, casts constness away and performs a static_cast to T.
Definition def.h:442
Defs deps() const noexcept
Definition def.cpp:408
nat_t num_tprojs() const
As above but yields 1, if Flags::scalarize_threshold is exceeded.
Definition def.cpp:490
const Def * zonk() const
If Holes have been filled, reconstruct the program without them.
Definition check.cpp:43
World & world() const noexcept
Definition def.cpp:380
virtual const Def * check()
After all Def::ops have ben Def::set, this method will be invoked to check the type of this mutable.
Definition def.h:530
const Def * refine(size_t i, const Def *new_op) const
Definition def.cpp:224
Def * set_type(const Def *)
Update type.
Definition def.cpp:256
std::string_view node_name() const
Definition def.cpp:398
constexpr auto ops() const noexcept
Definition def.h:266
Vars local_vars() const
Vars reachable by following immutable deps().
Definition def.cpp:299
void make_external()
Definition def.cpp:485
constexpr flags_t flags() const noexcept
Definition def.h:221
Dbg dbg_
Definition def.h:586
T * isa_mut() const
If this is mutable, it will cast constness away and perform a dynamic_cast to T.
Definition def.h:434
auto vars() noexcept
Definition def.h:384
bool is_term() const
Definition def.cpp:424
const Def * debug_prefix(std::string) const
Definition def.cpp:436
const Def * op(size_t i) const noexcept
Definition def.h:269
bool is_immutabilizable()
Definition def.cpp:173
const Def * var(nat_t a, nat_t i) noexcept
Definition def.h:384
bool is_external() const
Definition def.h:419
const Def * unfold_type() const
Yields the type of this Def and builds a new Type (UInc n) if necessary.
Definition def.cpp:387
bool is_open() const
Has free_vars()?
Definition def.cpp:367
friend class World
Definition def.h:615
Muts local_muts() const
Mutables reachable by following immutable deps(); mut->local_muts() is by definition the set { mut }...
Definition def.cpp:284
const Def * debug_suffix(std::string) const
Definition def.cpp:437
const Def * type() const noexcept
Yields the "raw" type of this Def (maybe nullptr).
Definition def.h:247
auto vars(F f) noexcept
Definition def.h:384
const Def * rebuild(World &w, const Def *type, Defs ops) const
Def::rebuilds this Def while using new_op as substitute for its i'th Def::op.
Definition def.h:496
const Def * var()
Not necessarily a Var: E.g., if the return type is [], this will yield ().
Definition def.cpp:442
virtual constexpr size_t reduction_offset() const noexcept
First Def::op that needs to be dealt with during reduction; e.g.
Definition def.h:516
Sym sym() const
Definition def.h:455
std::optional< nat_t > isa_lit_arity() const
Definition def.cpp:465
flags_t flags_
Definition def.h:593
constexpr u32 gid() const noexcept
Global id - unique number for this Def.
Definition def.h:222
const Def * arity() const
Definition def.cpp:458
Def * unset()
Unsets all Def::ops; works even, if not set at all or partially.
Definition def.cpp:263
std::string unique_name() const
name + "_" + Def::gid
Definition def.cpp:488
Muts users()
Set of mutables where this mutable is locally referenced.
Definition def.h:412
bool is_closed() const
Has no free_vars()?
Definition def.cpp:359
Vars free_vars() const
Compute a global solution by transitively following mutables as well.
Definition def.cpp:289
Dbg dbg() const
Definition def.h:453
u32 judge() const noexcept
Definition def.cpp:414
const Var * has_var()
Only returns not nullptr, if Var of this mutable has ever been created.
Definition def.h:388
constexpr size_t num_ops() const noexcept
Definition def.h:270
const Def * rebuild_(World &, const Def *, Defs) const final
Definition def.cpp:116
friend class World
Definition tuple.h:211
const Def * alloced_type() const
Definition def.cpp:547
friend class World
Definition def.h:869
bool is_mutable() const
Definition def.h:855
const App * type() const
Definition def.cpp:546
Global * stub_(World &, const Def *) final
Definition def.cpp:149
This node is a hole in the IR that is inferred by its context later on.
Definition check.h:10
friend class World
Definition check.h:46
static constexpr nat_t size2bitwidth(nat_t n)
Definition def.h:795
static const Def * isa(const Def *def)
Checks if def is a Idx s and returns s or nullptr otherwise.
Definition def.cpp:522
friend class World
Definition def.h:805
static std::optional< nat_t > isa_lit(const Def *def)
Definition def.cpp:530
friend class World
Definition lattice.h:83
friend class World
Definition tuple.h:238
A function.
Definition lam.h:106
friend class World
Definition lam.h:196
static std::optional< T > isa(const Def *def)
Definition def.h:733
friend class World
Definition def.h:746
friend class World
Definition lattice.h:129
friend class World
Definition lattice.h:60
friend class World
Definition def.h:759
const Def * immutabilize() final
Tries to make an immutable from a mutable.
Definition def.cpp:205
friend class World
Definition tuple.h:188
const Def * shape() const final
Definition tuple.cpp:48
const Def * reduce(const Def *arg) const
Definition tuple.h:177
A dependent function type.
Definition lam.h:11
Pi(const Def *type, const Def *dom, const Def *codom, bool implicit)
Constructor for an immutable Pi.
Definition lam.h:14
bool is_implicit() const
Definition lam.h:23
const Def * dom() const
Definition lam.h:32
friend class World
Definition lam.h:101
const Def * codom() const
Definition lam.h:33
const Pi * immutabilize() final
Tries to make an immutable from a mutable.
Definition def.cpp:185
Def(World *, Node, const Def *type, Defs ops, flags_t flags)
Constructor for an immutable Def.
Definition def.cpp:23
friend class World
Definition def.h:827
u32 pass() const
IPass::index within PassMan.
Definition def.h:818
u32 tag() const
Definition def.h:819
const Def * body() const
Definition tuple.h:86
Def(World *, Node, const Def *type, Defs ops, flags_t flags)
Constructor for an immutable Def.
Definition def.cpp:23
constexpr bool empty() const noexcept
Is empty?
Definition sets.h:235
void dot()
Definition sets.h:551
const TExt< Up > * set(Loc l) const
Definition def.h:155
friend class World
Definition tuple.h:57
const Def * immutabilize() final
Tries to make an immutable from a mutable.
Definition def.cpp:190
friend class World
Definition lattice.h:105
friend class World
Definition lattice.h:44
const Def * rebuild_(World &, const Def *, Defs) const final
Definition def.cpp:142
Extremum. Either Top (Up) or Bottom.
Definition lattice.h:140
const Def * rebuild_(World &, const Def *, Defs) const final
Definition def.cpp:141
friend class World
Definition lattice.h:153
friend class World
Definition tuple.h:74
friend class World
Definition def.h:708
friend class World
Definition def.h:687
level_t offset() const
Definition def.h:679
friend class World
Definition def.h:665
friend class World
Definition lattice.h:185
friend class World
Definition def.h:652
friend class World
Definition def.h:638
The World represents the whole program and manages creation of MimIR nodes (Defs).
Definition world.h:33
void make_external(Def *)
Definition world.cpp:88
const Def * sigma(Defs ops)
Definition world.cpp:272
const Pi * pi(const Def *dom, const Def *codom, bool implicit=false)
Definition world.h:255
Flags & flags()
Retrieve compile Flags.
Definition world.cpp:72
u32 next_gid()
Definition world.h:91
Sym sym(std::string_view)
Definition world.cpp:75
void make_internal(Def *)
Definition world.cpp:95
const Lit * lit_nat(nat_t a)
Definition world.h:388
auto & vars()
Definition world.h:508
Defs reduce(const Var *var, const Def *arg)
Yields the new body of [mut->var() -> arg]mut.
Definition world.cpp:667
const Lit * lit_nat_1()
Definition world.h:390
#define MIM_NODE(m)
Definition def.h:17
Definition ast.h:14
View< const Def * > Defs
Definition def.h:49
u64 nat_t
Definition types.h:43
Vector< const Def * > DefVec
Definition def.h:50
Dep
Tracks a dependency to certain Defs transitively through the Def::deps() up to but excliding mutables...
Definition def.h:97
@ None
Definition def.h:98
@ Mut
Definition def.h:99
u64 flags_t
Definition types.h:45
uint64_t scalarize_threshold
Definition flags.h:13
u8 node_t
Definition types.h:44
constexpr size_t hash_combine(size_t seed, T v) noexcept
Definition hash.h:58
Sets< Def >::Set Muts
Definition def.h:59
TExt< true > Top
Definition lattice.h:159
constexpr decltype(auto) get(Span< T, N > span) noexcept
Definition span.h:107
consteval size_t hash_begin() noexcept
Definition hash.h:71
constexpr size_t hash(size_t h) noexcept
Definition hash.h:32
Sets< const Var >::Set Vars
Definition def.h:68
uint32_t u32
Definition types.h:34
uint8_t u8
Definition types.h:34
Node
Definition def.h:83
@ Univ
Definition def.h:85
@ Var
Definition def.h:85
CODE(node, name, _)
Definition def.h:84