weary mesaBOT
fluid raft
whats an ir?
vital flame
whats an ir?
i guess ill look at this
please use structs and free functions
it’d be like, idk, 30 mins max to rewrite this module
your current one is over engineered garbage
what you have and need to improve
and why the hell does this resemble AST when it’s supposed to be an IR
violet ridge
your current one is over engineered garbage
what you have and need to improve
-...
only other way is with pointers and function overrides though
it becomes messy either way
vital flame
how?🤔
violet ridge
like I want this exact functionality but preferably more clean
violet ridge
not because of triton
violet ridge
kk sure
violet ridge
cya
hey so cant really figure out a way to improve this
I still believe variants is the way to go but not sure
violet ridge
bump
vital flame
bump
violet ridge
ok I realized the std::optional in the visitor struct makes 0 sense
vital flame
since you can't figure it out
export module ir;
import std;
import <triton/context.hpp>;
namespace ir {
static unsigned s_index{};
struct Variable {
std::string name;
std::size_t size;
Variable(std::size_t sz) : name{std::format("t{}", ++s_index)}, size{sz} {}
Variable(std::string_view n, std::size_t sz) : name{n}, size{sz} {}
};
struct Register {
triton::arch::Register reg;
Register(const triton::arch::Register& r) : reg{r} {}
};
struct Immediate {
std::uintptr_t value;
std::size_t size;
Immediate(std::uintptr_t v, std::size_t sz = 8) : value{v}, size{sz} {}
Immediate(const triton::arch::Immediate& imm) : value{imm.getValue()}, size{imm.getSize()} {}
};
using Leaf = std::variant<Variable, Register, Immediate>;
struct Memory { Leaf expr; triton::arch::Register seg; std::size_t size; };
struct Extract { Leaf expr; std::size_t hi, lo; };
struct Extend { Leaf expr; std::size_t size; };
struct Sign_extend { Leaf expr; std::size_t size; };
struct Zero_extend { Leaf expr; std::size_t size; };
struct Inc { Leaf expr; std::size_t size; };
struct Dec { Leaf expr; std::size_t size; };
struct Neg { Leaf expr; std::size_t size; };
struct Not { Leaf expr; std::size_t size; };
using Expr = std::variant<
Variable, Register, Immediate,
Memory, Extract, Extend, Sign_extend, Zero_extend,
Inc, Dec, Neg, Not
>;
struct Push { Expr expr; };
struct Assign { Expr lhs, rhs; };
using Instr = std::variant<Push, Assign>;
inline std::string to_string(const Variable& v) { return v.name; }
inline std::string to_string(const Register& r) { return r.reg.getName(); }
inline std::string to_string(const Immediate& i) { return std::format("{:#x}", i.value); }
inline std::string to_string(const Leaf& l) { return std::visit([](auto&& v){ return to_string(v); }, l); }
inline std::size_t get_size(const Variable& v) { return v.size; }
inline std::size_t get_size(const Register& r) { return r.reg.getSize(); }
inline std::size_t get_size(const Immediate& i) { return i.size; }
inline std::size_t get_size(const Leaf& l) { return std::visit([](auto&& v){ return get_size(v); }, l); }
} // namespace ir
@vital flame this doesn't preserve the original functionality though
I want to be able to do something like this
weary mesaBOT
@violet ridge Has your question been resolved? If so, type !solved :)
vital flame
<@1269691365122510932> this doesn't preserve the original functionality though
?
inline std::string to_string(const Expr& e) {
return std::visit([](auto&& v) -> std::string {
using T = std::decay_t<decltype(v)>;
if constexpr (std::same_as<T, Variable> || std::same_as<T, Register> || std::same_as<T, Immediate>) {
return to_string(v);
} else if constexpr (std::same_as<T, Memory>) {
return std::format("mem[{}]", to_string(v.expr));
} else if constexpr (std::same_as<T, Inc>) {
return std::format("inc({})", to_string(v.expr));
} else {
return "unknown";
}
}, e);
}
this should already solve your problem
https://godbolt.org/z/PG6c55YY8 there :)
you have 3 different ways to write your dispatch or whatever that is
violet ridge
you have 3 different ways to write your dispatch or whatever that is
this is great but how can I do something like: ```cpp
std::vector<Instr> instructions;
instructions.emplace_back(Push{Register{10}});
instructions.emplace_back(Push{Immediate{20}});
instructions.emplace_back(Assign{Register{30}, Immediate{40}});
for (const auto& instruction : instructions) {
if (auto* push = get_if<ir::Push>(instruction)) {
std::println("push {}", to_string(push));
}
}
std::println();```
do you even understand my code
violet ridge
oh
violet ridge
now I get it, yeah ur code is awesome
vital flame
you just gotta add more branches
this is ideally not the best design in my perspective but if it works for you then cool
violet ridge
uhh what is this for
template<typename... Fs>
struct overloaded : Fs... { using Fs::operator()...; };```ic
vital flame
for c++23 and beyond, idk if you can directly use multiple lambdas without the overload helper
i don’t really use variants
violet ridge
can we avoid something like this? cpp using T = std::decay_t<decltype(v)>; if constexpr (std::same_as<T, Variable> || std::same_as<T, Register> || std::same_as<T, Immediate>) {
like having to explicitly type each one
and just use using Leaf = std::variant<Variable, Register, Immediate>; somehow
violet ridge
oh nice u can just do
if constexpr (std::constructible_from<Leaf, T>) {
return to_string(v);
}```alright will try to add this to the project and if there are no probs will mark this as solved
thanks for the help
weary mesaBOT
@violet ridge Has your question been resolved? If so, type !solved :)
violet ridge
ok so my understanding is basically, you changed expr, leaf and inst from being classes to just a std::variant, and instead wrote free functions with ADL
vital flame
uh huh
yeah
i just have no idea why the original code snippet has so much bookkeeping
weary mesaBOT
violet ridge
ok ty for the help, this is the final design I came up with
weary mesaBOT
@violet ridge Has your question been resolved? If so, type !solved :)
violet ridge
!solved
weary mesaBOT