Merge pull request RustPython#4341 from evilpie/jit-tuple

Support variable exchange (aka basic tuple support)

Author: youknowone

jit/src/instructions.rs

@@ -26,6 +26,7 @@ enum JitValue {
     Float(Value),
     Bool(Value),
     None,
+    Tuple(Vec<JitValue>),
 }
 
 impl JitValue {
@@ -42,14 +43,14 @@ impl JitValue {
             JitValue::Int(_) => Some(JitType::Int),
             JitValue::Float(_) => Some(JitType::Float),
             JitValue::Bool(_) => Some(JitType::Bool),
-            JitValue::None => None,
+            JitValue::None | JitValue::Tuple(_) => None,
         }
     }
 
     fn into_value(self) -> Option<Value> {
         match self {
             JitValue::Int(val) | JitValue::Float(val) | JitValue::Bool(val) => Some(val),
-            JitValue::None => None,
+            JitValue::None | JitValue::Tuple(_) => None,
         }
     }
 }
@@ -88,6 +89,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         compiler
     }
 
+    fn pop_multiple(&mut self, count: usize) -> Vec<JitValue> {
+        let stack_len = self.stack.len();
+        self.stack.drain(stack_len - count..).collect()
+    }
+
     fn store_variable(
         &mut self,
         idx: bytecode::NameIdx,
@@ -126,6 +132,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             }
             JitValue::Bool(val) => Ok(val),
             JitValue::None => Ok(self.builder.ins().iconst(types::I8, 0)),
+            JitValue::Tuple(_) => Err(JitCompileError::NotSupported),
         }
     }
 
@@ -260,6 +267,26 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             Instruction::LoadConst { idx } => {
                 self.load_const(constants[*idx as usize].borrow_constant())
             }
+            Instruction::BuildTuple { unpack, size } if !unpack => {
+                let elements = self.pop_multiple(*size as usize);
+                self.stack.push(JitValue::Tuple(elements));
+                Ok(())
+            }
+            Instruction::UnpackSequence { size } => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+
+                let elements = match val {
+                    JitValue::Tuple(elements) => elements,
+                    _ => return Err(JitCompileError::NotSupported),
+                };
+
+                if elements.len() != *size as usize {
+                    return Err(JitCompileError::NotSupported);
+                }
+
+                self.stack.extend(elements.into_iter().rev());
+                Ok(())
+            }
             Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 if let Some(ref ty) = self.sig.ret {

jit/tests/misc_tests.rs

@@ -101,3 +101,15 @@ fn test_while_loop() {
     assert_eq!(while_loop(1), Ok(1));
     assert_eq!(while_loop(10), Ok(10));
 }
+
+#[test]
+fn test_unpack_tuple() {
+    let unpack_tuple = jit_function! { unpack_tuple(a:i64, b:i64) -> i64 => r##"
+        def unpack_tuple(a: int, b: int):
+            a, b = b, a
+            return a
+    "## };
+
+    assert_eq!(unpack_tuple(0, 1), Ok(1));
+    assert_eq!(unpack_tuple(1, 2), Ok(2));
+}