Merge 82e4779 into e0ae0bd

sway-ast/src/intrinsics.rs

@@ -35,6 +35,7 @@ pub enum Intrinsic {
     PtrSub,
     Smo,
     Not,
+    JmpToSsp,
 }
 
 impl fmt::Display for Intrinsic {
@@ -73,6 +74,7 @@ impl fmt::Display for Intrinsic {
             Intrinsic::PtrSub => "ptr_sub",
             Intrinsic::Smo => "smo",
             Intrinsic::Not => "not",
+            Intrinsic::JmpToSsp => "jmp_to_ssp",
         };
         write!(f, "{s}")
     }
@@ -115,6 +117,7 @@ impl Intrinsic {
             "__ptr_sub" => PtrSub,
             "__smo" => Smo,
             "__not" => Not,
+            "__jmp_to_ssp" => JmpToSsp,
             _ => return None,
         })
     }

sway-core/src/asm_generation/fuel/fuel_asm_builder.rs

@@ -305,6 +305,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                         arg2,
                         arg3,
                     } => self.compile_wide_modular_op(instr_val, op, result, arg1, arg2, arg3),
+                    FuelVmInstruction::JmpToSsp => self.compile_jmp_to_ssp(instr_val),
                 },
                 InstOp::GetElemPtr {
                     base,
@@ -1451,6 +1452,20 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         Ok(())
     }
 
+    fn compile_jmp_to_ssp(&mut self, instr_val: &Value) -> Result<(), CompileError> {
+        let owning_span = self.md_mgr.val_to_span(self.context, *instr_val);
+
+        self.cur_bytecode.push(Op {
+            owning_span,
+            opcode: Either::Left(VirtualOp::JMP(VirtualRegister::Constant(
+                ConstantRegister::StackStartPointer,
+            ))),
+            comment: "Jump to $ssp".into(),
+        });
+
+        Ok(())
+    }
+
     fn compile_smo(
         &mut self,
         instr_val: &Value,

sway-core/src/ir_generation/const_eval.rs

@@ -1111,6 +1111,7 @@ fn const_eval_intrinsic(
         | Intrinsic::StateStoreQuad
         | Intrinsic::Log
         | Intrinsic::Revert
+        | Intrinsic::JmpToSsp
         | Intrinsic::Smo => Err(ConstEvalError::CannotBeEvaluatedToConst {
             span: intrinsic.span.clone(),
         }),

sway-core/src/ir_generation/function.rs

@@ -1094,6 +1094,16 @@ impl<'eng> FnCompiler<'eng> {
                     .add_metadatum(context, span_md_idx);
                 Ok(TerminatorValue::new(val, context))
             }
+            Intrinsic::JmpToSsp => {
+                // The `revert` instruction
+                let span_md_idx = md_mgr.span_to_md(context, &span);
+                let val = self
+                    .current_block
+                    .append(context)
+                    .jmp_to_ssp()
+                    .add_metadatum(context, span_md_idx);
+                Ok(TerminatorValue::new(val, context))
+            }
             Intrinsic::PtrAdd | Intrinsic::PtrSub => {
                 let op = match kind {
                     Intrinsic::PtrAdd => BinaryOpKind::Add,

sway-core/src/language/ty/expression/intrinsic_function.rs

@@ -101,7 +101,7 @@ impl DebugWithEngines for TyIntrinsicFunctionKind {
 
 impl DeterministicallyAborts for TyIntrinsicFunctionKind {
     fn deterministically_aborts(&self, decl_engine: &DeclEngine, check_call_body: bool) -> bool {
-        matches!(self.kind, Intrinsic::Revert)
+        matches!(self.kind, Intrinsic::Revert | Intrinsic::JmpToSsp)
             || self
                 .arguments
                 .iter()

sway-core/src/semantic_analysis/ast_node/expression/intrinsic_function.rs

@@ -83,6 +83,9 @@ impl ty::TyIntrinsicFunctionKind {
             }
             Intrinsic::Smo => type_check_smo(handler, ctx, kind, arguments, type_arguments, span),
             Intrinsic::Not => type_check_not(handler, ctx, kind, arguments, type_arguments, span),
+            Intrinsic::JmpToSsp => {
+                type_check_jmp_to_ssp(handler, ctx, kind, arguments, type_arguments, span)
+            }
         }
     }
 }
@@ -1171,6 +1174,47 @@ fn type_check_revert(
     ))
 }
 
+/// Signature: `__jmp_to_ssp()`
+/// Description: Jumps to $ssp.
+/// Constraints: None.
+fn type_check_jmp_to_ssp(
+    handler: &Handler,
+    ctx: TypeCheckContext,
+    kind: sway_ast::Intrinsic,
+    arguments: Vec<Expression>,
+    type_arguments: Vec<TypeArgument>,
+    span: Span,
+) -> Result<(ty::TyIntrinsicFunctionKind, TypeId), ErrorEmitted> {
+    let type_engine = ctx.engines.te();
+    let engines = ctx.engines();
+
+    if !arguments.is_empty() {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumArgs {
+            name: kind.to_string(),
+            expected: 0,
+            span,
+        }));
+    }
+
+    if !type_arguments.is_empty() {
+        return Err(handler.emit_err(CompileError::IntrinsicIncorrectNumTArgs {
+            name: kind.to_string(),
+            expected: 0,
+            span,
+        }));
+    }
+
+    Ok((
+        ty::TyIntrinsicFunctionKind {
+            kind,
+            arguments: vec![],
+            type_arguments: vec![],
+            span,
+        },
+        type_engine.insert(engines, TypeInfo::Tuple(vec![]), None),
+    ))
+}
+
 /// Signature: `__ptr_add(ptr: raw_ptr, offset: u64)`
 /// Description: Adds `offset` to the raw value of pointer `ptr`.
 /// Constraints: None.

sway-core/src/semantic_analysis/cei_pattern_analysis.rs

@@ -608,7 +608,7 @@ fn effects_of_intrinsic(intr: &sway_ast::Intrinsic) -> HashSet<Effect> {
         StateClear | StateStoreWord | StateStoreQuad => HashSet::from([Effect::StorageWrite]),
         StateLoadWord | StateLoadQuad => HashSet::from([Effect::StorageRead]),
         Smo => HashSet::from([Effect::OutputMessage]),
-        Revert | IsReferenceType | IsStrArray | SizeOfType | SizeOfVal | SizeOfStr
+        Revert | JmpToSsp | IsReferenceType | IsStrArray | SizeOfType | SizeOfVal | SizeOfStr
         | AssertIsStrArray | ToStrArray | Eq | Gt | Lt | Gtf | AddrOf | Log | Add | Sub | Mul
         | Div | And | Or | Xor | Mod | Rsh | Lsh | PtrAdd | PtrSub | Not => HashSet::new(),
     }

sway-ir/src/analysis/memory_utils.rs

@@ -201,7 +201,7 @@ pub fn get_loaded_ptr_values(context: &Context, val: Value) -> Vec<Value> {
         InstOp::Store { dst_val_ptr: _, .. } => vec![],
         InstOp::FuelVm(FuelVmInstruction::Gtf { .. })
         | InstOp::FuelVm(FuelVmInstruction::ReadRegister(_))
-        | InstOp::FuelVm(FuelVmInstruction::Revert(_)) => vec![],
+        | InstOp::FuelVm(FuelVmInstruction::Revert(_) | FuelVmInstruction::JmpToSsp) => vec![],
         InstOp::FuelVm(FuelVmInstruction::WideUnaryOp { arg, .. }) => vec![*arg],
         InstOp::FuelVm(FuelVmInstruction::WideBinaryOp { arg1, arg2, .. })
         | InstOp::FuelVm(FuelVmInstruction::WideCmpOp { arg1, arg2, .. }) => {
@@ -252,6 +252,7 @@ pub fn get_stored_ptr_values(context: &Context, val: Value) -> Vec<Value> {
             | FuelVmInstruction::Log { .. }
             | FuelVmInstruction::ReadRegister(_)
             | FuelVmInstruction::Revert(_)
+            | FuelVmInstruction::JmpToSsp
             | FuelVmInstruction::Smo { .. }
             | FuelVmInstruction::StateClear { .. } => vec![],
             FuelVmInstruction::StateLoadQuadWord { load_val, .. } => vec![*load_val],

sway-ir/src/instruction.rs

@@ -194,6 +194,7 @@ pub enum FuelVmInstruction {
         arg1: Value,
         arg2: Value,
     },
+    JmpToSsp,
 }
 
 /// Comparison operations.
@@ -298,7 +299,7 @@ impl InstOp {
             // These are all terminators which don't return, essentially.  No type.
             InstOp::Branch(_)
             | InstOp::ConditionalBranch { .. }
-            | InstOp::FuelVm(FuelVmInstruction::Revert(..))
+            | InstOp::FuelVm(FuelVmInstruction::Revert(..) | FuelVmInstruction::JmpToSsp)
             | InstOp::Ret(..) => None,
 
             // No-op is also no-type.
@@ -408,6 +409,7 @@ impl InstOp {
                 } => vec![*log_val, *log_id],
                 FuelVmInstruction::ReadRegister(_) => vec![],
                 FuelVmInstruction::Revert(v) => vec![*v],
+                FuelVmInstruction::JmpToSsp => vec![],
                 FuelVmInstruction::Smo {
                     recipient,
                     message,
@@ -544,6 +546,7 @@ impl InstOp {
                 }
                 FuelVmInstruction::ReadRegister { .. } => (),
                 FuelVmInstruction::Revert(revert_val) => replace(revert_val),
+                FuelVmInstruction::JmpToSsp => (),
                 FuelVmInstruction::Smo {
                     recipient,
                     message,
@@ -629,7 +632,7 @@ impl InstOp {
             | InstOp::FuelVm(FuelVmInstruction::StateLoadQuadWord { .. })
             | InstOp::FuelVm(FuelVmInstruction::StateStoreQuadWord { .. })
             | InstOp::FuelVm(FuelVmInstruction::StateStoreWord { .. })
-            | InstOp::FuelVm(FuelVmInstruction::Revert(..))
+            | InstOp::FuelVm(FuelVmInstruction::Revert(..) | FuelVmInstruction::JmpToSsp)
             | InstOp::MemCopyBytes { .. }
             | InstOp::MemCopyVal { .. }
             | InstOp::Store { .. }
@@ -1072,6 +1075,18 @@ impl<'a, 'eng> InstructionInserter<'a, 'eng> {
         revert_val
     }
 
+    pub fn jmp_to_ssp(self) -> Value {
+        let jmp_to_ssp_val = Value::new_instruction(
+            self.context,
+            self.block,
+            InstOp::FuelVm(FuelVmInstruction::JmpToSsp),
+        );
+        self.context.blocks[self.block.0]
+            .instructions
+            .push(jmp_to_ssp_val);
+        jmp_to_ssp_val
+    }
+
     pub fn smo(self, recipient: Value, message: Value, message_size: Value, coins: Value) -> Value {
         insert_instruction!(
             self,

sway-ir/src/optimize/fn_dedup.rs

@@ -154,6 +154,7 @@ fn hash_fn(context: &Context, function: Function, eq_class: &mut EqClass) -> u64
                     crate::FuelVmInstruction::Log { log_ty, .. } => log_ty.hash(state),
                     crate::FuelVmInstruction::ReadRegister(reg) => reg.hash(state),
                     crate::FuelVmInstruction::Revert(_)
+                    | crate::FuelVmInstruction::JmpToSsp
                     | crate::FuelVmInstruction::Smo { .. }
                     | crate::FuelVmInstruction::StateClear { .. }
                     | crate::FuelVmInstruction::StateLoadQuadWord { .. }

sway-ir/src/optimize/inline.rs

@@ -535,6 +535,7 @@ fn inline_instruction(
                     new_block.append(context).read_register(reg)
                 }
                 FuelVmInstruction::Revert(val) => new_block.append(context).revert(map_value(val)),
+                FuelVmInstruction::JmpToSsp => new_block.append(context).jmp_to_ssp(),
                 FuelVmInstruction::Smo {
                     recipient,
                     message,

sway-ir/src/printer.rs

@@ -656,6 +656,9 @@ fn instruction_to_doc<'a>(
                         Doc::text(format!("revert {}", namer.name(context, v),))
                             .append(md_namer.md_idx_to_doc(context, metadata)),
                     )),
+                FuelVmInstruction::JmpToSsp => Doc::line(
+                    Doc::text("jmp_to_ssp").append(md_namer.md_idx_to_doc(context, metadata)),
+                ),
                 FuelVmInstruction::Smo {
                     recipient,
                     message,

sway-ir/src/verify.rs

@@ -233,6 +233,7 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
                             log_id,
                         } => self.verify_log(log_val, log_ty, log_id)?,
                         FuelVmInstruction::ReadRegister(_) => (),
+                        FuelVmInstruction::JmpToSsp => (),
                         FuelVmInstruction::Revert(val) => self.verify_revert(val)?,
                         FuelVmInstruction::Smo {
                             recipient,