Removed ref requirement on BasicBlock since it's Copy

Fixes rust-lang#155

Author: TheDan64

README.md

@@ -77,7 +77,7 @@ impl<'ctx> CodeGen<'ctx> {
         let function = self.module.add_function("sum", fn_type, None);
         let basic_block = self.context.append_basic_block(function, "entry");
 
-        self.builder.position_at_end(&basic_block);
+        self.builder.position_at_end(basic_block);
 
         let x = function.get_nth_param(0)?.into_int_value();
         let y = function.get_nth_param(1)?.into_int_value();

examples/jit.rs

@@ -28,7 +28,7 @@ impl<'ctx> CodeGen<'ctx> {
         let function = self.module.add_function("sum", fn_type, None);
         let basic_block = self.context.append_basic_block(function, "entry");
 
-        self.builder.position_at_end(&basic_block);
+        self.builder.position_at_end(basic_block);
 
         let x = function.get_nth_param(0)?.into_int_value();
         let y = function.get_nth_param(1)?.into_int_value();

examples/kaleidoscope/main.rs

@@ -868,7 +868,7 @@ impl<'a, 'ctx> Compiler<'a, 'ctx> {
 
         match entry.get_first_instruction() {
             Some(first_instr) => builder.position_before(&first_instr),
-            None => builder.position_at_end(&entry)
+            None => builder.position_at_end(entry)
         }
 
         builder.build_alloca(self.context.f64_type(), name)
@@ -1006,24 +1006,24 @@ impl<'a, 'ctx> Compiler<'a, 'ctx> {
                 let else_bb = self.context.append_basic_block(parent, "else");
                 let cont_bb = self.context.append_basic_block(parent, "ifcont");
 
-                self.builder.build_conditional_branch(cond, &then_bb, &else_bb);
+                self.builder.build_conditional_branch(cond, then_bb, else_bb);
 
                 // build then block
-                self.builder.position_at_end(&then_bb);
+                self.builder.position_at_end(then_bb);
                 let then_val = self.compile_expr(consequence)?;
-                self.builder.build_unconditional_branch(&cont_bb);
+                self.builder.build_unconditional_branch(cont_bb);
 
                 let then_bb = self.builder.get_insert_block().unwrap();
 
                 // build else block
-                self.builder.position_at_end(&else_bb);
+                self.builder.position_at_end(else_bb);
                 let else_val = self.compile_expr(alternative)?;
-                self.builder.build_unconditional_branch(&cont_bb);
+                self.builder.build_unconditional_branch(cont_bb);
 
                 let else_bb = self.builder.get_insert_block().unwrap();
 
                 // emit merge block
-                self.builder.position_at_end(&cont_bb);
+                self.builder.position_at_end(cont_bb);
 
                 let phi = self.builder.build_phi(self.context.f64_type(), "iftmp");
 
@@ -1046,8 +1046,8 @@ impl<'a, 'ctx> Compiler<'a, 'ctx> {
                 // go from current block to loop block
                 let loop_bb = self.context.append_basic_block(parent, "loop");
 
-                self.builder.build_unconditional_branch(&loop_bb);
-                self.builder.position_at_end(&loop_bb);
+                self.builder.build_unconditional_branch(loop_bb);
+                self.builder.position_at_end(loop_bb);
 
                 let old_val = self.variables.remove(var_name.as_str());
 
@@ -1073,8 +1073,8 @@ impl<'a, 'ctx> Compiler<'a, 'ctx> {
                 let end_cond = self.builder.build_float_compare(FloatPredicate::ONE, end_cond, self.context.f64_type().const_float(0.0), "loopcond");
                 let after_bb = self.context.append_basic_block(parent, "afterloop");
 
-                self.builder.build_conditional_branch(end_cond, &loop_bb, &after_bb);
-                self.builder.position_at_end(&after_bb);
+                self.builder.build_conditional_branch(end_cond, loop_bb, after_bb);
+                self.builder.position_at_end(after_bb);
 
                 self.variables.remove(var_name);
 
@@ -1120,7 +1120,7 @@ impl<'a, 'ctx> Compiler<'a, 'ctx> {
 
         let entry = self.context.append_basic_block(function, "entry");
 
-        self.builder.position_at_end(&entry);
+        self.builder.position_at_end(entry);
 
         // update fn field
         self.fn_value_opt = Some(function);

src/basic_block.rs

@@ -162,13 +162,13 @@ impl BasicBlock {
     /// let basic_block1 = context.append_basic_block(function, "entry");
     /// let basic_block2 = context.append_basic_block(function, "next");
     ///
-    /// basic_block2.move_before(&basic_block1);
+    /// basic_block2.move_before(basic_block1);
     ///
     /// assert!(basic_block1.get_next_basic_block().is_none());
     /// assert_eq!(basic_block2.get_next_basic_block().unwrap(), basic_block1);
     /// ```
     // REVIEW: What happens if blocks are from different scopes?
-    pub fn move_before(&self, basic_block: &BasicBlock) -> Result<(), ()> {
+    pub fn move_before(&self, basic_block: BasicBlock) -> Result<(), ()> {
         // This method is UB if the parent no longer exists, so we must check for parent (or encode into type system)
         if self.get_parent().is_none() || basic_block.get_parent().is_none() {
             return Err(());
@@ -199,13 +199,13 @@ impl BasicBlock {
     /// let basic_block1 = context.append_basic_block(function, "entry");
     /// let basic_block2 = context.append_basic_block(function, "next");
     ///
-    /// basic_block1.move_after(&basic_block2);
+    /// basic_block1.move_after(basic_block2);
     ///
     /// assert!(basic_block1.get_next_basic_block().is_none());
     /// assert_eq!(basic_block2.get_next_basic_block().unwrap(), basic_block1);
     /// ```
     // REVIEW: What happens if blocks are from different scopes?
-    pub fn move_after(&self, basic_block: &BasicBlock) -> Result<(), ()> {
+    pub fn move_after(&self, basic_block: BasicBlock) -> Result<(), ()> {
         // This method is UB if the parent no longer exists, so we must check for parent (or encode into type system)
         if self.get_parent().is_none() || basic_block.get_parent().is_none() {
             return Err(());
@@ -235,7 +235,7 @@ impl BasicBlock {
     /// let function = module.add_function("do_nothing", fn_type, None);
     /// let basic_block = context.append_basic_block(function, "entry");
     ///
-    /// builder.position_at_end(&basic_block);
+    /// builder.position_at_end(basic_block);
     /// builder.build_return(None);
     ///
     /// assert_eq!(basic_block.get_first_instruction().unwrap().get_opcode(), InstructionOpcode::Return);
@@ -269,7 +269,7 @@ impl BasicBlock {
     /// let function = module.add_function("do_nothing", fn_type, None);
     /// let basic_block = context.append_basic_block(function, "entry");
     ///
-    /// builder.position_at_end(&basic_block);
+    /// builder.position_at_end(basic_block);
     /// builder.build_return(None);
     ///
     /// assert_eq!(basic_block.get_last_instruction().unwrap().get_opcode(), InstructionOpcode::Return);
@@ -303,7 +303,7 @@ impl BasicBlock {
     /// let function = module.add_function("do_nothing", fn_type, None);
     /// let basic_block = context.append_basic_block(function, "entry");
     ///
-    /// builder.position_at_end(&basic_block);
+    /// builder.position_at_end(basic_block);
     /// builder.build_return(None);
     ///
     /// assert_eq!(basic_block.get_terminator().unwrap().get_opcode(), InstructionOpcode::Return);

src/builder.rs

@@ -54,7 +54,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let i32_arg = fn_value.get_first_param().unwrap();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_return(Some(&i32_arg));
     /// ```
     pub fn build_return(&self, value: Option<&dyn BasicValue<'ctx>>) -> InstructionValue<'ctx> {
@@ -85,7 +85,7 @@ impl<'ctx> Builder<'ctx> {
     /// let fn_value = module.add_function("ret", fn_type, None);
     /// let entry = context.append_basic_block(fn_value, "entry");
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_aggregate_return(&[i32_three.into(), i32_seven.into()]);
     /// ```
     pub fn build_aggregate_return(&self, values: &[BasicValueEnum<'ctx>]) -> InstructionValue<'ctx> {
@@ -118,7 +118,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let i32_arg = fn_value.get_first_param().unwrap();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     ///
     /// let ret_val = builder.build_call(fn_value, &[i32_arg], "call")
     ///     .try_as_basic_value()
@@ -228,7 +228,7 @@ impl<'ctx> Builder<'ctx> {
     /// let i32_ptr_param1 = fn_value.get_first_param().unwrap().into_pointer_value();
     /// let i32_ptr_param2 = fn_value.get_nth_param(1).unwrap().into_pointer_value();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_ptr_diff(i32_ptr_param1, i32_ptr_param2, "diff");
     /// builder.build_return(None);
     /// ```
@@ -278,7 +278,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let i32_ptr_param = fn_value.get_first_param().unwrap().into_pointer_value();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_store(i32_ptr_param, i32_seven);
     /// builder.build_return(None);
     /// ```
@@ -309,7 +309,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let i32_ptr_param = fn_value.get_first_param().unwrap().into_pointer_value();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     ///
     /// let pointee = builder.build_load(i32_ptr_param, "load");
     ///
@@ -524,7 +524,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let i32_arg = fn_value.get_first_param().unwrap();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     ///
     /// builder.build_bitcast(i32_arg, f32_type, "i32tof32");
     /// builder.build_return(None);
@@ -834,7 +834,7 @@ impl<'ctx> Builder<'ctx> {
     /// let n = function.get_nth_param(1).unwrap().into_int_value();
     /// let entry_block = context.append_basic_block(function, "entry");
     ///
-    /// builder.position_at_end(&entry_block);
+    /// builder.position_at_end(entry_block);
     ///
     /// let shift = builder.build_left_shift(value, n, "left_shift"); // value << n
     ///
@@ -906,7 +906,7 @@ impl<'ctx> Builder<'ctx> {
     /// let n = function.get_nth_param(1).unwrap().into_int_value();
     /// let entry_block = context.append_basic_block(function, "entry");
     ///
-    /// builder.position_at_end(&entry_block);
+    /// builder.position_at_end(entry_block);
     ///
     /// // Whether or not your right shift is sign extended (true) or logical (false) depends
     /// // on the boolean input parameter:
@@ -1078,7 +1078,7 @@ impl<'ctx> Builder<'ctx> {
         <<T::BaseType as FloatMathType>::MathConvType as IntMathType>::ValueType::new(value)
     }
 
-    pub fn build_unconditional_branch(&self, destination_block: &BasicBlock) -> InstructionValue<'ctx> {
+    pub fn build_unconditional_branch(&self, destination_block: BasicBlock) -> InstructionValue<'ctx> {
         let value = unsafe {
             LLVMBuildBr(self.builder, destination_block.basic_block)
         };
@@ -1089,8 +1089,8 @@ impl<'ctx> Builder<'ctx> {
     pub fn build_conditional_branch(
         &self,
         comparison: IntValue<'ctx>,
-        then_block: &BasicBlock,
-        else_block: &BasicBlock,
+        then_block: BasicBlock,
+        else_block: BasicBlock,
     ) -> InstructionValue<'ctx> {
         let value = unsafe {
             LLVMBuildCondBr(self.builder, comparison.as_value_ref(), then_block.basic_block, else_block.basic_block)
@@ -1102,7 +1102,7 @@ impl<'ctx> Builder<'ctx> {
     pub fn build_indirect_branch<BV: BasicValue<'ctx>>(
         &self,
         address: BV,
-        destinations: &[&BasicBlock],
+        destinations: &[BasicBlock],
     ) -> InstructionValue<'ctx> {
         let value = unsafe {
             LLVMBuildIndirectBr(self.builder, address.as_value_ref(), destinations.len() as u32)
@@ -1175,7 +1175,7 @@ impl<'ctx> Builder<'ctx> {
 
     // REVIEW: What if instruction and basic_block are completely unrelated?
     // It'd be great if we could get the BB from the instruction behind the scenes
-    pub fn position_at(&self, basic_block: &BasicBlock, instruction: &InstructionValue<'ctx>) {
+    pub fn position_at(&self, basic_block: BasicBlock, instruction: &InstructionValue<'ctx>) {
         unsafe {
             LLVMPositionBuilder(self.builder, basic_block.basic_block, instruction.as_value_ref())
         }
@@ -1187,7 +1187,7 @@ impl<'ctx> Builder<'ctx> {
         }
     }
 
-    pub fn position_at_end(&self, basic_block: &BasicBlock) {
+    pub fn position_at_end(&self, basic_block: BasicBlock) {
         unsafe {
             LLVMPositionBuilderAtEnd(self.builder, basic_block.basic_block);
         }
@@ -1213,7 +1213,7 @@ impl<'ctx> Builder<'ctx> {
     /// let builder = context.create_builder();
     /// let entry = context.append_basic_block(fn_value, "entry");
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     ///
     /// let array_alloca = builder.build_alloca(array_type, "array_alloca");
     /// let array = builder.build_load(array_alloca, "array_load").into_array_value();
@@ -1275,7 +1275,7 @@ impl<'ctx> Builder<'ctx> {
     /// let builder = context.create_builder();
     /// let entry = context.append_basic_block(fn_value, "entry");
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     ///
     /// let array_alloca = builder.build_alloca(array_type, "array_alloca");
     /// let array = builder.build_load(array_alloca, "array_load").into_array_value();
@@ -1329,7 +1329,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let vector_param = fn_value.get_first_param().unwrap().into_vector_value();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     ///
     /// let extracted = builder.build_extract_element(vector_param, i32_zero, "insert");
     ///
@@ -1366,7 +1366,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let vector_param = fn_value.get_first_param().unwrap().into_vector_value();
     ///
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_insert_element(vector_param, i32_seven, i32_zero, "insert");
     /// builder.build_return(None);
     /// ```
@@ -1464,7 +1464,7 @@ impl<'ctx> Builder<'ctx> {
     // REVIEW: Returning InstructionValue is the safe move here; but if the value means something
     // (IE the result of the switch) it should probably return BasicValueEnum?
     // SubTypes: I think value and case values must be the same subtype (maybe). Case value might need to be constants
-    pub fn build_switch(&self, value: IntValue<'ctx>, else_block: &BasicBlock, cases: &[(IntValue<'ctx>, &BasicBlock)]) -> InstructionValue<'ctx> {
+    pub fn build_switch(&self, value: IntValue<'ctx>, else_block: BasicBlock, cases: &[(IntValue<'ctx>, BasicBlock)]) -> InstructionValue<'ctx> {
         let switch_value = unsafe {
             LLVMBuildSwitch(self.builder, value.as_value_ref(), else_block.basic_block, cases.len() as u32)
         };
@@ -1550,7 +1550,7 @@ impl<'ctx> Builder<'ctx> {
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let i32_ptr_param = fn_value.get_first_param().unwrap().into_pointer_value();
     /// let builder = context.create_builder();
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_atomicrmw(AtomicRMWBinOp::Add, i32_ptr_param, i32_seven, AtomicOrdering::Unordered);
     /// builder.build_return(None);
     /// ```
@@ -1599,7 +1599,7 @@ impl<'ctx> Builder<'ctx> {
     /// let i32_eight = i32_type.const_int(8, false);
     /// let entry = context.append_basic_block(fn_value, "entry");
     /// let builder = context.create_builder();
-    /// builder.position_at_end(&entry);
+    /// builder.position_at_end(entry);
     /// builder.build_cmpxchg(i32_ptr_param, i32_seven, i32_eight, AtomicOrdering::AcquireRelease, AtomicOrdering::Monotonic);
     /// builder.build_return(None);
     /// ```

src/context.rs

@@ -31,7 +31,7 @@ use std::thread_local;
 // 1) Only one thread has access to the global context at a time.
 // 2) The thread has shared access across different points in the thread.
 // This is still technically unsafe because another program in the same process
-// could also be accessing the global context via the C API. `get_context` has been
+// could also be accessing the global context via the C API. `get_global` has been
 // marked unsafe for this reason. Iff this isn't the case then this should be fully safe.
 static GLOBAL_CTX: Lazy<Mutex<Context>> = Lazy::new(|| {
     let ctx = unsafe {
@@ -168,7 +168,7 @@ impl Context {
     /// let fn_val = module.add_function("my_fn", fn_type, None);
     /// let basic_block = context.append_basic_block(fn_val, "entry");
     ///
-    /// builder.position_at_end(&basic_block);
+    /// builder.position_at_end(basic_block);
     /// builder.build_return(None);
     ///
     /// let memory_buffer = module.write_bitcode_to_memory();
@@ -691,7 +691,7 @@ impl Context {
     /// let fn_value = module.add_function("my_func", fn_type, None);
     /// let entry_block = context.append_basic_block(fn_value, "entry");
     ///
-    /// builder.position_at_end(&entry_block);
+    /// builder.position_at_end(entry_block);
     ///
     /// let ret_instr = builder.build_return(None);
     ///
@@ -731,7 +731,7 @@ impl Context {
     /// let fn_value = module.add_function("my_func", fn_type, None);
     /// let entry_block = context.append_basic_block(fn_value, "entry");
     ///
-    /// builder.position_at_end(&entry_block);
+    /// builder.position_at_end(entry_block);
     ///
     /// let ret_instr = builder.build_return(None);
     ///

src/execution_engine.rs

@@ -162,7 +162,7 @@ impl<'ctx> ExecutionEngine<'ctx> {
     /// let f = module.add_function("test_fn", fnt, None);
     /// let b = context.append_basic_block(f, "entry");
     ///
-    /// builder.position_at_end(&b);
+    /// builder.position_at_end(b);
     ///
     /// let extf = module.add_function("sumf", ft.fn_type(&[ft.into(), ft.into()], false), None);
     ///
@@ -274,7 +274,7 @@ impl<'ctx> ExecutionEngine<'ctx> {
     /// // Add the function to our module
     /// let f = module.add_function("test_fn", sig, None);
     /// let b = context.append_basic_block(f, "entry");
-    /// builder.position_at_end(&b);
+    /// builder.position_at_end(b);
     ///
     /// // Insert a return statement
     /// let ret = double.const_float(64.0);