loading: say how to read a headerless blob (processor, base)

A raw firmware dump has no format to detect, so IDA fell back to x86 at address
0. It doesn't fail — it opens, analyses, and finds nothing. An AArch64 image
loaded this way gave 0 functions; told the truth it gives 35.

    ida-tui fw.bin --processor arm --base 0x8000000

and per binary in a project, which is what a multi-image firmware actually
needs:

    {"path": "app.bin", "processor": "arm", "base": "0x8000000"}

idapro.open_database() already accepted IDA command-line switches; nothing was
passing any. Plumbed BinaryRef -> WorkerPool -> WorkerClient -> worker argv, plus
a load_args for the single-binary path that has no project ref.

base is written the way people say it (0x8000000, int or string, any base).
IDA's -b is in PARAGRAPHS — -b1000 loads at 0x10000 — so BinaryRef.load_args
converts, and a base that isn't 16-byte aligned is refused rather than silently
landing 16x off. ida_args passes anything else through.

Two bugs found by testing the whole path rather than the happy one:

* Project.load() whitelisted path/label when normalising entries, so the load
  options were dropped the first time a project was reopened — set a processor,
  come back tomorrow, it's gone.
* Re-passing the switches to an EXISTING database makes IDA refuse the open
  (rc != 0, no functions). The .i64 already records how the image was loaded, so
  the worker skips them once a database exists. My first guard checked
  splitext(path) + ".i64" and never fired, because IDA names it "<file>.i64" —
  keeping the extension. It checks both spellings now.

Verified on a real AArch64 blob: fresh load 35 functions based at 0x8002440,
reopen 35 again, and the CLI rejects an unaligned or non-numeric --base.

tests: +6 project (options recorded, paragraph conversion, file round-trip,
add() takes them, an ELF passes nothing, hex-string base). 39/0 project, 195/0
scenarios, 30/0 project UI, 36/0 index, 27/0 pool.

1 files changed, 40 insertions, 0 deletions

diff --git a/tests/test_project.py b/tests/test_project.py
index be46875..91fd250 100644
--- a/tests/test_project.py
+++ b/tests/test_project.py
@@ -185,6 +185,46 @@ def main() -> int:
         except ProjectError:
             check("staging a missing binary raises ProjectError", True)
 
+    # -- load options for headerless blobs --------------------------------- #
+    with tempfile.TemporaryDirectory() as tmp:
+        src = os.path.join(tmp, "src"); os.makedirs(src)
+        blob = os.path.join(src, "fw.bin")
+        with open(blob, "wb") as f:
+            f.write(b"\x00" * 64)
+        proj = Project.create(os.path.join(tmp, "p.json"), [blob], name="p",
+                              load={"processor": "arm", "base": 0x8000000})
+        r = proj.refs[0]
+        check("create() records load options per binary",
+              r.processor == "arm" and r.base == 0x8000000,
+              f"proc={r.processor!r} base={r.base:#x}")
+        # -b is PARAGRAPHS: 0x8000000 >> 4 == 0x800000. Getting this wrong loads
+        # the image 16x too high and every address in the database is wrong.
+        check("base is converted to IDA's paragraph units",
+              r.load_args == "-parm -b800000", r.load_args)
+
+        proj2 = Project.load(proj.path)
+        check("load options survive a round-trip through the file",
+              proj2.refs[0].load_args == "-parm -b800000",
+              proj2.refs[0].load_args)
+
+        blob2 = os.path.join(src, "other.bin")
+        with open(blob2, "wb") as f:
+            f.write(b"\x00" * 64)
+        r2 = proj2.add(blob2, load={"processor": "mipsb"})
+        check("add() takes load options too",
+              r2.load_args == "-pmipsb", r2.load_args)
+
+        # a normal ELF needs none of this and must pass nothing
+        check("a binary with no load options passes no switches",
+              Project.create(os.path.join(tmp, "q.json"), [blob],
+                             name="q").refs[0].load_args == "")
+
+        # addresses get written by hand, so accept how people write them
+        proj3 = Project.create(os.path.join(tmp, "r.json"), [blob], name="r",
+                               load={"base": "0x1000"})
+        check("a base given as a hex STRING is parsed",
+              proj3.refs[0].base == 0x1000, f"{proj3.refs[0].base}")
+
     print(f"\n{PASS} passed, {FAIL} failed")
     return 1 if FAIL else 0