Rename sarg__ to sarg_t

cranelift/codegen/meta/src/cdsl/types.rs

@@ -424,7 +424,7 @@ impl SpecialType {
                 flags can be tested with a :type:`floatcc` condition code.",
             ),
             SpecialType::StructArgument => {
-                String::from("After legalization sarg__ arguments will get this type.")
+                String::from("After legalization sarg_t arguments will get this type.")
             }
         }
     }
@@ -452,7 +452,7 @@ impl fmt::Display for SpecialType {
         match *self {
             SpecialType::Flag(shared_types::Flag::IFlags) => write!(f, "iflags"),
             SpecialType::Flag(shared_types::Flag::FFlags) => write!(f, "fflags"),
-            SpecialType::StructArgument => write!(f, "sarg__"),
+            SpecialType::StructArgument => write!(f, "sarg_t"),
         }
     }
 }

cranelift/codegen/meta/src/isa/x86/encodings.rs

@@ -465,7 +465,7 @@ fn define_moves(e: &mut PerCpuModeEncodings, shared_defs: &SharedDefinitions, r:
     let sextend = shared.by_name("sextend");
     let set_pinned_reg = shared.by_name("set_pinned_reg");
     let uextend = shared.by_name("uextend");
-    let dummy_sarg__ = shared.by_name("dummy_sarg__");
+    let dummy_sarg_t = shared.by_name("dummy_sarg_t");
 
     // Shorthands for recipes.
     let rec_copysp = r.template("copysp");
@@ -483,7 +483,7 @@ fn define_moves(e: &mut PerCpuModeEncodings, shared_defs: &SharedDefinitions, r:
     let rec_umr_reg_to_ssa = r.template("umr_reg_to_ssa");
     let rec_urm_noflags = r.template("urm_noflags");
     let rec_urm_noflags_abcd = r.template("urm_noflags_abcd");
-    let rec_dummy_sarg__ = r.recipe("dummy_sarg__");
+    let rec_dummy_sarg_t = r.recipe("dummy_sarg_t");
 
     // The pinned reg is fixed to a certain value entirely user-controlled, so it generates nothing!
     e.enc64_rec(get_pinned_reg.bind(I64), rec_get_pinned_reg, 0);
@@ -750,7 +750,7 @@ fn define_moves(e: &mut PerCpuModeEncodings, shared_defs: &SharedDefinitions, r:
         rec_furm_reg_to_ssa.opcodes(&MOVSS_LOAD),
     );
 
-    e.enc_32_64_rec(dummy_sarg__, rec_dummy_sarg__, 0);
+    e.enc_32_64_rec(dummy_sarg_t, rec_dummy_sarg_t, 0);
 }
 
 #[inline(never)]

cranelift/codegen/meta/src/isa/x86/recipes.rs

@@ -1271,7 +1271,7 @@ pub(crate) fn define<'shared>(
     }
 
     recipes.add_recipe(
-        EncodingRecipeBuilder::new("dummy_sarg__", &formats.nullary, 0)
+        EncodingRecipeBuilder::new("dummy_sarg_t", &formats.nullary, 0)
             .operands_out(vec![Stack::new(gpr)])
             .emit(""),
     );

cranelift/codegen/meta/src/shared/instructions.rs

@@ -1870,14 +1870,14 @@ pub(crate) fn define(
             .specials(vec![crate::cdsl::types::SpecialType::StructArgument])
             .build(),
     );
-    let sarg__ = &Operand::new("sarg__", Sarg);
+    let sarg_t = &Operand::new("sarg_t", Sarg);
 
     // FIXME remove once the old style codegen backends are removed.
     ig.push(
         Inst::new(
-            "dummy_sarg__",
+            "dummy_sarg_t",
             r#"
-        This creates a sarg__
+        This creates a sarg_t
 
         This instruction is internal and should not be created by
         Cranelift users.
@@ -1885,7 +1885,7 @@ pub(crate) fn define(
             &formats.nullary,
         )
         .operands_in(vec![])
-        .operands_out(vec![sarg__]),
+        .operands_out(vec![sarg_t]),
     );
 
     let src = &Operand::new("src", &imm.regunit);

cranelift/codegen/src/ir/types.rs

@@ -343,7 +343,7 @@ impl Display for Type {
             f.write_str(match *self {
                 IFLAGS => "iflags",
                 FFLAGS => "fflags",
-                SARG__ => "sarg__",
+                SARG_T => "sarg_t",
                 INVALID => panic!("INVALID encountered"),
                 _ => panic!("Unknown Type(0x{:x})", self.0),
             })

cranelift/codegen/src/isa/aarch64/lower_inst.rs

@@ -2152,7 +2152,7 @@ pub(crate) fn lower_insn_to_regs<C: LowerCtx<I = Inst>>(
             panic!("x86-specific opcode in supposedly arch-neutral IR!");
         }
 
-        Opcode::DummySarg => unreachable!(),
+        Opcode::DummySargT => unreachable!(),
 
         Opcode::AvgRound => unimplemented!(),
         Opcode::Iabs => unimplemented!(),

cranelift/codegen/src/isa/x86/abi.rs

@@ -118,7 +118,7 @@ impl ArgAssigner for Args {
             let loc = ArgumentLoc::Stack(self.offset as i32);
             self.offset += size;
             debug_assert!(self.offset <= i32::MAX as u32);
-            return ArgAction::AssignAndChangeType(loc, types::SARG__);
+            return ArgAction::AssignAndChangeType(loc, types::SARG_T);
         }
 
         let ty = arg.value_type;

cranelift/codegen/src/legalizer/boundary.rs

@@ -127,7 +127,7 @@ fn legalize_entry_params(func: &mut Function, entry: Block) {
                 let dummy = pos
                     .func
                     .dfg
-                    .append_block_param(entry, crate::ir::types::SARG__);
+                    .append_block_param(entry, crate::ir::types::SARG_T);
                 pos.func.locations[dummy] = ValueLoc::Stack(ss);
                 abi_arg += 1;
                 continue;
@@ -1127,7 +1127,7 @@ fn spill_call_arguments(pos: &mut FuncCursor, isa: &dyn TargetIsa) -> bool {
 
             let libc_memcpy = import_memcpy(pos.func, pointer_type);
             pos.ins().call(libc_memcpy, &[dest, src, size]);
-            pos.ins().dummy_sarg__()
+            pos.ins().dummy_sarg_t()
         } else {
             // Non struct argument
             pos.ins().spill(arg)