Check target function size to avoid undefined behavior

The size of target function to fake could be less than the patching size. Patching such function could cause undefined behavior at runtime.

One option is checking the size of the target function before performing patching. Panic if the function size is smaller than the required patching size.

For example, aarch64 has a hard coded size. This could cause undefined behavior if the function to fake is smaller.

fn replace_function_with_other_function(
    src: FuncPtrInternal,
    target: FuncPtrInternal,
) -> PatchGuard {
    const PATCH_SIZE: usize = 12;
    const JIT_SIZE: usize = 20;


    let original_bytes = unsafe { read_bytes(src.as_ptr() as *mut u8, PATCH_SIZE) };
    let jit_memory = allocate_jit_memory(&src, JIT_SIZE);
    generate_will_execute_jit_code_abs(jit_memory, target.as_ptr());


    apply_branch_patch(src, jit_memory, JIT_SIZE, &original_bytes)
}

Start with src/injector_core/patch_arm64.rs and the replace_function_with_other_function entry point shown in the issue. Trace how the hard-coded patch size is used before applying a branch patch, then inspect related architecture-specific patching code. Done means undersized target functions are detected before patching and the behavior is covered by appropriate tests.