6#include "tpde/ValueAssignment.hpp"
13template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
17 AsmReg reg = AsmReg::make_invalid();
18 bool has_assignment =
false;
21 bool const_inline : 1;
31 AsmReg reg = AsmReg::make_invalid();
32 bool has_assignment =
true;
34 ValLocalIdx local_idx;
36 ValueAssignment *assignment;
45 ValuePart() noexcept : state{ConstantData{.is_const =
false}} {}
47 ValuePart(RegBank bank) noexcept
49 ConstantData{.is_const =
false, .bank = bank}
51 assert(bank.id() < Config::NUM_BANKS);
54 ValuePart(ValLocalIdx local_idx,
55 ValueAssignment *assignment,
61 .local_idx = local_idx,
63 .assignment = assignment,
66 assert(this->assignment().variable_ref() ||
67 state.v.assignment->references_left);
68 assert(!owned || state.v.assignment->references_left == 1);
71 ValuePart(
const u64 *data, u32 size, RegBank bank) noexcept
73 .c = ConstantData{.is_const =
true,
74 .const_inline =
false,
79 assert(data &&
"constant data must not be null");
80 assert(bank.id() < Config::NUM_BANKS);
83 ValuePart(
const u64 val, u32 size, RegBank bank) noexcept
85 .c = ConstantData{.is_const =
true,
91 assert(size <=
sizeof(val));
92 assert(bank.id() < Config::NUM_BANKS);
95 explicit ValuePart(
const ValuePart &) =
delete;
97 ValuePart(ValuePart &&other) noexcept : state{other.state} {
98 other.state.c = ConstantData{};
101 ~ValuePart() noexcept {
102 assert(!state.c.reg.valid() &&
"must call reset() on ValuePart explicitly");
105 ValuePart &operator=(
const ValuePart &) =
delete;
107 ValuePart &operator=(ValuePart &&other)
noexcept {
108 if (
this == &other) {
111 assert(!state.c.reg.valid() &&
"must call reset() on ValuePart explicitly");
112 this->state = other.state;
113 other.state.c = ConstantData{};
117 bool has_assignment() const noexcept {
return state.v.has_assignment; }
119 bool is_const() const noexcept {
120 return !state.c.has_assignment && state.c.is_const;
123 bool is_owned() const noexcept {
124 assert(has_assignment());
125 return state.c.owned;
128 [[nodiscard]] AssignmentPartRef assignment() const noexcept {
129 assert(has_assignment());
130 return AssignmentPartRef{state.v.assignment, state.v.part};
135 AsmReg cur_reg() const noexcept {
136 assert(state.v.reg.valid());
142 AsmReg cur_reg_unlocked() const noexcept {
143 if (state.v.reg.valid()) {
146 if (has_assignment()) {
147 if (
auto ap = assignment(); ap.register_valid()) {
151 return AsmReg::make_invalid();
155 bool is_in_reg(AsmReg reg)
const noexcept {
157 return cur_reg() == reg;
159 if (has_assignment()) {
160 auto ap = assignment();
161 return ap.register_valid() && ap.get_reg() == reg;
166 bool has_reg() const noexcept {
return state.v.reg.valid(); }
171 bool reload)
noexcept;
174 bool reload)
noexcept;
179 AsmReg alloc_reg(
CompilerBase *compiler, u64 exclusion_mask = 0) noexcept {
180 return alloc_reg_impl(compiler, exclusion_mask,
false);
198 AsmReg alloc_try_reuse(
CompilerBase *compiler, ValuePart &ref)
noexcept {
199 assert(ref.has_reg());
200 if (!has_assignment() || !assignment().register_valid()) {
201 assert(!has_assignment() || !assignment().fixed_assignment());
202 if (ref.can_salvage()) {
203 set_value(compiler, std::move(ref));
204 if (has_assignment()) {
210 return alloc_reg(compiler);
218 void alloc_specific(
CompilerBase *compiler, AsmReg reg)
noexcept {
219 alloc_specific_impl(compiler, reg,
false);
226 return alloc_reg_impl(compiler, 0,
true);
236 void load_to_specific(
CompilerBase *compiler, AsmReg reg)
noexcept {
237 alloc_specific_impl(compiler, reg,
true);
241 AsmReg reload_into_specific_fixed(
CompilerBase *compiler,
243 unsigned size = 0) noexcept;
246 ValuePart get_unowned() noexcept {
248 ValuePart res{bank()};
250 ConstantData{.reg = cur_reg(), .owned =
false, .is_const =
false};
255 ValuePart into_temporary(
CompilerBase *compiler) &&
noexcept {
257 if (state.c.const_inline) {
258 ValuePart res{state.c.inline_data, state.c.size, state.c.bank};
259 res.load_to_reg(compiler);
262 ValuePart res{state.c.data, state.c.size, state.c.bank};
263 res.load_to_reg(compiler);
269 assert((has_assignment() || state.c.owned) &&
270 "into_temporary from unowned ValuePart not implemented");
271 ValuePart res{bank()};
272 res.set_value(compiler, std::move(*
this));
273 if (!res.has_reg()) [[unlikely]] {
274 assert(res.is_const());
275 res.load_to_reg(compiler);
285 u32 to) &&
noexcept {
286 assert(from < to &&
"invalid integer extension sizes");
287 if (is_const() && to <= 64) {
288 u64 val = const_data()[0];
289 u64 extended = sign ? util::sext(val, from) : util::zext(val, from);
290 return ValuePart{extended, (to + 7) / 8, state.c.bank};
292 ValuePart res{bank()};
293 Reg src_reg = has_reg() ? cur_reg() : load_to_reg(compiler);
295 res.set_value(compiler, std::move(*
this));
296 assert(src_reg == res.cur_reg());
298 res.alloc_reg(compiler);
300 compiler->derived()->generate_raw_intext(
301 res.cur_reg(), src_reg, sign, from, to);
308 void set_modified() noexcept {
309 assert(has_reg() && has_assignment());
310 assignment().set_modified(
true);
316 void set_value(
CompilerBase *compiler, ValuePart &&other)
noexcept;
322 void set_value_reg(
CompilerBase *compiler, AsmReg reg)
noexcept;
324 bool can_salvage() const noexcept {
325 if (!has_assignment()) {
326 return state.c.owned && state.c.reg.valid();
329 return state.v.owned && assignment().register_valid();
333 AsmReg salvage_keep_used(
CompilerBase *compiler)
noexcept;
339 AsmReg reg = salvage_keep_used(compiler);
340 compiler->register_file.unmark_used(reg);
344 ValLocalIdx local_idx() const noexcept {
345 assert(has_assignment());
346 return state.v.local_idx;
349 u32 part() const noexcept {
350 assert(has_assignment());
354 RegBank bank() const noexcept {
355 return !has_assignment() ? state.c.bank : assignment().bank();
358 u32 part_size() const noexcept {
359 return !has_assignment() ? state.c.size : assignment().part_size();
362 std::span<const u64> const_data() const noexcept {
364 if (state.c.const_inline) {
365 return {&state.c.inline_data, 1};
367 return {state.c.data, (state.c.size + 7) / 8};
374template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
375typename CompilerBase<Adaptor, Derived, Config>::AsmReg
376 CompilerBase<Adaptor, Derived, Config>::ValuePart::alloc_reg_impl(
379 const bool reload)
noexcept {
383 assert(compiler->may_change_value_state());
384 assert(!state.c.reg.valid());
387 if (has_assignment()) {
388 auto ap = assignment();
389 if (ap.register_valid()) {
392 assert((exclusion_mask & (1ull << state.v.reg.id())) == 0 &&
393 "moving registers in alloc_reg is unsupported");
402 Reg reg = compiler->select_reg(bank, exclusion_mask);
403 auto ®_file = compiler->register_file;
404 reg_file.mark_clobbered(reg);
405 if (has_assignment()) {
406 reg_file.mark_used(reg, state.v.local_idx, state.v.part);
407 auto ap = assignment();
409 ap.set_register_valid(
true);
416 compiler->derived()->reload_to_reg(reg, ap);
418 assert(!ap.stack_valid() &&
"alloc_reg called on initialized value");
421 reg_file.mark_used(reg, INVALID_VAL_LOCAL_IDX, 0);
422 reg_file.mark_fixed(reg);
424 state.c.owned =
true;
427 assert(is_const() &&
"cannot reload temporary value");
428 compiler->derived()->materialize_constant(
429 const_data().data(), state.c.bank, state.c.size, reg);
436template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
437typename CompilerBase<Adaptor, Derived, Config>::AsmReg
438 CompilerBase<Adaptor, Derived, Config>::ValuePart::alloc_specific_impl(
439 CompilerBase *compiler, AsmReg reg,
const bool reload)
noexcept {
440 assert(!state.c.reg.valid());
442 if (has_assignment()) {
443 auto ap = assignment();
444 assert(!ap.fixed_assignment());
446 if (ap.register_valid() && ap.get_reg() == reg) {
452 auto ®_file = compiler->register_file;
453 if (reg_file.is_used(reg)) {
454 compiler->evict_reg(reg);
457 reg_file.mark_clobbered(reg);
458 if (has_assignment()) {
459 assert(compiler->may_change_value_state());
461 reg_file.mark_used(reg, state.v.local_idx, state.v.part);
462 auto ap = assignment();
463 auto old_reg = AsmReg::make_invalid();
464 if (ap.register_valid()) {
465 old_reg = ap.get_reg();
469 ap.set_register_valid(
true);
476 if (old_reg.valid()) {
477 compiler->derived()->mov(reg, old_reg, ap.part_size());
478 reg_file.unmark_used(old_reg);
480 compiler->derived()->reload_to_reg(reg, ap);
483 assert(!ap.stack_valid() &&
"alloc_reg with valid stack slot");
486 reg_file.mark_used(reg, INVALID_VAL_LOCAL_IDX, 0);
487 reg_file.mark_fixed(reg);
490 if (state.c.reg.valid()) {
492 compiler->derived()->mov(reg, state.c.reg, 8);
493 reg_file.unmark_fixed(state.c.reg);
494 reg_file.unmark_used(state.c.reg);
496 assert(is_const() &&
"cannot reload temporary value");
497 compiler->derived()->materialize_constant(
498 const_data().data(), state.c.bank, state.c.size, reg);
503 state.c.owned =
true;
509template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
510typename CompilerBase<Adaptor, Derived, Config>::AsmReg
514 unsigned size)
noexcept {
516 compiler->derived()->materialize_constant(
517 const_data().data(), state.c.bank, state.c.size, reg);
520 if (!has_assignment()) {
522 assert(reg != cur_reg());
525 compiler->derived()->mov(reg, cur_reg(), size);
529 auto ap = assignment();
531 assert(cur_reg() != reg);
532 compiler->derived()->mov(reg, cur_reg(), ap.part_size());
533 }
else if (ap.register_valid()) {
534 assert(ap.get_reg() != reg);
536 compiler->derived()->mov(reg, ap.get_reg(), ap.part_size());
538 assert(!ap.fixed_assignment());
539 compiler->derived()->reload_to_reg(reg, ap);
542 compiler->register_file.mark_clobbered(reg);
546template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
547void CompilerBase<Adaptor, Derived, Config>::ValuePart::lock(
549 assert(has_assignment());
551 auto ap = assignment();
552 assert(ap.register_valid());
554 const auto reg = ap.get_reg();
555 compiler->register_file.inc_lock_count(reg);
559template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
560void CompilerBase<Adaptor, Derived, Config>::ValuePart::unlock(
562 assert(has_assignment());
563 if (!state.v.reg.valid()) {
567 compiler->register_file.dec_lock_count(state.v.reg);
568 state.v.reg = AsmReg::make_invalid();
571template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
572void CompilerBase<Adaptor, Derived, Config>::ValuePart::set_value(
574 auto ®_file = compiler->register_file;
575 if (!has_assignment()) {
577 if (!other.can_salvage()) {
579 AsmReg cur_reg = alloc_reg(compiler);
580 other.reload_into_specific_fixed(compiler, cur_reg);
581 other.reset(compiler);
587 if (!other.has_assignment()) {
588 assert(other.state.c.owned &&
"can_salvage true for unowned value??");
592 *
this = std::move(other);
599 state.c.reg = other.salvage_keep_used(compiler);
600 state.c.owned =
true;
601 reg_file.mark_fixed(state.c.reg);
602 reg_file.update_reg_assignment(state.c.reg, INVALID_VAL_LOCAL_IDX, 0);
607 auto ap = assignment();
608 assert(!ap.variable_ref() &&
"cannot update variable ref");
610 if (ap.fixed_assignment() || !other.can_salvage()) {
612 AsmReg cur_reg = alloc_reg(compiler);
613 other.reload_into_specific_fixed(compiler, cur_reg, ap.part_size());
614 other.reset(compiler);
616 ap.set_register_valid(
true);
617 ap.set_modified(
true);
622 if (ap.register_valid()) {
625 auto cur_reg = ap.get_reg();
626 assert(!reg_file.is_fixed(cur_reg));
627 reg_file.unmark_used(cur_reg);
630 AsmReg new_reg = other.salvage_keep_used(compiler);
631 reg_file.update_reg_assignment(new_reg, local_idx(), part());
633 ap.set_register_valid(
true);
634 ap.set_modified(
true);
637template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
638void CompilerBase<Adaptor, Derived, Config>::ValuePart::set_value_reg(
640 assert(compiler->may_change_value_state());
642 auto ®_file = compiler->register_file;
645 assert(value_reg.valid() &&
"cannot initialize with invalid register");
646 assert(!state.c.reg.valid() &&
647 "attempted to overwrite already initialized and locked ValuePartRef");
649 if (!has_assignment()) {
650 assert(!is_const() &&
"cannot mutate constant ValuePartRef");
651 state.c.reg = value_reg;
652 state.c.owned =
true;
653 reg_file.mark_used(state.c.reg, INVALID_VAL_LOCAL_IDX, 0);
654 reg_file.mark_fixed(state.c.reg);
659 auto ap = assignment();
660 assert(!ap.variable_ref() &&
"cannot update variable ref");
662 if (ap.fixed_assignment()) {
664 auto cur_reg = ap.get_reg();
665 assert(reg_file.is_used(cur_reg));
666 assert(reg_file.is_fixed(cur_reg));
667 assert(reg_file.reg_local_idx(cur_reg) == local_idx());
669 assert(cur_reg != value_reg);
670 compiler->derived()->mov(cur_reg, value_reg, ap.part_size());
671 ap.set_register_valid(
true);
672 ap.set_modified(
true);
677 assert(!ap.register_valid() && !ap.stack_valid() &&
678 "attempted to overwrite already initialized ValuePartRef");
680 reg_file.mark_used(value_reg, local_idx(), part());
681 reg_file.mark_clobbered(value_reg);
682 ap.set_reg(value_reg);
683 ap.set_register_valid(
true);
684 ap.set_modified(
true);
687template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
688typename CompilerBase<Adaptor, Derived, Config>::AsmReg
689 CompilerBase<Adaptor, Derived, Config>::ValuePart::salvage_keep_used(
691 assert(compiler->may_change_value_state());
692 assert(can_salvage());
693 if (!has_assignment()) {
694 AsmReg reg = state.c.reg;
695 compiler->register_file.unmark_fixed(reg);
696 state.c.reg = AsmReg::make_invalid();
700 auto ap = assignment();
701 assert(ap.register_valid());
702 auto cur_reg = ap.get_reg();
705 assert(ap.fixed_assignment() || !compiler->register_file.is_fixed(cur_reg));
706 if (ap.fixed_assignment()) {
707 compiler->register_file.dec_lock_count(cur_reg);
710 ap.set_register_valid(
false);
711 ap.set_fixed_assignment(
false);
715template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
716void CompilerBase<Adaptor, Derived, Config>::ValuePart::reset(
718 AsmReg reg = state.c.reg;
726 assert(!has_assignment() || assignment().modified() ||
true);
729 if (!has_assignment()) {
731 compiler->register_file.unmark_fixed(reg);
732 compiler->register_file.unmark_used(reg);
735 assert(compiler->may_change_value_state());
736 bool reg_unlocked = compiler->register_file.dec_lock_count(reg);
737 if (reg_unlocked && state.v.owned) {
738 assert(assignment().register_valid());
739 assert(!assignment().fixed_assignment());
740 compiler->register_file.unmark_used(reg);
741 assignment().set_register_valid(
false);
745 state.c.reg = AsmReg::make_invalid();
748template <IRAdaptor Adaptor,
typename Derived, CompilerConfig Config>
749struct CompilerBase<Adaptor, Derived, Config>::ValuePartRef : ValuePart {
752 template <
typename... Args>
753 ValuePartRef(
CompilerBase *compiler, Args &&...args) noexcept
754 : ValuePart(std::forward<Args>(args)...), compiler(compiler) {}
756 explicit ValuePartRef(
const ValuePartRef &) =
delete;
758 ValuePartRef(ValuePartRef &&other) noexcept
759 : ValuePart(std::move(other)), compiler(other.compiler) {}
761 ~ValuePartRef() noexcept {
reset(); }
763 ValuePartRef &operator=(
const ValuePartRef &) =
delete;
765 ValuePartRef &operator=(ValuePartRef &&other)
noexcept {
766 if (
this == &other) {
770 ValuePart::operator=(std::move(other));
774 AsmReg alloc_reg(u64 exclusion_mask = 0) noexcept {
775 return ValuePart::alloc_reg(compiler, exclusion_mask);
778 AsmReg alloc_try_reuse(ValuePart &ref)
noexcept {
779 return ValuePart::alloc_try_reuse(compiler, ref);
782 void alloc_specific(AsmReg reg)
noexcept {
783 ValuePart::alloc_specific(compiler, reg);
786 AsmReg load_to_reg() noexcept {
return ValuePart::load_to_reg(compiler); }
788 void load_to_specific(AsmReg reg)
noexcept {
789 ValuePart::load_to_specific(compiler, reg);
792 AsmReg reload_into_specific_fixed(AsmReg reg,
unsigned size = 0) noexcept {
793 return ValuePart::reload_into_specific_fixed(compiler, reg, size);
796 AsmReg reload_into_specific_fixed(
CompilerBase *compiler,
798 unsigned size = 0) noexcept {
799 return ValuePart::reload_into_specific_fixed(compiler, reg, size);
802 ValuePartRef get_unowned_ref() noexcept {
803 return ValuePartRef{compiler, ValuePart::get_unowned()};
806 ValuePartRef into_temporary() &&
noexcept {
809 std::move(*
static_cast<ValuePart *
>(
this)).into_temporary(compiler)};
812 ValuePartRef into_extended(
bool sign, u32 from, u32 to) &&
noexcept {
813 return ValuePartRef{compiler,
814 std::move(*
static_cast<ValuePart *
>(
this))
815 .into_extended(compiler, sign, from, to)};
818 void lock() noexcept { ValuePart::lock(compiler); }
819 void unlock() noexcept { ValuePart::unlock(compiler); }
821 void set_value(ValuePart &&other)
noexcept {
822 ValuePart::set_value(compiler, std::move(other));
825 void set_value_reg(AsmReg value_reg)
noexcept {
826 ValuePart::set_value_reg(compiler, value_reg);
829 AsmReg salvage() noexcept {
return ValuePart::salvage(compiler); }
831 void reset() noexcept { ValuePart::reset(compiler); }
CompilerBase(Adaptor *adaptor)
Initialize a CompilerBase, should be called by the derived classes.