stuff!

3 files changed, 6 insertions, 5 deletions

diff --git a/lib/hook-functions.c b/lib/hook-functions.c
index 673d6d9..ee3d049 100644
--- a/lib/hook-functions.c
+++ b/lib/hook-functions.c
@@ -213,8 +213,8 @@ int substitute_hook_functions(const struct substitute_function_hook *hooks,
 
         /* Generate the rewritten start of the function for the outro
          * trampoline (complaining if any bad instructions are found)
-         * (on arm64, this modifies regs_possibly_written, which is used by the
-         * ending make_jump_patch call) */
+         * (on arm64, this modifies arch.regs_possibly_written, which is used
+         * by the later make_jump_patch call) */
         if ((ret = transform_dis_main(code, &trampoline_ptr, pc_patch_start,
                                       &pc_patch_end, (uintptr_t) trampoline_ptr,
                                       &arch, hi->offset_by_pcdiff,
diff --git a/lib/jump-dis.c b/lib/jump-dis.c
index f909cc7..04a919e 100644
--- a/lib/jump-dis.c
+++ b/lib/jump-dis.c
@@ -121,7 +121,8 @@ void jump_dis_thumb_it(UNUSED struct jump_dis_ctx *ctx) {
 
 static void jump_dis_dis(struct jump_dis_ctx *ctx);
 
-bool jump_dis_main(void *code_ptr, uint_tptr pc_patch_start, uint_tptr pc_patch_end,
+bool jump_dis_main(void *code_ptr, uint_tptr pc_patch_start,
+                   uint_tptr pc_patch_end,
                    struct arch_dis_ctx initial_dis_ctx) {
     bool ret;
     struct jump_dis_ctx ctx;
diff --git a/lib/substitute.h b/lib/substitute.h
index f75aa82..6b7b9f4 100644
--- a/lib/substitute.h
+++ b/lib/substitute.h
@@ -124,7 +124,7 @@ enum {
  * other similar library which cares about atomicity, noticing the same
  * concern, would independently come up with the same restriction - at least,
  * if they do not find an easier method to avoid deadlocks.  Note that all
- * existing hooking libraries I know of do not attempt to do any
+ * existing hooking libraries I know of make no attempt to do any
  * synchronization at all; this is fine if hooking is only done during
  * initialization while the process is single threaded, but I want to properly
  * support dynamic injection.  (Note - if there is such an easier method on OS
@@ -280,7 +280,7 @@ int substitute_interpose_imports(const struct substitute_image *handle,
  * @old_ptr          optional - out pointer to the 'old implementation'.
  *                   If there is no old implementation, a custom IMP is
  *                   returned that delegates to the superclass.  This IMP can
- *                   be freed if desired with imp_removeBlock.
+ *                   be freed if desired with substitute_free_created_imp.
  * @created_imp_ptr  optional - out pointer to whether a fake superclass-call
  *                   IMP has been placed in <old_ptr>
  *