Converting a set of sets to a single range - c++

Question

I'm having trouble with creating a certain type of range.
In LLVM (a compiler infrastructure), a Module (could be the code for a translation unit) is organized as follows:
llvm::Module m{...}; // A module could be a single translation unit.
for(const auto &func : m){
for(const auto &basic_block : func){
for(const auto &inst : basic_block){
}
}
}
In the code I'm working on, it's very convenient to have a function that creates a range of instructions contained in a Module or Function. For example:
llvm::Module m;
llvm::Function f;
InstSet temp;
temp.insert(instructions(m));
temp.insert(instructions(f));
However, I'm having trouble elegantly implementing the range.
Things I tried:
Implementing a custom iterator. It turned out to be really messy even though what I'm trying to do is supposed to be simple...
Implementing using coroutines. While this worked out slightly better, the performance was unacceptable (about 10x slower upon investigation).
My question is, are there any elegant solutions that I'm missing? If there is none, I'd like to know why to understand the problem I'm trying to solve the wrong way.
EDIT (I added my own implementations below):
Here is the implementation that uses coroutines (finished):
struct InstructionsGenerator {
struct promise_type;
using Handle = coroutine_handle<promise_type>;
struct promise_type {
const Instruction *i;
auto get_return_object() -> InstructionsGenerator { return {Handle::from_promise(*this)}; }
auto yield_value(const Instruction &y) -> suspend_always {
i = &y;
return {};
}
auto initial_suspend() -> suspend_never { return {}; };
auto final_suspend() -> suspend_always { return {}; };
auto return_void() -> void {}
};
Handle h;
};
auto instructions_generator(const Module &m) -> InstructionsGenerator {
for (const auto &f : m) {
for (const auto &bb : f) {
for (const auto &i : instructions(bb)) {
co_yield i;
}
}
}
}
struct InstructionRange {
struct iterator {
optional<InstructionsGenerator> g;
auto operator++() -> auto & {
g->h();
return *this;
}
auto operator*() const -> auto & { return *(g->h.promise().i); }
auto operator==(const iterator & /*unused*/) const -> bool { return g->h.done(); }
};
iterator b;
[[nodiscard]] auto begin() const -> iterator { return b; }
[[nodiscard]] auto end() const -> iterator { return {nullopt}; };
~InstructionRange() {
if (b.g) {
b.g->h.destroy();
}
}
InstructionRange(InstructionsGenerator fi) : b{fi} {}
InstructionRange(InstructionRange &&r) noexcept : b{r.b} { r.b.g = nullopt; }
};
auto instructions(const Module &m) -> InstructionRange { return {instructions_generator(m)}; };
Here is the implementation that uses custom iterators (unfinished. Abandoned it after realizing it's too much of a hassle.):
// The real implementation was templated but to give you the idea, I've simplified it.
struct LiftedRange {
llvm::Module& m;
public:
struct iterator {
llvm::Module& m;
llvm::Module::iterator l1;
llvm::Function::iterator l2;
auto operator*(); // Skipped for brevity.
auto operator==(); // Skipped for brevity.
auto operator++(){
if(next(l2) != l1.end()){
++l2;
return *this;
}
do {
++l1;
while(l1->empty() || l1 != m.end()); // Avoid empty sets.
l2 = l1->begin();
return *this;
}
};
auto begin(); // Skipped for brevity.
auto end(); // Skipped for brevity.
};