u256 implementation

Cargo.toml

@@ -24,11 +24,7 @@ members = [
     "swayfmt",
     "test",
 ]
-exclude = [
-    "examples/*",
-    "swayfmt/test_macros",
-    "forc-test/test_data"
-]
+exclude = ["examples/*", "swayfmt/test_macros", "forc-test/test_data"]
 
 [workspace.dependencies]
 fuel-asm = "0.34.1"

forc-plugins/forc-doc/src/render/item/type_anchor.rs

@@ -96,6 +96,7 @@ pub(crate) fn render_type_anchor(
                 IntegerBits::Sixteen => "u16",
                 IntegerBits::ThirtyTwo => "u32",
                 IntegerBits::SixtyFour => "u64",
+                IntegerBits::V256 => "u256",
             };
             Ok(box_html! {
                 : uint;

sway-ast/src/literal.rs

@@ -25,6 +25,7 @@ pub enum LitIntType {
     U16,
     U32,
     U64,
+    U256,
     I8,
     I16,
     I32,

sway-core/Cargo.toml

@@ -27,9 +27,12 @@ im = "15.0"
 itertools = "0.10"
 lazy_static = "1.4"
 miden-core = "0.3.0"
+num-bigint = { version = "0.4.3", features = ["serde"] }
+num-traits = "0.2.16"
 pest = "2.1.3"
 pest_derive = "2.1"
 petgraph = "0.6"
+prettydiff = "0.6.4"
 rustc-hash = "1.1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.91"
@@ -47,5 +50,6 @@ tracing = "0.1"
 uint = "0.9"
 vec1 = "1.8.0"
 
+
 [target.'cfg(not(target_os = "macos"))'.dependencies]
 sysinfo = "0.29.0"

sway-core/src/abi_generation/evm_abi.rs

@@ -89,6 +89,7 @@ pub fn abi_str(type_info: &TypeInfo, type_engine: &TypeEngine, decl_engine: &Dec
             IntegerBits::Sixteen => "uint16",
             IntegerBits::ThirtyTwo => "uint32",
             IntegerBits::SixtyFour => "uint64",
+            IntegerBits::V256 => todo!(),
         }
         .into(),
         Boolean => "bool".into(),
@@ -149,6 +150,7 @@ pub fn abi_param_type(
             IntegerBits::Sixteen => ethabi::ParamType::Uint(16),
             IntegerBits::ThirtyTwo => ethabi::ParamType::Uint(32),
             IntegerBits::SixtyFour => ethabi::ParamType::Uint(64),
+            IntegerBits::V256 => todo!(),
         },
         Boolean => ethabi::ParamType::Bool,
         B256 => ethabi::ParamType::Uint(256),

sway-core/src/abi_generation/fuel_abi.rs

@@ -790,6 +790,7 @@ impl TypeInfo {
                 IntegerBits::Sixteen => "u16",
                 IntegerBits::ThirtyTwo => "u32",
                 IntegerBits::SixtyFour => "u64",
+                IntegerBits::V256 => "u256",
             }
             .into(),
             Boolean => "bool".into(),

sway-core/src/asm_generation/from_ir.rs

@@ -135,13 +135,19 @@ fn compile_module_to_asm(
                 println!("{abstract_program}\n");
             }
 
+            // let before = abstract_program.to_string();
+
             let allocated_program = check!(
                 CompileResult::from(abstract_program.into_allocated_program()),
                 return err(warnings, errors),
                 warnings,
                 errors
             );
 
+            // let after = allocated_program.to_string();
+            // println!("############################################# into_allocated_program");
+            // println!("{}", prettydiff::diff_lines(&before, &after));
+
             if build_config
                 .map(|cfg| cfg.print_intermediate_asm)
                 .unwrap_or(false)

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

@@ -24,6 +24,8 @@ pub struct AbstractInstructionSet {
 
 impl AbstractInstructionSet {
     pub(crate) fn optimize(self) -> AbstractInstructionSet {
+        // println!("AbstractInstructionSet:: Before:");
+        // println!("{}", self.to_string());
         self.remove_sequential_jumps()
             .remove_redundant_moves()
             .remove_unused_ops()
@@ -57,6 +59,8 @@ impl AbstractInstructionSet {
     }
 
     fn remove_redundant_moves(mut self) -> AbstractInstructionSet {
+        // let before = self.to_string();
+
         // This has a lot of room for improvement.
         //
         // For now it is just removing MOVEs to registers which are _never_ used.  It doesn't
@@ -107,6 +111,9 @@ impl AbstractInstructionSet {
             }
         }
 
+        // let after = self.to_string();
+        // println!("######################################### remove_redundant_moves");
+        // println!("{}", prettydiff::diff_lines(&before, &after));
         self
     }
 

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

@@ -40,6 +40,8 @@ impl AllocatedAbstractInstructionSet {
     /// Typically there will be only one of each but the code here allows for nested sections or
     /// even overlapping sections.
     pub(crate) fn emit_pusha_popa(mut self) -> Self {
+        // let before = self.to_string();
+
         // Gather the sets of used registers per section.  Using a fold here because it's actually
         // simpler to manage.  We use a HashSet to keep track of the active section labels and then
         // build a HashMap of Label to HashSet of registers.
@@ -171,6 +173,12 @@ impl AllocatedAbstractInstructionSet {
             new_ops
         });
 
+        // let after = self.to_string();
+        // println!(
+        //     "################################################################# emit_pusha_popa"
+        // );
+        // println!("{}", prettydiff::diff_lines(&before, &after));
+
         self
     }
 

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

@@ -99,8 +99,20 @@ impl Entry {
         match &constant.value {
             ConstantValue::Undef | ConstantValue::Unit => Entry::new_word(0, size, name),
             ConstantValue::Bool(b) => Entry::new_word(u64::from(*b), size, name),
-            ConstantValue::Uint(u) => Entry::new_word(*u, size, name),
-
+            ConstantValue::Uint(u) => match constant.ty.get_uint_width(context) {
+                Some(width) if width <= 64 => {
+                    let u = u64::try_from(u).unwrap();
+                    Entry::new_word(u, size, name)
+                }
+                Some(256) => {
+                    let number_bytes = u.to_bytes_be();
+                    let mut bytes = vec![0u8; 32 - number_bytes.len()];
+                    bytes.extend(number_bytes);
+                    assert!(bytes.len() == size.unwrap());
+                    Entry::new_byte_array(bytes, size, name)
+                }
+                _ => todo!(),
+            },
             ConstantValue::B256(bs) => Entry::new_byte_array(bs.to_vec(), size, name),
             ConstantValue::String(bs) => Entry::new_byte_array(bs.clone(), size, name),