Class BytecodeBuilder

include/mkpivm/bytecode.h:13–114

accumulates plaintext bytecode. tracks branch fixups

namespace mkpivm {
    // accumulates plaintext bytecode. tracks branch fixups 
    class BytecodeBuilder {
        public:
            std::size_t pos() const noexcept { return buf_.size(); }
            void u8 (std::uint8_t  v) { buf_.push_back(v); }

            void u16(std::uint16_t v) {
                buf_.push_back(static_cast<std::uint8_t>(v));
                buf_.push_back(static_cast<std::uint8_t>(v >> 8));
            }

            void u32(std::uint32_t v) {
                for (int i = 0; i < 4; ++i) buf_.push_back(static_cast<std::uint8_t>(v >> (8*i)));
            }

            void u64(std::uint64_t v) {
                for (int i = 0; i < 8; ++i) buf_.push_back(static_cast<std::uint8_t>(v >> (8*i)));
            }

            void bytes(const std::uint8_t* p, std::size_t n) { buf_.insert(buf_.end(), p, p+n); }

            // record this cursor as the start of IR block_id
            void mark_block(std::uint32_t block_id) {
                block_offsets_[block_id] = buf_.size();
            }

            std::uint32_t block_offset(std::uint32_t block_id) const {
                auto it = block_offsets_.find(block_id);
                if (it == block_offsets_.end()) throw Error("block_offset: unbound id");
                return static_cast<std::uint32_t>(it->second);
            }

            // placeholder rel32 to a target block. resolved later to target_off
            // minus end_of_field
            void emit_branch_rel32(std::uint32_t target_block_id) {
                branch_fixups_.push_back({buf_.size(), target_block_id});
                u32(0);
            }

            // walk the fixup list once every block has an offset
            void resolve_branches() {
                for (const auto& f : branch_fixups_) {
                    auto it = block_offsets_.find(f.target_block_id);

                    if (it == block_offsets_.end()) throw Error("resolve_branches: missing block");
                    const std::int64_t rel = static_cast<std::int64_t>(it->second) - (static_cast<std::int64_t>(f.patch_pos) + 4);

                    if (rel < INT32_MIN || rel > INT32_MAX) throw Error("resolve_branches: oob");
                    const std::uint32_t v = static_cast<std::uint32_t>(static_cast<std::int32_t>(rel));

                    for (int i = 0; i < 4; ++i) {
                        buf_[f.patch_pos + i] = static_cast<std::uint8_t>(v >> (8*i));
                    }
                }
                branch_fixups_.clear();
            }

            // placeholder offset into the data island for an original VA. encoder
            // fills it in using the IRProgram data map