Function package_shellcode

src/packager.cpp:236–1191

    }

    PackageResult package_shellcode(Span<std::uint8_t> shellcode, const PackageOptions& opt) {
        SeedRng rng{opt.seed};

        // range mode bounds check + lifter restriction 
        if (!opt.ranges.empty()) {
            for (const auto& [s, e] : opt.ranges) {
                if (e > shellcode.size) {
                    throw Error(
                        fmt::format(
                            "ranges entry 0x{:x}:0x{:x} extends past input size 0x{:x}",
                            s,
                            e,
                            static_cast<std::uint32_t>(shellcode.size)
                        )
                    );
                }
            }

            if (opt.verbose) {
                std::fprintf(stderr, "ranges hybrid mode: %zu range/s\n", opt.ranges.size());
                for (const auto& [s, e] : opt.ranges) {
                    std::fprintf(
                        stderr,
                        "  va 0x%x..0x%x  %u bytes\n",
                        s,
                        e,
                        e - s
                    );
                }
            }
        }

        // pack + ranges: build the range-mode blob first then pack-wrap it 
        if (opt.pack_mode && !opt.ranges.empty()) {
            PackageOptions inner = opt;
            inner.pack_mode = false; // inner pass: just range-mode
            auto inner_pkg = package_shellcode(shellcode, inner);
            PackageOptions outer = opt;
            outer.ranges.clear(); // outer pass: pure pack
            Span<std::uint8_t> inner_bytes{inner_pkg.blob.data(), static_cast<std::uint32_t>(inner_pkg.blob.size())};

            auto outer_pkg = package_shellcode(inner_bytes, outer);
            outer_pkg.stats = fmt::format(
                "{}\n  pack+ranges chain: inner range-mode blob = {} B",
                outer_pkg.stats, inner_pkg.blob.size()
            );
            
            return outer_pkg;
        }

        // lift
        CFGBuilder cfg{opt.arch, shellcode, opt.base_va};
        IRProgram prog;
        if (opt.pack_mode) {
            // single synthetic JMP_NATIVE
            prog.arch = opt.arch;
            prog.entry_va = opt.base_va;
            IRBlock blk;