Merge branch 'master' into bitzoic-b256-bytez-conversion

sway-ast/src/expr/op_code.rs

@@ -340,6 +340,7 @@ define_op_codes!(
     (ECOP, ECOPOpcode, "ecop", (dst_addr: reg, curve: reg, operation: reg, src_addr: reg)),
     (EPAR, EPAROpcode, "epar", (ret: reg, curve: reg, groups_of_points: reg, addr: reg)),
     /* Other Instructions */
+    (Ecal, EcalOpcode, "ecal", (reg_a: reg, reg_b: reg, reg_c: reg, reg_d: reg)),
     (Flag, FlagOpcode, "flag", (value: reg)),
     (Gm, GmOpcode, "gm", (ret: reg, op: imm)),
     (

sway-core/src/asm_lang/allocated_ops.rs

@@ -281,6 +281,12 @@ pub(crate) enum AllocatedOpcode {
     ),
 
     /* Other Instructions */
+    ECAL(
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+        AllocatedRegister,
+    ),
     FLAG(AllocatedRegister),
     GM(AllocatedRegister, VirtualImmediate18),
     GTF(AllocatedRegister, AllocatedRegister, VirtualImmediate12),
@@ -408,6 +414,7 @@ impl AllocatedOpcode {
             EPAR(r1, _r2, _r3, _r4) => vec![r1],
 
             /* Other Instructions */
+            ECAL(_r1, _r2, _r3, _r4) => vec![],
             FLAG(_r1) => vec![],
             GM(r1, _imm) => vec![r1],
             GTF(r1, _r2, _i) => vec![r1],
@@ -539,6 +546,7 @@ impl fmt::Display for AllocatedOpcode {
             EPAR(a, b, c, d) => write!(fmtr, "epar {a} {b} {c} {d}"),
 
             /* Other Instructions */
+            ECAL(a, b, c, d) => write!(fmtr, "ecal {a} {b} {c} {d}"),
             FLAG(a) => write!(fmtr, "flag {a}"),
             GM(a, b) => write!(fmtr, "gm   {a} {b}"),
             GTF(a, b, c) => write!(fmtr, "gtf  {a} {b} {c}"),
@@ -775,6 +783,9 @@ impl AllocatedOp {
             }
 
             /* Other Instructions */
+            ECAL(a, b, c, d) => {
+                op::ECAL::new(a.to_reg_id(), b.to_reg_id(), c.to_reg_id(), d.to_reg_id()).into()
+            }
             FLAG(a) => op::FLAG::new(a.to_reg_id()).into(),
             GM(a, b) => op::GM::new(a.to_reg_id(), b.value().into()).into(),
             GTF(a, b, c) => op::GTF::new(a.to_reg_id(), b.to_reg_id(), c.value().into()).into(),

sway-core/src/asm_lang/mod.rs

@@ -596,6 +596,10 @@ impl Op {
                 let (r1, r2, r3, i0) = three_regs_imm_06(handler, args, immediate, whole_op_span)?;
                 VirtualOp::LDC(r1, r2, r3, i0)
             }
+            "bldd" => {
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::BLDD(r1, r2, r3, r4)
+            }
             "log" => {
                 let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
                 VirtualOp::LOG(r1, r2, r3, r4)
@@ -684,6 +688,10 @@ impl Op {
             }
 
             /* Other Instructions */
+            "ecal" => {
+                let (r1, r2, r3, r4) = four_regs(handler, args, immediate, whole_op_span)?;
+                VirtualOp::ECAL(r1, r2, r3, r4)
+            }
             "flag" => {
                 let r1 = single_reg(handler, args, immediate, whole_op_span)?;
                 VirtualOp::FLAG(r1)
@@ -1240,6 +1248,7 @@ impl fmt::Display for VirtualOp {
             EPAR(a, b, c, d) => write!(fmtr, "epar {a} {b} {c} {d}"),
 
             /* Other Instructions */
+            ECAL(a, b, c, d) => write!(fmtr, "ecal {a} {b} {c} {d}"),
             FLAG(a) => write!(fmtr, "flag {a}"),
             GM(a, b) => write!(fmtr, "gm {a} {b}"),
             GTF(a, b, c) => write!(fmtr, "gtf {a} {b} {c}"),

sway-core/src/asm_lang/virtual_ops.rs

@@ -232,6 +232,12 @@ pub(crate) enum VirtualOp {
     ),
 
     /* Other Instructions */
+    ECAL(
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+        VirtualRegister,
+    ),
     FLAG(VirtualRegister),
     GM(VirtualRegister, VirtualImmediate18),
     GTF(VirtualRegister, VirtualRegister, VirtualImmediate12),
@@ -355,6 +361,7 @@ impl VirtualOp {
             EPAR(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
 
             /* Other Instructions */
+            ECAL(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             FLAG(r1) => vec![r1],
             GM(r1, _imm) => vec![r1],
             GTF(r1, r2, _i) => vec![r1, r2],
@@ -479,6 +486,8 @@ impl VirtualOp {
             | K256(_, _, _)
             | S256(_, _, _)
             | ECOP(_, _, _, _)
+            // Other instructions
+            | ECAL(_, _, _, _)
             | FLAG(_)
             // Virtual OPs
             | BLOB(_)
@@ -588,6 +597,7 @@ impl VirtualOp {
             | S256(_, _, _)
             | ECOP(_, _, _, _)
             | EPAR(_, _, _, _)
+            | ECAL(_, _, _, _)
             | GM(_, _)
             | GTF(_, _, _)
             | BLOB(_)
@@ -709,6 +719,7 @@ impl VirtualOp {
             EPAR(_r1, r2, r3, r4) => vec![r2, r3, r4],
 
             /* Other Instructions */
+            ECAL(r1, r2, r3, r4) => vec![r1, r2, r3, r4],
             FLAG(r1) => vec![r1],
             GM(_r1, _imm) => vec![],
             GTF(_r1, r2, _i) => vec![r2],
@@ -833,6 +844,7 @@ impl VirtualOp {
             EPAR(r1, _r2, _r3, _r4) => vec![r1],
 
             /* Other Instructions */
+            ECAL(_r1, _r2, _r3, _r4) => vec![],
             FLAG(_r1) => vec![],
             GM(r1, _imm) => vec![r1],
             GTF(r1, _r2, _i) => vec![r1],
@@ -1292,6 +1304,12 @@ impl VirtualOp {
             ),
 
             /* Other Instructions */
+            ECAL(r1, r2, r3, r4) => Self::ECAL(
+                update_reg(reg_to_reg_map, r1),
+                update_reg(reg_to_reg_map, r2),
+                update_reg(reg_to_reg_map, r3),
+                update_reg(reg_to_reg_map, r4),
+            ),
             FLAG(r1) => Self::FLAG(update_reg(reg_to_reg_map, r1)),
             GM(r1, i) => Self::GM(update_reg(reg_to_reg_map, r1), i.clone()),
             GTF(r1, r2, i) => Self::GTF(
@@ -1785,6 +1803,12 @@ impl VirtualOp {
             ),
 
             /* Other Instructions */
+            ECAL(reg1, reg2, reg3, reg4) => AllocatedOpcode::ECAL(
+                map_reg(&mapping, reg1),
+                map_reg(&mapping, reg2),
+                map_reg(&mapping, reg3),
+                map_reg(&mapping, reg4),
+            ),
             FLAG(reg) => AllocatedOpcode::FLAG(map_reg(&mapping, reg)),
             GM(reg, imm) => AllocatedOpcode::GM(map_reg(&mapping, reg), imm.clone()),
             GTF(reg1, reg2, imm) => AllocatedOpcode::GTF(

sway-core/src/language/ty/code_block.rs

@@ -1,6 +1,6 @@
 use crate::{
     decl_engine::*, engine_threading::*, language::ty::*, semantic_analysis::TypeCheckContext,
-    type_system::*,
+    transform::AllowDeprecatedState, type_system::*,
 };
 use serde::{Deserialize, Serialize};
 use std::hash::Hasher;
@@ -13,6 +13,19 @@ pub struct TyCodeBlock {
     pub(crate) whole_block_span: Span,
 }
 
+impl TyCodeBlock {
+    pub(crate) fn check_deprecated(
+        &self,
+        engines: &Engines,
+        handler: &Handler,
+        allow_deprecated: &mut AllowDeprecatedState,
+    ) {
+        for n in self.contents.iter() {
+            n.check_deprecated(engines, handler, allow_deprecated);
+        }
+    }
+}
+
 impl Default for TyCodeBlock {
     fn default() -> Self {
         Self {