ZJIT: Rename PadPatchPoint to PatchPointPad

Two reasons for this: 1. It's less weird for a pad to be zero width than
for an imperative to pad to not actually pad. 2. PatchPoint is a noun so
its related padding reads better when can only be interpreted as a noun.

Author: XrXr

zjit/src/backend/arm64/mod.rs

@@ -1528,8 +1528,8 @@ impl Assembler {
                 Insn::Jonz(opnd, target) => {
                     emit_cmp_zero_jump(cb, opnd.into(), false, target.clone());
                 },
-                Insn::PatchPoint(..) => unreachable!("PatchPoint should have been lowered to PadPatchPoint in arm64_scratch_split"),
-                Insn::PadPatchPoint => {
+                Insn::PatchPoint(..) => unreachable!("PatchPoint should have been lowered to PatchPointPad in arm64_scratch_split"),
+                Insn::PatchPointPad => {
                     emit_pad_after_patch_point(cb, last_patch_pos);
                     // This position is itself where a jump gets written on invalidation, so it
                     // becomes what following code has to keep its distance from.

zjit/src/backend/lir.rs

@@ -898,12 +898,12 @@ pub enum Insn {
     ///
     /// Zero-width whenever there is already enough room, which is the common
     /// case.
-    PadPatchPoint,
+    PatchPointPad,
 
     /// Space reserved at a boundary that a preceding PatchPoint's invalidation
     /// jump must not cross: the start of a non-entry block, the start of a side
     /// exit, or the end of the last block. Nothing is ever patched at a
-    /// boundary, so unlike [`Insn::PadPatchPoint`] this only protects what comes
+    /// boundary, so unlike [`Insn::PatchPointPad`] this only protects what comes
     /// after it, and it does not become something later code has to keep away
     /// from — the first patch point of a block needs no padding in front of it.
     ///
@@ -1001,7 +1001,7 @@ macro_rules! for_each_operand_impl {
             Insn::Breakpoint | Insn::Abort |
             Insn::Comment(_) |
             Insn::CPop { .. } |
-            Insn::PadPatchPoint |
+            Insn::PatchPointPad |
             Insn::PosMarker(_) |
             Insn::PosMarkerAtBlockEnd(_) => {},
 
@@ -1185,7 +1185,7 @@ impl Insn {
             Insn::Not { .. } => "Not",
             Insn::Or { .. } => "Or",
             Insn::PatchPoint(..) => "PatchPoint",
-            Insn::PadPatchPoint => "PadPatchPoint",
+            Insn::PatchPointPad => "PatchPointPad",
             Insn::PosMarker(_) => "PosMarker",
             Insn::PosMarkerAtBlockEnd(_) => "PosMarkerAtBlockEnd",
             Insn::RShift { .. } => "RShift",
@@ -3970,8 +3970,8 @@ impl Assembler {
         self.push_insn(Insn::PatchPoint(Box::new(PatchPointData { target, invariant, version })));
     }
 
-    pub fn pad_patch_point(&mut self) {
-        self.push_insn(Insn::PadPatchPoint);
+    pub fn patch_point_pad(&mut self) {
+        self.push_insn(Insn::PatchPointPad);
     }
 
     pub fn boundary_pad(&mut self) {

zjit/src/backend/x86_64/mod.rs

@@ -1069,8 +1069,8 @@ impl Assembler {
 
                 Insn::Joz(..) | Insn::Jonz(..) => unreachable!("Joz/Jonz should be unused for now"),
 
-                Insn::PatchPoint(..) => unreachable!("PatchPoint should have been lowered to PadPatchPoint in x86_scratch_split"),
-                Insn::PadPatchPoint => {
+                Insn::PatchPoint(..) => unreachable!("PatchPoint should have been lowered to PatchPointPad in x86_scratch_split"),
+                Insn::PatchPointPad => {
                     emit_pad_after_patch_point(cb, last_patch_pos);
                     // This position is itself where a jump gets written on invalidation, so it
                     // becomes what following code has to keep its distance from.

zjit/src/codegen.rs

@@ -977,15 +977,15 @@ fn gen_patch_point(jit: &mut JITState, asm: &mut Assembler, function: &Function,
     asm.patch_point(Target::SideExit(Box::new(SideExitTarget { exit, reason: PatchPoint(invariant) })), invariant, jit.version);
 }
 
-/// This is used by scratch_split to lower PatchPoint into PadPatchPoint and PosMarker.
+/// This is used by scratch_split to lower PatchPoint into PatchPointPad and PosMarker.
 /// It's called at scratch_split so that we can use the Label after side-exit deduplication in compile_exits.
 pub fn split_patch_point(asm: &mut Assembler, target: &Target, invariant: Invariant, version: IseqVersionRef) {
     let Target::Label(exit_label) = *target else {
         unreachable!("PatchPoint's target should have been lowered to Target::Label by compile_exits: {target:?}");
     };
 
     // Fill nop instructions if the last patch point is too close.
-    asm.pad_patch_point();
+    asm.patch_point_pad();
 
     // Remember the current address as a patch point
     asm.pos_marker(move |code_ptr, cb| {