RustPython
diff --git a/‎jit/src/instructions.rs‎
Lines changed: 22 additions & 12 deletions b/‎jit/src/instructions.rs‎
Lines changed: 22 additions & 12 deletions
diff --git a/‎jit/src/lib.rs‎
Lines changed: 4 additions & 4 deletions b/‎jit/src/lib.rs‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎jit/tests/common.rs‎
Lines changed: 13 additions & 9 deletions b/‎jit/tests/common.rs‎
Lines changed: 13 additions & 9 deletions
@@ -1,8 +1,8 @@
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_bytecode::bytecode::{
-    BinaryOperator, CodeObject, ComparisonOperator, Constant, Instruction, Label, NameScope,
-    UnaryOperator,
+    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction, Label,
+    NameScope, UnaryOperator,
 };
 use std::collections::HashMap;
 
@@ -105,7 +105,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .or_insert_with(|| builder.create_block())
     }
 
-    pub fn compile(&mut self, bytecode: &CodeObject) -> Result<(), JitCompileError> {
+    pub fn compile<C: bytecode::Constant>(
+        &mut self,
+        bytecode: &CodeObject<C>,
+    ) -> Result<(), JitCompileError> {
         let offset_to_label: HashMap<&usize, &Label> =
             bytecode.label_map.iter().map(|(k, v)| (v, k)).collect();
 
@@ -128,15 +131,18 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 continue;
             }
 
-            self.add_instruction(&instruction)?;
+            self.add_instruction(&instruction, &bytecode.constants)?;
         }
 
         Ok(())
     }
 
-    fn load_const(&mut self, constant: &Constant) -> Result<(), JitCompileError> {
+    fn load_const<C: bytecode::Constant>(
+        &mut self,
+        constant: BorrowedConstant<C>,
+    ) -> Result<(), JitCompileError> {
         match constant {
-            Constant::Integer { value } => {
+            BorrowedConstant::Integer { value } => {
                 let val = self.builder.ins().iconst(
                     types::I64,
                     value.to_i64().ok_or(JitCompileError::NotSupported)?,
@@ -147,16 +153,16 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 });
                 Ok(())
             }
-            Constant::Float { value } => {
-                let val = self.builder.ins().f64const(*value);
+            BorrowedConstant::Float { value } => {
+                let val = self.builder.ins().f64const(value);
                 self.stack.push(JitValue {
                     val,
                     ty: JitType::Float,
                 });
                 Ok(())
             }
-            Constant::Boolean { value } => {
-                let val = self.builder.ins().iconst(types::I8, *value as i64);
+            BorrowedConstant::Boolean { value } => {
+                let val = self.builder.ins().iconst(types::I8, value as i64);
                 self.stack.push(JitValue {
                     val,
                     ty: JitType::Bool,
@@ -167,7 +173,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         }
     }
 
-    fn add_instruction(&mut self, instruction: &Instruction) -> Result<(), JitCompileError> {
+    pub fn add_instruction<C: bytecode::Constant>(
+        &mut self,
+        instruction: &Instruction,
+        constants: &[C],
+    ) -> Result<(), JitCompileError> {
         match instruction {
             Instruction::JumpIfFalse { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -222,7 +232,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(name.clone(), val)
             }
-            Instruction::LoadConst { value } => self.load_const(value),
+            Instruction::LoadConst { idx } => self.load_const(constants[*idx].borrow_constant()),
             Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 if let Some(ref ty) = self.sig.ret {
 
@@ -46,9 +46,9 @@ impl Jit {
         }
     }
 
-    fn build_function(
+    fn build_function<C: bytecode::Constant>(
         &mut self,
-        bytecode: &bytecode::CodeObject,
+        bytecode: &bytecode::CodeObject<C>,
         args: &[JitType],
     ) -> Result<(FuncId, JitSig), JitCompileError> {
         for arg in args {
@@ -92,8 +92,8 @@ impl Jit {
     }
 }
 
-pub fn compile(
-    bytecode: &bytecode::CodeObject,
+pub fn compile<C: bytecode::Constant>(
+    bytecode: &bytecode::CodeObject<C>,
     args: &[JitType],
 ) -> Result<CompiledCode, JitCompileError> {
     let mut jit = Jit::new();
 
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use rustpython_bytecode::bytecode::{CodeObject, Constant, Instruction, NameScope};
+use rustpython_bytecode::bytecode::{CodeObject, ConstantData, Instruction, NameScope};
 use rustpython_jit::{CompiledCode, JitType};
 
 #[derive(Debug, Clone)]
@@ -39,12 +39,12 @@ enum StackValue {
     Function(Function),
 }
 
-impl From<Constant> for StackValue {
-    fn from(value: Constant) -> Self {
+impl From<ConstantData> for StackValue {
+    fn from(value: ConstantData) -> Self {
         match value {
-            Constant::String { value } => StackValue::String(value),
-            Constant::None => StackValue::None,
-            Constant::Code { code } => StackValue::Code(code),
+            ConstantData::Str { value } => StackValue::String(value),
+            ConstantData::None => StackValue::None,
+            ConstantData::Code { code } => StackValue::Code(code),
             c => unimplemented!("constant {:?} isn't yet supported in py_function!", c),
         }
     }
@@ -65,15 +65,19 @@ impl StackMachine {
 
     pub fn run(&mut self, code: CodeObject) {
         for instruction in code.instructions {
-            if self.process_instruction(instruction) {
+            if self.process_instruction(instruction, &code.constants) {
                 break;
             }
         }
     }
 
-    fn process_instruction(&mut self, instruction: Instruction) -> bool {
+    fn process_instruction(
+        &mut self,
+        instruction: Instruction,
+        constants: &[ConstantData],
+    ) -> bool {
         match instruction {
-            Instruction::LoadConst { value } => self.stack.push(value.into()),
+            Instruction::LoadConst { idx } => self.stack.push(constants[idx].clone().into()),
             Instruction::LoadName {
                 name,
                 scope: NameScope::Free,
Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,9 @@ impl Jit {`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`- fn build_function(`
	`49`	`+ fn build_function<C: bytecode::Constant>(`
`50`	`50`	`&mut self,`
`51`		`- bytecode: &bytecode::CodeObject,`
	`51`	`+ bytecode: &bytecode::CodeObject<C>,`
`52`	`52`	`args: &[JitType],`
`53`	`53`	`) -> Result<(FuncId, JitSig), JitCompileError> {`
`54`	`54`	`for arg in args {`
`@@ -92,8 +92,8 @@ impl Jit {`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`		`-pub fn compile(`
`96`		`- bytecode: &bytecode::CodeObject,`
	`95`	`+pub fn compile<C: bytecode::Constant>(`
	`96`	`+ bytecode: &bytecode::CodeObject<C>,`
`97`	`97`	`args: &[JitType],`
`98`	`98`	`) -> Result<CompiledCode, JitCompileError> {`
`99`	`99`	`let mut jit = Jit::new();`