RustPython
diff --git a/‎jit/src/instructions.rs‎
Lines changed: 24 additions & 6 deletions b/‎jit/src/instructions.rs‎
Lines changed: 24 additions & 6 deletions
diff --git a/‎jit/src/lib.rs‎
Lines changed: 9 additions & 2 deletions b/‎jit/src/lib.rs‎
Lines changed: 9 additions & 2 deletions
diff --git a/‎vm/src/builtins/function/jitfunc.rs‎
Lines changed: 6 additions & 1 deletion b/‎vm/src/builtins/function/jitfunc.rs‎
Lines changed: 6 additions & 1 deletion
@@ -1,7 +1,8 @@
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_bytecode::bytecode::{
-    UnaryOperator, BinaryOperator, CodeObject, ComparisonOperator, Constant, Instruction, Label, NameScope,
+    BinaryOperator, CodeObject, ComparisonOperator, Constant, Instruction, Label, NameScope,
+    UnaryOperator,
 };
 use std::collections::HashMap;
 
@@ -85,9 +86,14 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             JitType::Float => {
                 let zero = self.builder.ins().f64const(0);
                 let val = self.builder.ins().fcmp(FloatCC::NotEqual, val.val, zero);
-                Ok(self.builder.ins().bint(types::I64, val))
-            },
-            JitType::Int => Ok(val.val),
+                Ok(self.builder.ins().bint(types::I8, val))
+            }
+            JitType::Int => {
+                let zero = self.builder.ins().iconst(types::I64, 0);
+                let val = self.builder.ins().icmp(IntCC::NotEqual, val.val, zero);
+                Ok(self.builder.ins().bint(types::I8, val))
+            }
+            JitType::Bool => Ok(val.val),
         }
     }
 
@@ -228,8 +234,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                         let val = self.builder.ins().icmp(cond, a.val, b.val);
                         self.stack.push(JitValue {
-                            val,
-                            ty: JitType::Int, // TODO: Boolean
+                            val: self.builder.ins().bint(types::I8, val),
+                            ty: JitType::Bool,
                         });
 
                         Ok(())
@@ -264,6 +270,18 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                         }
                         _ => Err(JitCompileError::NotSupported),
                     },
+                    JitType::Bool => match op {
+                        UnaryOperator::Not => {
+                            let val = self.boolean_val(a)?;
+                            let not_val = self.builder.ins().bxor_imm(val, 1);
+                            self.stack.push(JitValue {
+                                val: not_val,
+                                ty: JitType::Bool,
+                            });
+                            Ok(())
+                        }
+                        _ => Err(JitCompileError::NotSupported),
+                    },
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
 
@@ -166,20 +166,23 @@ impl JitSig {
 pub enum JitType {
     Int,
     Float,
+    Bool,
 }
 
 impl JitType {
     fn to_cranelift(&self) -> types::Type {
         match self {
             Self::Int => types::I64,
             Self::Float => types::F64,
+            Self::Bool => types::I8,
         }
     }
 
     fn to_libffi(&self) -> libffi::middle::Type {
         match self {
             Self::Int => libffi::middle::Type::i64(),
             Self::Float => libffi::middle::Type::f64(),
+            Self::Bool => libffi::middle::Type::u8(),
         }
     }
 }
@@ -188,13 +191,15 @@ impl JitType {
 pub enum AbiValue {
     Float(f64),
     Int(i64),
+    Bool(bool),
 }
 
 impl AbiValue {
     fn to_libffi_arg(&self) -> libffi::middle::Arg {
         match self {
             AbiValue::Int(ref i) => libffi::middle::Arg::new(i),
             AbiValue::Float(ref f) => libffi::middle::Arg::new(f),
+            AbiValue::Bool(ref b) => libffi::middle::Arg::new(b),
         }
     }
 }
@@ -217,7 +222,7 @@ impl TryFrom<AbiValue> for i64 {
     fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
         match value {
             AbiValue::Int(i) => Ok(i),
-            AbiValue::Float(_) => Err(()),
+            _ => Err(()),
         }
     }
 }
@@ -227,8 +232,8 @@ impl TryFrom<AbiValue> for f64 {
 
     fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
         match value {
-            AbiValue::Int(_) => Err(()),
             AbiValue::Float(f) => Ok(f),
+            _ => Err(()),
         }
     }
 }
@@ -244,6 +249,7 @@ fn type_check(ty: &JitType, val: &AbiValue) -> Result<(), JitArgumentError> {
 union UnTypedAbiValue {
     float: f64,
     int: i64,
+    boolean: u8,
     _void: (),
 }
 
@@ -252,6 +258,7 @@ impl UnTypedAbiValue {
         match ty {
             JitType::Int => AbiValue::Int(self.int),
             JitType::Float => AbiValue::Float(self.float),
+            JitType::Bool => AbiValue::Bool(self.boolean != 0),
         }
     }
 }
 
@@ -1,6 +1,6 @@
 use crate::builtins::dict::PyDictRef;
 use crate::builtins::function::{PyFunction, PyFunctionRef};
-use crate::builtins::{float, int};
+use crate::builtins::{float, int, pybool};
 use crate::exceptions::PyBaseExceptionRef;
 use crate::function::FuncArgs;
 use crate::pyobject::{
@@ -35,6 +35,7 @@ impl IntoPyObject for AbiValue {
         match self {
             AbiValue::Int(i) => i.into_pyobject(vm),
             AbiValue::Float(f) => f.into_pyobject(vm),
+            AbiValue::Bool(b) => b.into_pyobject(vm),
         }
     }
 }
@@ -50,6 +51,8 @@ fn get_jit_arg_type(dict: &PyDictRef, name: &str, vm: &VirtualMachine) -> PyResu
             Ok(JitType::Int)
         } else if value.is(&vm.ctx.types.float_type) {
             Ok(JitType::Float)
+        } else if value.is(&vm.ctx.types.bool_type) {
+            Ok(JitType::Bool)
         } else {
             Err(new_jit_error(
                 "Jit requires argument to be either int or float".to_owned(),
@@ -113,6 +116,8 @@ fn get_jit_value(vm: &VirtualMachine, obj: &PyObjectRef) -> Result<AbiValue, Arg
             .ok_or(ArgsError::IntOverflow)
     } else if cls.is(&vm.ctx.types.float_type) {
         Ok(AbiValue::Float(float::get_value(&obj)))
+    } else if cls.is(&vm.ctx.types.bool_type) {
+        Ok(AbiValue::Bool(pybool::get_value(&obj)))
     } else {
         Err(ArgsError::NonJitType)
     }
Original file line number	Diff line number	Diff line change
`@@ -166,20 +166,23 @@ impl JitSig {`
`166`	`166`	`pub enum JitType {`
`167`	`167`	`Int,`
`168`	`168`	`Float,`
	`169`	`+ Bool,`
`169`	`170`	`}`
`170`	`171`
`171`	`172`	`impl JitType {`
`172`	`173`	`fn to_cranelift(&self) -> types::Type {`
`173`	`174`	`match self {`
`174`	`175`	`Self::Int => types::I64,`
`175`	`176`	`Self::Float => types::F64,`
	`177`	`+ Self::Bool => types::I8,`
`176`	`178`	`}`
`177`	`179`	`}`
`178`	`180`
`179`	`181`	`fn to_libffi(&self) -> libffi::middle::Type {`
`180`	`182`	`match self {`
`181`	`183`	`Self::Int => libffi::middle::Type::i64(),`
`182`	`184`	`Self::Float => libffi::middle::Type::f64(),`
	`185`	`+ Self::Bool => libffi::middle::Type::u8(),`
`183`	`186`	`}`
`184`	`187`	`}`
`185`	`188`	`}`
`@@ -188,13 +191,15 @@ impl JitType {`
`188`	`191`	`pub enum AbiValue {`
`189`	`192`	`Float(f64),`
`190`	`193`	`Int(i64),`
	`194`	`+ Bool(bool),`
`191`	`195`	`}`
`192`	`196`
`193`	`197`	`impl AbiValue {`
`194`	`198`	`fn to_libffi_arg(&self) -> libffi::middle::Arg {`
`195`	`199`	`match self {`
`196`	`200`	`AbiValue::Int(ref i) => libffi::middle::Arg::new(i),`
`197`	`201`	`AbiValue::Float(ref f) => libffi::middle::Arg::new(f),`
	`202`	`+ AbiValue::Bool(ref b) => libffi::middle::Arg::new(b),`
`198`	`203`	`}`
`199`	`204`	`}`
`200`	`205`	`}`
`@@ -217,7 +222,7 @@ impl TryFrom<AbiValue> for i64 {`
`217`	`222`	`fn try_from(value: AbiValue) -> Result<Self, Self::Error> {`
`218`	`223`	`match value {`
`219`	`224`	`AbiValue::Int(i) => Ok(i),`
`220`		`- AbiValue::Float(_) => Err(()),`
	`225`	`+ _ => Err(()),`
`221`	`226`	`}`
`222`	`227`	`}`
`223`	`228`	`}`
`@@ -227,8 +232,8 @@ impl TryFrom<AbiValue> for f64 {`
`227`	`232`
`228`	`233`	`fn try_from(value: AbiValue) -> Result<Self, Self::Error> {`
`229`	`234`	`match value {`
`230`		`- AbiValue::Int(_) => Err(()),`
`231`	`235`	`AbiValue::Float(f) => Ok(f),`
	`236`	`+ _ => Err(()),`
`232`	`237`	`}`
`233`	`238`	`}`
`234`	`239`	`}`
`@@ -244,6 +249,7 @@ fn type_check(ty: &JitType, val: &AbiValue) -> Result<(), JitArgumentError> {`
`244`	`249`	`union UnTypedAbiValue {`
`245`	`250`	`float: f64,`
`246`	`251`	`int: i64,`
	`252`	`+ boolean: u8,`
`247`	`253`	`_void: (),`
`248`	`254`	`}`
`249`	`255`
`@@ -252,6 +258,7 @@ impl UnTypedAbiValue {`
`252`	`258`	`match ty {`
`253`	`259`	`JitType::Int => AbiValue::Int(self.int),`
`254`	`260`	`JitType::Float => AbiValue::Float(self.float),`
	`261`	`+ JitType::Bool => AbiValue::Bool(self.boolean != 0),`
`255`	`262`	`}`
`256`	`263`	`}`
`257`	`264`	`}`