Upgrade to new asm syntax

CHANGELOG.md

@@ -28,18 +28,18 @@
     - Remove `FftConfig`; move its contents to `FftField`.
 - [\#383](https://github.com/arkworks-rs/algebra/pull/383) (arc-ff) Rename `BigInteger::add_nocarry` to `add_with_carry` and `sub_noborrow` to `sub_with_borrow`.
 
-
 ### Features
 
-- [\#321](https://github.com/arkworks-rs/algebra/pull/321) (`ark-ff`) Change bigint conversions to impl `From` instead of `Into`.
 - [\#301](https://github.com/arkworks-rs/algebra/pull/301) (`ark-ec`) Add `GLVParameters` trait definition.
 - [\#312](https://github.com/arkworks-rs/algebra/pull/312) (`ark-ec`) Add `is_in_correct_subgroup_assuming_on_curve` for all `SWModelParameters`.
+- [\#321](https://github.com/arkworks-rs/algebra/pull/321) (`ark-ff`) Change bigint conversions to impl `From` instead of `Into`.
 - [\#348](https://github.com/arkworks-rs/algebra/pull/348) (`ark-ec`) Add `msm:{Fixed,Variable}Base:msm_checked_len`.
 - [\#364](https://github.com/arkworks-rs/algebra/pull/364) (`ark-ec`) Add `ChunkedPippenger` to variable-base MSM.
 - [\#371](https://github.com/arkworks-rs/algebra/pull/371) (`ark-serialize`) Add serialization impls for arrays
 
 ### Improvements
 
+- [\#306](https://github.com/arkworks-rs/algebra/pull/306) (`ark-ff`, `ark-ff-asm`) Make the assembly backend available on `stable`.
 - [\#339](https://github.com/arkworks-rs/algebra/pull/339) (`ark-ff`) Remove duplicated code from `test_field` module and replace its usage with `ark-test-curves` crate.
 - [\#352](https://github.com/arkworks-rs/algebra/pull/352) (`ark-ff`) Update `QuadExtField::sqrt` for better performance.
 - [\#357](https://github.com/arkworks-rs/algebra/pull/357) (`ark-poly`) Speedup division by vanishing polynomials for dense polynomials.

ff-asm/src/context/data_structures.rs

@@ -0,0 +1,68 @@
+use std::fmt;
+
+#[derive(Clone)]
+pub enum AssemblyVar {
+    Memory(String),
+    Variable(String),
+    Fixed(String),
+}
+
+impl AssemblyVar {
+    pub fn memory_access(&self, offset: usize) -> Option<AssemblyVar> {
+        match self {
+            Self::Variable(a) | Self::Fixed(a) => Some(Self::Memory(format!("{}({})", offset, a))),
+            _ => None,
+        }
+    }
+
+    pub fn memory_accesses(&self, range: usize) -> Vec<AssemblyVar> {
+        (0..range)
+            .map(|i| {
+                let offset = i * 8;
+                self.memory_access(offset).unwrap()
+            })
+            .collect()
+    }
+}
+
+impl fmt::Display for AssemblyVar {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match self {
+            Self::Variable(a) | Self::Fixed(a) | Self::Memory(a) => write!(f, "{}", a),
+        }
+    }
+}
+
+impl<'a> From<Declaration<'a>> for AssemblyVar {
+    fn from(other: Declaration<'a>) -> Self {
+        Self::Variable(format!("{{{}}}", other.name))
+    }
+}
+
+impl<'a> From<Register<'a>> for AssemblyVar {
+    fn from(other: Register<'a>) -> Self {
+        Self::Fixed(format!("%{}", other.0))
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct Register<'a>(pub &'a str);
+impl fmt::Display for Register<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(f, "\"{}\"", self.0)
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct Declaration<'a> {
+    /// Name of the assembly template variable declared by `self`.
+    pub name: &'a str,
+    /// Rust expression whose value is declared in `self`.
+    pub expr: &'a str,
+}
+
+impl fmt::Display for Declaration<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(f, "{} = in(reg) {},", self.name, self.expr)
+    }
+}

ff-asm/src/context/mod.rs

@@ -0,0 +1,117 @@
+mod data_structures;
+pub use data_structures::*;
+
+#[derive(Clone)]
+pub struct Context<'a> {
+    assembly_instructions: Vec<String>,
+    declarations: Vec<Declaration<'a>>,
+    used_registers: Vec<Register<'a>>,
+}
+
+impl<'a> Context<'a> {
+    pub const RAX: Register<'static> = Register("rax");
+    pub const RSI: Register<'static> = Register("rsi");
+    pub const RCX: Register<'static> = Register("rcx");
+    pub const RDX: Register<'static> = Register("rdx");
+
+    pub const R: [Register<'static>; 8] = [
+        Register("r8"),
+        Register("r9"),
+        Register("r10"),
+        Register("r11"),
+        Register("r12"),
+        Register("r13"),
+        Register("r14"),
+        Register("r15"),
+    ];
+
+    pub fn new() -> Self {
+        Self {
+            assembly_instructions: Vec::new(),
+            declarations: Vec::new(),
+            used_registers: Vec::new(),
+        }
+    }
+
+    fn find(&self, name: &str) -> Option<&Declaration<'_>> {
+        self.declarations.iter().find(|item| item.name == name)
+    }
+
+    fn append(&mut self, other: &str) {
+        self.assembly_instructions.push(format!("\"{}\",", other));
+    }
+
+    fn instructions_to_string(&self) -> String {
+        self.assembly_instructions.join("\n")
+    }
+
+    fn get_decl_name(&self, name: &str) -> Option<&Declaration<'_>> {
+        self.find(name)
+    }
+
+    pub fn get_decl(&self, name: &str) -> Declaration<'_> {
+        *self.get_decl_name(name).unwrap()
+    }
+
+    pub fn get_decl_with_fallback(&self, name: &str, fallback_name: &str) -> Declaration<'_> {
+        self.get_decl_name(name)
+            .copied()
+            .unwrap_or_else(|| self.get_decl(fallback_name))
+    }
+
+    pub fn add_declaration(&mut self, name: &'a str, expr: &'a str) {
+        let declaration = Declaration { name, expr };
+        self.declarations.push(declaration);
+    }
+
+    pub fn add_buffer(&mut self, extra_reg: usize) {
+        self.append(&format!(
+            "let mut spill_buffer = core::mem::MaybeUninit::<[u64; {}]>::uninit();",
+            extra_reg
+        ));
+    }
+
+    pub fn add_asm(&mut self, asm_instructions: &[String]) {
+        for instruction in asm_instructions {
+            self.append(instruction)
+        }
+    }
+
+    pub fn add_clobbers(&mut self, clobbers: impl Iterator<Item = Register<'a>>) {
+        for clobber in clobbers {
+            self.add_clobber(clobber)
+        }
+    }
+
+    pub fn add_clobber(&mut self, clobber: Register<'a>) {
+        self.used_registers.push(clobber);
+    }
+
+    pub fn build(self) -> String {
+        let declarations: String = self
+            .declarations
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>()
+            .join("\n");
+        let clobbers = self
+            .used_registers
+            .iter()
+            .map(|l| format!("out({}) _,", l))
+            .collect::<Vec<String>>()
+            .join("\n");
+        let options = "options(att_syntax)".to_string();
+        let assembly = self.instructions_to_string();
+        [
+            "unsafe {".to_string(),
+            "ark_std::arch::asm!(".to_string(),
+            assembly,
+            declarations,
+            clobbers,
+            options,
+            ")".to_string(),
+            "}".to_string(),
+        ]
+        .join("\n")
+    }
+}