A focused walkthrough of the host offload-entry table in REX: how `__tgt_offload_entry` objects are emitted, why REX uses synthetic host identity symbols, how entry names stay aligned with generated device kernels, and how the table is joined with the CUBIN during registration.

A focused debugging guide for REX GPU offloading failures that appear only at runtime: checking CUBIN presence, offload-entry integrity, kernel-name matching, init ordering, and map-array correctness.

A focused walkthrough of REX's offload init/fini policy: why the lowerer eagerly inserts `rex_offload_init()` near the top of `main`, why it deliberately does not auto-insert `rex_offload_fini()`, and what the lowering tests verify about that decision.

A focused walkthrough of the wrapper layer in `rex_kmp.h`: vendored runtime ABI structs, asm aliases for the real `libomptarget` symbols, direct and safe REX wrappers, macro rewriting of generated `__tgt_*` calls, and the `ident_t *` bridge for `__tgt_target_kernel`.

A focused walkthrough of REX's device-image registration path: why it uses standalone CUBIN files, how `register_cubin.cpp` builds `__tgt_device_image` and `__tgt_bin_desc`, how one-time registration is synchronized, and why `rex_offload_init()` is explicit.

A focused walkthrough of REX's mapper-expansion path: scope-aware `declare mapper` resolution, recursive clause expansion, array-section deferral into dynamic entries, and the shared two-pass builder used by `target`, `target data`, and `target update`.

A focused walkthrough of REX's literal target parameter path: how eligible mapped scalars are tagged, packed into pointer-sized launch arguments, stabilized in the host packet, and reconstructed inside the generated GPU kernel.

A focused walkthrough of REX's non-loop GPU offloading branch: how `transOmpTargetSpmd()` handles `target`, `target teams`, and `target parallel`, outlines the region body, builds offload entries and runtime argument arrays, and launches a simpler SPMD kernel path without worksharing loop rewriting.

A focused walkthrough of the target-loop lowering stage in REX: how `transOmpTargetLoopBlock()` recovers canonical loop structure, rewrites loops into direct grid-stride kernels, keeps a round-robin fallback, and shares loop analysis with host launch shaping.

A walkthrough of REX's top validation layer: building native LLVM and REX binaries side by side, comparing outputs with normalization rules, and catching runtime and performance regressions using real benchmarks.