From 617f0d65b20b7b405b1acecea6f99ccd0a6d73f3 Mon Sep 17 00:00:00 2001 From: johannst Date: Thu, 5 Jan 2023 20:25:01 +0000 Subject: deploy: 802cca1963bc27f8ea4e4923029909e45464d3df --- src/llvm_kaleidoscope_rs/llvm/basic_block.rs.html | 69 ++-- src/llvm_kaleidoscope_rs/llvm/builder.rs.html | 423 ++++++++++----------- src/llvm_kaleidoscope_rs/llvm/lljit.rs.html | 217 +++++------ src/llvm_kaleidoscope_rs/llvm/mod.rs.html | 115 +++--- src/llvm_kaleidoscope_rs/llvm/module.rs.html | 325 ++++++++-------- src/llvm_kaleidoscope_rs/llvm/pass_manager.rs.html | 115 +++--- src/llvm_kaleidoscope_rs/llvm/type_.rs.html | 95 +++-- src/llvm_kaleidoscope_rs/llvm/value.rs.html | 361 +++++++++--------- 8 files changed, 832 insertions(+), 888 deletions(-) (limited to 'src/llvm_kaleidoscope_rs/llvm') diff --git a/src/llvm_kaleidoscope_rs/llvm/basic_block.rs.html b/src/llvm_kaleidoscope_rs/llvm/basic_block.rs.html index 581b8e2..2370022 100644 --- a/src/llvm_kaleidoscope_rs/llvm/basic_block.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/basic_block.rs.html @@ -1,10 +1,4 @@ -basic_block.rs - source - 
1
+basic_block.rs - source
1
 2
 3
 4
@@ -43,45 +37,44 @@
 37
 38
 39
-
use llvm_sys::{core::LLVMGetBasicBlockParent, prelude::LLVMBasicBlockRef};
+
use llvm_sys::{core::LLVMGetBasicBlockParent, prelude::LLVMBasicBlockRef};
 
-use std::marker::PhantomData;
+use std::marker::PhantomData;
 
-use super::FnValue;
+use super::FnValue;
 
-/// Wrapper for a LLVM Basic Block.
-#[derive(Copy, Clone)]
-pub struct BasicBlock<'llvm>(LLVMBasicBlockRef, PhantomData<&'llvm ()>);
+/// Wrapper for a LLVM Basic Block.
+#[derive(Copy, Clone)]
+pub struct BasicBlock<'llvm>(LLVMBasicBlockRef, PhantomData<&'llvm ()>);
 
-impl<'llvm> BasicBlock<'llvm> {
-    /// Create a new BasicBlock instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `bb_ref` is a null pointer.
-    pub(super) fn new(bb_ref: LLVMBasicBlockRef) -> BasicBlock<'llvm> {
-        assert!(!bb_ref.is_null());
-        BasicBlock(bb_ref, PhantomData)
+impl<'llvm> BasicBlock<'llvm> {
+    /// Create a new BasicBlock instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `bb_ref` is a null pointer.
+    pub(super) fn new(bb_ref: LLVMBasicBlockRef) -> BasicBlock<'llvm> {
+        assert!(!bb_ref.is_null());
+        BasicBlock(bb_ref, PhantomData)
     }
 
-    /// Get the raw LLVM value reference.
-    #[inline]
-    pub(super) fn bb_ref(&self) -> LLVMBasicBlockRef {
-        self.0
-    }
+    /// Get the raw LLVM value reference.
+    #[inline]
+    pub(super) fn bb_ref(&self) -> LLVMBasicBlockRef {
+        self.0
+    }
 
-    /// Get the function to which the basic block belongs.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn get_parent(&self) -> FnValue<'llvm> {
-        let value_ref = unsafe { LLVMGetBasicBlockParent(self.bb_ref()) };
-        assert!(!value_ref.is_null());
+    /// Get the function to which the basic block belongs.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn get_parent(&self) -> FnValue<'llvm> {
+        let value_ref = unsafe { LLVMGetBasicBlockParent(self.bb_ref()) };
+        assert!(!value_ref.is_null());
 
-        FnValue::new(value_ref)
+        FnValue::new(value_ref)
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/builder.rs.html b/src/llvm_kaleidoscope_rs/llvm/builder.rs.html index 934351a..fad1867 100644 --- a/src/llvm_kaleidoscope_rs/llvm/builder.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/builder.rs.html @@ -1,10 +1,4 @@ -builder.rs - source - 
1
+builder.rs - source
1
 2
 3
 4
@@ -283,285 +277,284 @@
 277
 278
 279
-
use llvm_sys::{
-    core::{
-        LLVMAddIncoming, LLVMBuildBr, LLVMBuildCondBr, LLVMBuildFAdd, LLVMBuildFCmp, LLVMBuildFMul,
-        LLVMBuildFSub, LLVMBuildPhi, LLVMBuildRet, LLVMBuildUIToFP, LLVMCreateBuilderInContext,
-        LLVMDisposeBuilder, LLVMGetInsertBlock, LLVMPositionBuilderAtEnd,
+
use llvm_sys::{
+    core::{
+        LLVMAddIncoming, LLVMBuildBr, LLVMBuildCondBr, LLVMBuildFAdd, LLVMBuildFCmp, LLVMBuildFMul,
+        LLVMBuildFSub, LLVMBuildPhi, LLVMBuildRet, LLVMBuildUIToFP, LLVMCreateBuilderInContext,
+        LLVMDisposeBuilder, LLVMGetInsertBlock, LLVMPositionBuilderAtEnd,
     },
-    prelude::{LLVMBuilderRef, LLVMValueRef},
-    LLVMRealPredicate,
+    prelude::{LLVMBuilderRef, LLVMValueRef},
+    LLVMRealPredicate,
 };
 
-use std::marker::PhantomData;
+use std::marker::PhantomData;
 
-use super::{BasicBlock, FnValue, Module, PhiValue, Type, Value};
+use super::{BasicBlock, FnValue, Module, PhiValue, Type, Value};
 
-// Definition of LLVM C API functions using our `repr(transparent)` types.
-extern "C" {
-    fn LLVMBuildCall2(
-        arg1: LLVMBuilderRef,
-        arg2: Type<'_>,
-        Fn: FnValue<'_>,
-        Args: *mut Value<'_>,
-        NumArgs: ::libc::c_uint,
-        Name: *const ::libc::c_char,
-    ) -> LLVMValueRef;
+// Definition of LLVM C API functions using our `repr(transparent)` types.
+extern "C" {
+    fn LLVMBuildCall2(
+        arg1: LLVMBuilderRef,
+        arg2: Type<'_>,
+        Fn: FnValue<'_>,
+        Args: *mut Value<'_>,
+        NumArgs: ::libc::c_uint,
+        Name: *const ::libc::c_char,
+    ) -> LLVMValueRef;
 }
 
-/// Wrapper for a LLVM IR Builder.
-pub struct IRBuilder<'llvm> {
-    builder: LLVMBuilderRef,
-    _ctx: PhantomData<&'llvm ()>,
+/// Wrapper for a LLVM IR Builder.
+pub struct IRBuilder<'llvm> {
+    builder: LLVMBuilderRef,
+    _ctx: PhantomData<&'llvm ()>,
 }
 
-impl<'llvm> IRBuilder<'llvm> {
-    /// Create a new LLVM IR Builder with the `module`s context.
-    ///
-    /// # Panics
-    ///
-    /// Panics if creating the IR Builder fails.
-    pub fn with_ctx(module: &'llvm Module) -> IRBuilder<'llvm> {
-        let builder = unsafe { LLVMCreateBuilderInContext(module.ctx()) };
-        assert!(!builder.is_null());
+impl<'llvm> IRBuilder<'llvm> {
+    /// Create a new LLVM IR Builder with the `module`s context.
+    ///
+    /// # Panics
+    ///
+    /// Panics if creating the IR Builder fails.
+    pub fn with_ctx(module: &'llvm Module) -> IRBuilder<'llvm> {
+        let builder = unsafe { LLVMCreateBuilderInContext(module.ctx()) };
+        assert!(!builder.is_null());
 
-        IRBuilder {
-            builder,
-            _ctx: PhantomData,
+        IRBuilder {
+            builder,
+            _ctx: PhantomData,
         }
     }
 
-    /// Position the IR Builder at the end of the given Basic Block.
-    pub fn pos_at_end(&self, bb: BasicBlock<'llvm>) {
-        unsafe {
-            LLVMPositionBuilderAtEnd(self.builder, bb.bb_ref());
+    /// Position the IR Builder at the end of the given Basic Block.
+    pub fn pos_at_end(&self, bb: BasicBlock<'llvm>) {
+        unsafe {
+            LLVMPositionBuilderAtEnd(self.builder, bb.bb_ref());
         }
     }
 
-    /// Get the BasicBlock the IRBuilder currently inputs into.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn get_insert_block(&self) -> BasicBlock<'llvm> {
-        let bb_ref = unsafe { LLVMGetInsertBlock(self.builder) };
-        assert!(!bb_ref.is_null());
+    /// Get the BasicBlock the IRBuilder currently inputs into.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn get_insert_block(&self) -> BasicBlock<'llvm> {
+        let bb_ref = unsafe { LLVMGetInsertBlock(self.builder) };
+        assert!(!bb_ref.is_null());
 
-        BasicBlock::new(bb_ref)
+        BasicBlock::new(bb_ref)
     }
 
-    /// Emit a [fadd](https://llvm.org/docs/LangRef.html#fadd-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn fadd(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
-        debug_assert!(lhs.is_f64(), "fadd: Expected f64 as lhs operand!");
-        debug_assert!(rhs.is_f64(), "fadd: Expected f64 as rhs operand!");
+    /// Emit a [fadd](https://llvm.org/docs/LangRef.html#fadd-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn fadd(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
+        debug_assert!(lhs.is_f64(), "fadd: Expected f64 as lhs operand!");
+        debug_assert!(rhs.is_f64(), "fadd: Expected f64 as rhs operand!");
 
-        let value_ref = unsafe {
-            LLVMBuildFAdd(
-                self.builder,
-                lhs.value_ref(),
-                rhs.value_ref(),
-                b"fadd\0".as_ptr().cast(),
+        let value_ref = unsafe {
+            LLVMBuildFAdd(
+                self.builder,
+                lhs.value_ref(),
+                rhs.value_ref(),
+                b"fadd\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [fsub](https://llvm.org/docs/LangRef.html#fsub-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn fsub(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
-        debug_assert!(lhs.is_f64(), "fsub: Expected f64 as lhs operand!");
-        debug_assert!(rhs.is_f64(), "fsub: Expected f64 as rhs operand!");
+    /// Emit a [fsub](https://llvm.org/docs/LangRef.html#fsub-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn fsub(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
+        debug_assert!(lhs.is_f64(), "fsub: Expected f64 as lhs operand!");
+        debug_assert!(rhs.is_f64(), "fsub: Expected f64 as rhs operand!");
 
-        let value_ref = unsafe {
-            LLVMBuildFSub(
-                self.builder,
-                lhs.value_ref(),
-                rhs.value_ref(),
-                b"fsub\0".as_ptr().cast(),
+        let value_ref = unsafe {
+            LLVMBuildFSub(
+                self.builder,
+                lhs.value_ref(),
+                rhs.value_ref(),
+                b"fsub\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [fmul](https://llvm.org/docs/LangRef.html#fmul-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn fmul(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
-        debug_assert!(lhs.is_f64(), "fmul: Expected f64 as lhs operand!");
-        debug_assert!(rhs.is_f64(), "fmul: Expected f64 as rhs operand!");
+    /// Emit a [fmul](https://llvm.org/docs/LangRef.html#fmul-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn fmul(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
+        debug_assert!(lhs.is_f64(), "fmul: Expected f64 as lhs operand!");
+        debug_assert!(rhs.is_f64(), "fmul: Expected f64 as rhs operand!");
 
-        let value_ref = unsafe {
-            LLVMBuildFMul(
-                self.builder,
-                lhs.value_ref(),
-                rhs.value_ref(),
-                b"fmul\0".as_ptr().cast(),
+        let value_ref = unsafe {
+            LLVMBuildFMul(
+                self.builder,
+                lhs.value_ref(),
+                rhs.value_ref(),
+                b"fmul\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [fcmpult](https://llvm.org/docs/LangRef.html#fcmp-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn fcmpult(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
-        debug_assert!(lhs.is_f64(), "fcmpult: Expected f64 as lhs operand!");
-        debug_assert!(rhs.is_f64(), "fcmpult: Expected f64 as rhs operand!");
+    /// Emit a [fcmpult](https://llvm.org/docs/LangRef.html#fcmp-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn fcmpult(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
+        debug_assert!(lhs.is_f64(), "fcmpult: Expected f64 as lhs operand!");
+        debug_assert!(rhs.is_f64(), "fcmpult: Expected f64 as rhs operand!");
 
-        let value_ref = unsafe {
-            LLVMBuildFCmp(
-                self.builder,
-                LLVMRealPredicate::LLVMRealULT,
-                lhs.value_ref(),
-                rhs.value_ref(),
-                b"fcmpult\0".as_ptr().cast(),
+        let value_ref = unsafe {
+            LLVMBuildFCmp(
+                self.builder,
+                LLVMRealPredicate::LLVMRealULT,
+                lhs.value_ref(),
+                rhs.value_ref(),
+                b"fcmpult\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [fcmpone](https://llvm.org/docs/LangRef.html#fcmp-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn fcmpone(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
-        debug_assert!(lhs.is_f64(), "fcmone: Expected f64 as lhs operand!");
-        debug_assert!(rhs.is_f64(), "fcmone: Expected f64 as rhs operand!");
+    /// Emit a [fcmpone](https://llvm.org/docs/LangRef.html#fcmp-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn fcmpone(&self, lhs: Value<'llvm>, rhs: Value<'llvm>) -> Value<'llvm> {
+        debug_assert!(lhs.is_f64(), "fcmone: Expected f64 as lhs operand!");
+        debug_assert!(rhs.is_f64(), "fcmone: Expected f64 as rhs operand!");
 
-        let value_ref = unsafe {
-            LLVMBuildFCmp(
-                self.builder,
-                LLVMRealPredicate::LLVMRealONE,
-                lhs.value_ref(),
-                rhs.value_ref(),
-                b"fcmpone\0".as_ptr().cast(),
+        let value_ref = unsafe {
+            LLVMBuildFCmp(
+                self.builder,
+                LLVMRealPredicate::LLVMRealONE,
+                lhs.value_ref(),
+                rhs.value_ref(),
+                b"fcmpone\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [uitofp](https://llvm.org/docs/LangRef.html#uitofp-to-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn uitofp(&self, val: Value<'llvm>, dest_type: Type<'llvm>) -> Value<'llvm> {
-        debug_assert!(val.is_int(), "uitofp: Expected integer operand!");
+    /// Emit a [uitofp](https://llvm.org/docs/LangRef.html#uitofp-to-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn uitofp(&self, val: Value<'llvm>, dest_type: Type<'llvm>) -> Value<'llvm> {
+        debug_assert!(val.is_int(), "uitofp: Expected integer operand!");
 
-        let value_ref = unsafe {
-            LLVMBuildUIToFP(
-                self.builder,
-                val.value_ref(),
-                dest_type.type_ref(),
-                b"uitofp\0".as_ptr().cast(),
+        let value_ref = unsafe {
+            LLVMBuildUIToFP(
+                self.builder,
+                val.value_ref(),
+                dest_type.type_ref(),
+                b"uitofp\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [call](https://llvm.org/docs/LangRef.html#call-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn call(&self, fn_value: FnValue<'llvm>, args: &mut [Value<'llvm>]) -> Value<'llvm> {
-        let value_ref = unsafe {
-            LLVMBuildCall2(
-                self.builder,
-                fn_value.ret_type(),
-                fn_value,
-                args.as_mut_ptr(),
-                args.len() as libc::c_uint,
-                b"call\0".as_ptr().cast(),
+    /// Emit a [call](https://llvm.org/docs/LangRef.html#call-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn call(&self, fn_value: FnValue<'llvm>, args: &mut [Value<'llvm>]) -> Value<'llvm> {
+        let value_ref = unsafe {
+            LLVMBuildCall2(
+                self.builder,
+                fn_value.ret_type(),
+                fn_value,
+                args.as_mut_ptr(),
+                args.len() as libc::c_uint,
+                b"call\0".as_ptr().cast(),
             )
         };
-        Value::new(value_ref)
+        Value::new(value_ref)
     }
 
-    /// Emit a [ret](https://llvm.org/docs/LangRef.html#ret-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn ret(&self, ret: Value<'llvm>) {
-        let ret = unsafe { LLVMBuildRet(self.builder, ret.value_ref()) };
-        assert!(!ret.is_null());
+    /// Emit a [ret](https://llvm.org/docs/LangRef.html#ret-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn ret(&self, ret: Value<'llvm>) {
+        let ret = unsafe { LLVMBuildRet(self.builder, ret.value_ref()) };
+        assert!(!ret.is_null());
     }
 
-    /// Emit an unconditional [br](https://llvm.org/docs/LangRef.html#br-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn br(&self, dest: BasicBlock<'llvm>) {
-        let br_ref = unsafe { LLVMBuildBr(self.builder, dest.bb_ref()) };
-        assert!(!br_ref.is_null());
+    /// Emit an unconditional [br](https://llvm.org/docs/LangRef.html#br-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn br(&self, dest: BasicBlock<'llvm>) {
+        let br_ref = unsafe { LLVMBuildBr(self.builder, dest.bb_ref()) };
+        assert!(!br_ref.is_null());
     }
 
-    /// Emit a conditional [br](https://llvm.org/docs/LangRef.html#br-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn cond_br(&self, cond: Value<'llvm>, then: BasicBlock<'llvm>, else_: BasicBlock<'llvm>) {
-        let br_ref = unsafe {
-            LLVMBuildCondBr(
-                self.builder,
-                cond.value_ref(),
-                then.bb_ref(),
-                else_.bb_ref(),
+    /// Emit a conditional [br](https://llvm.org/docs/LangRef.html#br-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn cond_br(&self, cond: Value<'llvm>, then: BasicBlock<'llvm>, else_: BasicBlock<'llvm>) {
+        let br_ref = unsafe {
+            LLVMBuildCondBr(
+                self.builder,
+                cond.value_ref(),
+                then.bb_ref(),
+                else_.bb_ref(),
             )
         };
-        assert!(!br_ref.is_null());
+        assert!(!br_ref.is_null());
     }
 
-    /// Emit a [phi](https://llvm.org/docs/LangRef.html#phi-instruction) instruction.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn phi(
+    /// Emit a [phi](https://llvm.org/docs/LangRef.html#phi-instruction) instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn phi(
         &self,
-        phi_type: Type<'llvm>,
-        incoming: &[(Value<'llvm>, BasicBlock<'llvm>)],
-    ) -> PhiValue<'llvm> {
-        let phi_ref =
-            unsafe { LLVMBuildPhi(self.builder, phi_type.type_ref(), b"phi\0".as_ptr().cast()) };
-        assert!(!phi_ref.is_null());
+        phi_type: Type<'llvm>,
+        incoming: &[(Value<'llvm>, BasicBlock<'llvm>)],
+    ) -> PhiValue<'llvm> {
+        let phi_ref =
+            unsafe { LLVMBuildPhi(self.builder, phi_type.type_ref(), b"phi\0".as_ptr().cast()) };
+        assert!(!phi_ref.is_null());
 
-        for (val, bb) in incoming {
+        for (val, bb) in incoming {
             debug_assert_eq!(
-                val.type_of().kind(),
-                phi_type.kind(),
-                "Type of incoming phi value must be the same as the type used to build the phi node."
-            );
+                val.type_of().kind(),
+                phi_type.kind(),
+                "Type of incoming phi value must be the same as the type used to build the phi node."
+            );
 
-            unsafe {
-                LLVMAddIncoming(phi_ref, &mut val.value_ref() as _, &mut bb.bb_ref() as _, 1);
+            unsafe {
+                LLVMAddIncoming(phi_ref, &mut val.value_ref() as _, &mut bb.bb_ref() as _, 1);
             }
         }
 
-        PhiValue::new(phi_ref)
+        PhiValue::new(phi_ref)
     }
 }
 
-impl Drop for IRBuilder<'_> {
-    fn drop(&mut self) {
-        unsafe { LLVMDisposeBuilder(self.builder) }
+impl Drop for IRBuilder<'_> {
+    fn drop(&mut self) {
+        unsafe { LLVMDisposeBuilder(self.builder) }
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/lljit.rs.html b/src/llvm_kaleidoscope_rs/llvm/lljit.rs.html index 5a5a376..80be225 100644 --- a/src/llvm_kaleidoscope_rs/llvm/lljit.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/lljit.rs.html @@ -1,10 +1,4 @@ -lljit.rs - source - 
1
+lljit.rs - source
1
 2
 3
 4
@@ -158,160 +152,159 @@
 152
 153
 154
-
use llvm_sys::orc2::{
-    lljit::{
-        LLVMOrcCreateLLJIT, LLVMOrcLLJITAddLLVMIRModuleWithRT, LLVMOrcLLJITGetGlobalPrefix,
-        LLVMOrcLLJITGetMainJITDylib, LLVMOrcLLJITLookup, LLVMOrcLLJITRef,
+
use llvm_sys::orc2::{
+    lljit::{
+        LLVMOrcCreateLLJIT, LLVMOrcLLJITAddLLVMIRModuleWithRT, LLVMOrcLLJITGetGlobalPrefix,
+        LLVMOrcLLJITGetMainJITDylib, LLVMOrcLLJITLookup, LLVMOrcLLJITRef,
     },
-    LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess, LLVMOrcDefinitionGeneratorRef,
-    LLVMOrcJITDylibAddGenerator, LLVMOrcJITDylibCreateResourceTracker, LLVMOrcJITDylibRef,
-    LLVMOrcReleaseResourceTracker, LLVMOrcResourceTrackerRef, LLVMOrcResourceTrackerRemove,
+    LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess, LLVMOrcDefinitionGeneratorRef,
+    LLVMOrcJITDylibAddGenerator, LLVMOrcJITDylibCreateResourceTracker, LLVMOrcJITDylibRef,
+    LLVMOrcReleaseResourceTracker, LLVMOrcResourceTrackerRef, LLVMOrcResourceTrackerRemove,
 };
 
-use std::convert::TryFrom;
-use std::marker::PhantomData;
+use std::convert::TryFrom;
+use std::marker::PhantomData;
 
-use super::{Error, Module};
-use crate::SmallCStr;
+use super::{Error, Module};
+use crate::SmallCStr;
 
-/// Marker trait to constrain function signatures that can be looked up in the JIT.
-pub trait JitFn {}
+/// Marker trait to constrain function signatures that can be looked up in the JIT.
+pub trait JitFn {}
 
-impl JitFn for unsafe extern "C" fn() -> f64 {}
+impl JitFn for unsafe extern "C" fn() -> f64 {}
 
-/// Wrapper for a LLVM [LLJIT](https://www.llvm.org/docs/ORCv2.html#lljit-and-lllazyjit).
-pub struct LLJit {
-    jit: LLVMOrcLLJITRef,
-    dylib: LLVMOrcJITDylibRef,
+/// Wrapper for a LLVM [LLJIT](https://www.llvm.org/docs/ORCv2.html#lljit-and-lllazyjit).
+pub struct LLJit {
+    jit: LLVMOrcLLJITRef,
+    dylib: LLVMOrcJITDylibRef,
 }
 
-impl LLJit {
-    /// Create a new LLJit instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer or an error.
-    pub fn new() -> LLJit {
-        let (jit, dylib) = unsafe {
-            let mut jit = std::ptr::null_mut();
-            let err = LLVMOrcCreateLLJIT(
-                &mut jit as _,
-                std::ptr::null_mut(), /* builder: nullptr -> default */
-            );
+impl LLJit {
+    /// Create a new LLJit instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer or an error.
+    pub fn new() -> LLJit {
+        let (jit, dylib) = unsafe {
+            let mut jit = std::ptr::null_mut();
+            let err = LLVMOrcCreateLLJIT(
+                &mut jit as _,
+                std::ptr::null_mut(), /* builder: nullptr -> default */
+            );
 
-            if let Some(err) = Error::from(err) {
-                panic!("Error: {}", err.as_str());
+            if let Some(err) = Error::from(err) {
+                panic!("Error: {}", err.as_str());
             }
 
-            let dylib = LLVMOrcLLJITGetMainJITDylib(jit);
-            assert!(!dylib.is_null());
+            let dylib = LLVMOrcLLJITGetMainJITDylib(jit);
+            assert!(!dylib.is_null());
 
-            (jit, dylib)
+            (jit, dylib)
         };
 
-        LLJit { jit, dylib }
+        LLJit { jit, dylib }
     }
 
-    /// Add an LLVM IR module to the JIT. Return a [`ResourceTracker`], which when dropped, will
-    /// remove the code of the LLVM IR module from the JIT.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer or an error.
-    pub fn add_module(&self, module: Module) -> ResourceTracker<'_> {
-        let tsmod = module.into_raw_thread_safe_module();
+    /// Add an LLVM IR module to the JIT. Return a [`ResourceTracker`], which when dropped, will
+    /// remove the code of the LLVM IR module from the JIT.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer or an error.
+    pub fn add_module(&self, module: Module) -> ResourceTracker<'_> {
+        let tsmod = module.into_raw_thread_safe_module();
 
-        let rt = unsafe {
-            let rt = LLVMOrcJITDylibCreateResourceTracker(self.dylib);
-            let err = LLVMOrcLLJITAddLLVMIRModuleWithRT(self.jit, rt, tsmod);
+        let rt = unsafe {
+            let rt = LLVMOrcJITDylibCreateResourceTracker(self.dylib);
+            let err = LLVMOrcLLJITAddLLVMIRModuleWithRT(self.jit, rt, tsmod);
 
-            if let Some(err) = Error::from(err) {
-                panic!("Error: {}", err.as_str());
+            if let Some(err) = Error::from(err) {
+                panic!("Error: {}", err.as_str());
             }
 
-            rt
+            rt
         };
 
-        ResourceTracker::new(rt)
+        ResourceTracker::new(rt)
     }
 
-    /// Find the symbol with the name `sym` in the JIT.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the symbol is not found in the JIT.
-    pub fn find_symbol<F: JitFn>(&self, sym: &str) -> F {
-        let sym =
-            SmallCStr::try_from(sym).expect("Failed to convert 'sym' argument to small C string!");
+    /// Find the symbol with the name `sym` in the JIT.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the symbol is not found in the JIT.
+    pub fn find_symbol<F: JitFn>(&self, sym: &str) -> F {
+        let sym =
+            SmallCStr::try_from(sym).expect("Failed to convert 'sym' argument to small C string!");
 
-        unsafe {
-            let mut addr = 0u64;
-            let err = LLVMOrcLLJITLookup(self.jit, &mut addr as _, sym.as_ptr());
+        unsafe {
+            let mut addr = 0u64;
+            let err = LLVMOrcLLJITLookup(self.jit, &mut addr as _, sym.as_ptr());
 
-            if let Some(err) = Error::from(err) {
-                panic!("Error: {}", err.as_str());
+            if let Some(err) = Error::from(err) {
+                panic!("Error: {}", err.as_str());
             }
 
-            debug_assert_eq!(core::mem::size_of_val(&addr), core::mem::size_of::<F>());
-            std::mem::transmute_copy(&addr)
+            debug_assert_eq!(core::mem::size_of_val(&addr), core::mem::size_of::<F>());
+            std::mem::transmute_copy(&addr)
         }
     }
 
-    /// Enable lookup of dynamic symbols available in the current process from the JIT.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns an error.
-    pub fn enable_process_symbols(&self) {
-        unsafe {
-            let mut proc_syms_gen: LLVMOrcDefinitionGeneratorRef = std::ptr::null_mut();
-            let err = LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
-                &mut proc_syms_gen as _,
-                self.global_prefix(),
-                None,                 /* filter */
-                std::ptr::null_mut(), /* filter ctx */
-            );
+    /// Enable lookup of dynamic symbols available in the current process from the JIT.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns an error.
+    pub fn enable_process_symbols(&self) {
+        unsafe {
+            let mut proc_syms_gen: LLVMOrcDefinitionGeneratorRef = std::ptr::null_mut();
+            let err = LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
+                &mut proc_syms_gen as _,
+                self.global_prefix(),
+                None,                 /* filter */
+                std::ptr::null_mut(), /* filter ctx */
+            );
 
-            if let Some(err) = Error::from(err) {
-                panic!("Error: {}", err.as_str());
+            if let Some(err) = Error::from(err) {
+                panic!("Error: {}", err.as_str());
             }
 
-            LLVMOrcJITDylibAddGenerator(self.dylib, proc_syms_gen);
+            LLVMOrcJITDylibAddGenerator(self.dylib, proc_syms_gen);
         }
     }
 
-    /// Return the global prefix character according to the LLJITs data layout.
-    fn global_prefix(&self) -> libc::c_char {
-        unsafe { LLVMOrcLLJITGetGlobalPrefix(self.jit) }
+    /// Return the global prefix character according to the LLJITs data layout.
+    fn global_prefix(&self) -> libc::c_char {
+        unsafe { LLVMOrcLLJITGetGlobalPrefix(self.jit) }
     }
 }
 
-/// A resource handle for code added to an [`LLJit`] instance.
-///
-/// When a `ResourceTracker` handle is dropped, the code corresponding to the handle will be
-/// removed from the JIT.
-pub struct ResourceTracker<'jit>(LLVMOrcResourceTrackerRef, PhantomData<&'jit ()>);
+/// A resource handle for code added to an [`LLJit`] instance.
+///
+/// When a `ResourceTracker` handle is dropped, the code corresponding to the handle will be
+/// removed from the JIT.
+pub struct ResourceTracker<'jit>(LLVMOrcResourceTrackerRef, PhantomData<&'jit ()>);
 
-impl<'jit> ResourceTracker<'jit> {
-    fn new(rt: LLVMOrcResourceTrackerRef) -> ResourceTracker<'jit> {
-        assert!(!rt.is_null());
-        ResourceTracker(rt, PhantomData)
+impl<'jit> ResourceTracker<'jit> {
+    fn new(rt: LLVMOrcResourceTrackerRef) -> ResourceTracker<'jit> {
+        assert!(!rt.is_null());
+        ResourceTracker(rt, PhantomData)
     }
 }
 
-impl Drop for ResourceTracker<'_> {
-    fn drop(&mut self) {
-        unsafe {
-            let err = LLVMOrcResourceTrackerRemove(self.0);
+impl Drop for ResourceTracker<'_> {
+    fn drop(&mut self) {
+        unsafe {
+            let err = LLVMOrcResourceTrackerRemove(self.0);
 
-            if let Some(err) = Error::from(err) {
-                panic!("Error: {}", err.as_str());
+            if let Some(err) = Error::from(err) {
+                panic!("Error: {}", err.as_str());
             }
 
-            LLVMOrcReleaseResourceTracker(self.0);
+            LLVMOrcReleaseResourceTracker(self.0);
         };
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/mod.rs.html b/src/llvm_kaleidoscope_rs/llvm/mod.rs.html index 3dca9c7..87756d4 100644 --- a/src/llvm_kaleidoscope_rs/llvm/mod.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/mod.rs.html @@ -1,10 +1,4 @@ -mod.rs - source - 
1
+mod.rs - source
1
 2
 3
 4
@@ -78,80 +72,79 @@
 72
 73
 74
-
//! Safe wrapper around the LLVM C API.
-//!
-//! References returned from the LLVM API are tied to the `'llvm` lifetime which is bound to the
-//! context where the objects are created in.
-//! We do not offer wrappers to remove or delete any objects in the context and therefore all the
-//! references will be valid for the liftime of the context.
-//!
-//! For the scope of this tutorial we mainly use assertions to validate the results from the LLVM
-//! API calls.
+
//! Safe wrapper around the LLVM C API.
+//!
+//! References returned from the LLVM API are tied to the `'llvm` lifetime which is bound to the
+//! context where the objects are created in.
+//! We do not offer wrappers to remove or delete any objects in the context and therefore all the
+//! references will be valid for the liftime of the context.
+//!
+//! For the scope of this tutorial we mainly use assertions to validate the results from the LLVM
+//! API calls.
 
-use llvm_sys::{
-    core::LLVMShutdown,
-    error::{LLVMDisposeErrorMessage, LLVMErrorRef, LLVMGetErrorMessage},
-    target::{
-        LLVM_InitializeNativeAsmParser, LLVM_InitializeNativeAsmPrinter,
-        LLVM_InitializeNativeTarget,
+use llvm_sys::{
+    core::LLVMShutdown,
+    error::{LLVMDisposeErrorMessage, LLVMErrorRef, LLVMGetErrorMessage},
+    target::{
+        LLVM_InitializeNativeAsmParser, LLVM_InitializeNativeAsmPrinter,
+        LLVM_InitializeNativeTarget,
     },
 };
 
-use std::ffi::CStr;
+use std::ffi::CStr;
 
-mod basic_block;
-mod builder;
-mod lljit;
-mod module;
-mod pass_manager;
-mod type_;
-mod value;
+mod basic_block;
+mod builder;
+mod lljit;
+mod module;
+mod pass_manager;
+mod type_;
+mod value;
 
-pub use basic_block::BasicBlock;
-pub use builder::IRBuilder;
-pub use lljit::{LLJit, ResourceTracker};
-pub use module::Module;
-pub use pass_manager::FunctionPassManager;
-pub use type_::Type;
-pub use value::{FnValue, PhiValue, Value};
+pub use basic_block::BasicBlock;
+pub use builder::IRBuilder;
+pub use lljit::{LLJit, ResourceTracker};
+pub use module::Module;
+pub use pass_manager::FunctionPassManager;
+pub use type_::Type;
+pub use value::{FnValue, PhiValue, Value};
 
-struct Error<'llvm>(&'llvm mut libc::c_char);
+struct Error<'llvm>(&'llvm mut libc::c_char);
 
-impl<'llvm> Error<'llvm> {
-    fn from(err: LLVMErrorRef) -> Option<Error<'llvm>> {
-        (!err.is_null()).then(|| Error(unsafe { &mut *LLVMGetErrorMessage(err) }))
+impl<'llvm> Error<'llvm> {
+    fn from(err: LLVMErrorRef) -> Option<Error<'llvm>> {
+        (!err.is_null()).then(|| Error(unsafe { &mut *LLVMGetErrorMessage(err) }))
     }
 
-    fn as_str(&self) -> &str {
-        unsafe { CStr::from_ptr(self.0) }
-            .to_str()
-            .expect("Expected valid UTF8 string from LLVM API")
+    fn as_str(&self) -> &str {
+        unsafe { CStr::from_ptr(self.0) }
+            .to_str()
+            .expect("Expected valid UTF8 string from LLVM API")
     }
 }
 
-impl Drop for Error<'_> {
-    fn drop(&mut self) {
-        unsafe {
-            LLVMDisposeErrorMessage(self.0 as *mut libc::c_char);
+impl Drop for Error<'_> {
+    fn drop(&mut self) {
+        unsafe {
+            LLVMDisposeErrorMessage(self.0 as *mut libc::c_char);
         }
     }
 }
 
-/// Initialize native target for corresponding to host (useful for jitting).
-pub fn initialize_native_taget() {
-    unsafe {
-        assert_eq!(LLVM_InitializeNativeTarget(), 0);
-        assert_eq!(LLVM_InitializeNativeAsmParser(), 0);
-        assert_eq!(LLVM_InitializeNativeAsmPrinter(), 0);
+/// Initialize native target for corresponding to host (useful for jitting).
+pub fn initialize_native_taget() {
+    unsafe {
+        assert_eq!(LLVM_InitializeNativeTarget(), 0);
+        assert_eq!(LLVM_InitializeNativeAsmParser(), 0);
+        assert_eq!(LLVM_InitializeNativeAsmPrinter(), 0);
     }
 }
 
-/// Deallocate and destroy all "ManagedStatic" variables.
-pub fn shutdown() {
-    unsafe {
-        LLVMShutdown();
+/// Deallocate and destroy all "ManagedStatic" variables.
+pub fn shutdown() {
+    unsafe {
+        LLVMShutdown();
     };
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/module.rs.html b/src/llvm_kaleidoscope_rs/llvm/module.rs.html index 99846f4..127ba39 100644 --- a/src/llvm_kaleidoscope_rs/llvm/module.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/module.rs.html @@ -1,10 +1,4 @@ -module.rs - source - 
1
+module.rs - source
1
 2
 3
 4
@@ -214,216 +208,215 @@
 208
 209
 210
-
use llvm_sys::{
-    core::{
-        LLVMAddFunction, LLVMAppendBasicBlockInContext, LLVMCreateBasicBlockInContext,
-        LLVMDisposeModule, LLVMDoubleTypeInContext, LLVMDumpModule, LLVMGetNamedFunction,
-        LLVMModuleCreateWithNameInContext,
+
use llvm_sys::{
+    core::{
+        LLVMAddFunction, LLVMAppendBasicBlockInContext, LLVMCreateBasicBlockInContext,
+        LLVMDisposeModule, LLVMDoubleTypeInContext, LLVMDumpModule, LLVMGetNamedFunction,
+        LLVMModuleCreateWithNameInContext,
     },
-    orc2::{
-        LLVMOrcCreateNewThreadSafeContext, LLVMOrcCreateNewThreadSafeModule,
-        LLVMOrcDisposeThreadSafeContext, LLVMOrcThreadSafeContextGetContext,
-        LLVMOrcThreadSafeContextRef, LLVMOrcThreadSafeModuleRef,
+    orc2::{
+        LLVMOrcCreateNewThreadSafeContext, LLVMOrcCreateNewThreadSafeModule,
+        LLVMOrcDisposeThreadSafeContext, LLVMOrcThreadSafeContextGetContext,
+        LLVMOrcThreadSafeContextRef, LLVMOrcThreadSafeModuleRef,
     },
-    prelude::{LLVMBool, LLVMContextRef, LLVMModuleRef, LLVMTypeRef},
-    LLVMTypeKind,
+    prelude::{LLVMBool, LLVMContextRef, LLVMModuleRef, LLVMTypeRef},
+    LLVMTypeKind,
 };
 
-use std::convert::TryFrom;
+use std::convert::TryFrom;
 
-use super::{BasicBlock, FnValue, Type};
-use crate::SmallCStr;
+use super::{BasicBlock, FnValue, Type};
+use crate::SmallCStr;
 
-// Definition of LLVM C API functions using our `repr(transparent)` types.
-extern "C" {
-    fn LLVMFunctionType(
-        ReturnType: Type<'_>,
-        ParamTypes: *mut Type<'_>,
-        ParamCount: ::libc::c_uint,
-        IsVarArg: LLVMBool,
-    ) -> LLVMTypeRef;
+// Definition of LLVM C API functions using our `repr(transparent)` types.
+extern "C" {
+    fn LLVMFunctionType(
+        ReturnType: Type<'_>,
+        ParamTypes: *mut Type<'_>,
+        ParamCount: ::libc::c_uint,
+        IsVarArg: LLVMBool,
+    ) -> LLVMTypeRef;
 }
 
-/// Wrapper for a LLVM Module with its own LLVM Context.
-pub struct Module {
-    tsctx: LLVMOrcThreadSafeContextRef,
-    ctx: LLVMContextRef,
-    module: LLVMModuleRef,
+/// Wrapper for a LLVM Module with its own LLVM Context.
+pub struct Module {
+    tsctx: LLVMOrcThreadSafeContextRef,
+    ctx: LLVMContextRef,
+    module: LLVMModuleRef,
 }
 
-impl<'llvm> Module {
-    /// Create a new Module instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if creating the context or the module fails.
-    pub fn new() -> Self {
-        let (tsctx, ctx, module) = unsafe {
-            // We generate a thread safe context because we are going to jit this IR module and
-            // there is no method to create a thread safe context wrapper from an existing context
-            // reference (at the time of writing this).
-            //
-            // ThreadSafeContext has shared ownership (start with ref count 1).
-            // We must explicitly dispose our reference (dec ref count).
-            let tc = LLVMOrcCreateNewThreadSafeContext();
-            assert!(!tc.is_null());
+impl<'llvm> Module {
+    /// Create a new Module instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if creating the context or the module fails.
+    pub fn new() -> Self {
+        let (tsctx, ctx, module) = unsafe {
+            // We generate a thread safe context because we are going to jit this IR module and
+            // there is no method to create a thread safe context wrapper from an existing context
+            // reference (at the time of writing this).
+            //
+            // ThreadSafeContext has shared ownership (start with ref count 1).
+            // We must explicitly dispose our reference (dec ref count).
+            let tc = LLVMOrcCreateNewThreadSafeContext();
+            assert!(!tc.is_null());
 
-            let c = LLVMOrcThreadSafeContextGetContext(tc);
-            let m = LLVMModuleCreateWithNameInContext(b"module\0".as_ptr().cast(), c);
-            assert!(!c.is_null() && !m.is_null());
-            (tc, c, m)
+            let c = LLVMOrcThreadSafeContextGetContext(tc);
+            let m = LLVMModuleCreateWithNameInContext(b"module\0".as_ptr().cast(), c);
+            assert!(!c.is_null() && !m.is_null());
+            (tc, c, m)
         };
 
-        Module { tsctx, ctx, module }
+        Module { tsctx, ctx, module }
     }
 
-    /// Get the raw LLVM context reference.
-    #[inline]
-    pub(super) fn ctx(&self) -> LLVMContextRef {
-        self.ctx
+    /// Get the raw LLVM context reference.
+    #[inline]
+    pub(super) fn ctx(&self) -> LLVMContextRef {
+        self.ctx
     }
 
-    /// Get the raw LLVM module reference.
-    #[inline]
-    pub(super) fn module(&self) -> LLVMModuleRef {
-        self.module
+    /// Get the raw LLVM module reference.
+    #[inline]
+    pub(super) fn module(&self) -> LLVMModuleRef {
+        self.module
     }
 
-    /// Consume the module and turn in into a raw LLVM ThreadSafeModule reference.
-    ///
-    /// If ownership of the raw reference is not transferred (eg to the JIT), memory will be leaked
-    /// in case the reference is disposed explicitly with LLVMOrcDisposeThreadSafeModule.
-    #[inline]
-    pub(super) fn into_raw_thread_safe_module(mut self) -> LLVMOrcThreadSafeModuleRef {
-        let m = std::mem::replace(&mut self.module, std::ptr::null_mut());
+    /// Consume the module and turn in into a raw LLVM ThreadSafeModule reference.
+    ///
+    /// If ownership of the raw reference is not transferred (eg to the JIT), memory will be leaked
+    /// in case the reference is disposed explicitly with LLVMOrcDisposeThreadSafeModule.
+    #[inline]
+    pub(super) fn into_raw_thread_safe_module(mut self) -> LLVMOrcThreadSafeModuleRef {
+        let m = std::mem::replace(&mut self.module, std::ptr::null_mut());
 
-        // ThreadSafeModule has unique ownership.
-        // Takes ownership of module and increments ThreadSafeContext ref count.
-        //
-        // We must not reference/dispose `m` after this call, but we need to dispose our `tsctx`
-        // reference.
-        let tm = unsafe { LLVMOrcCreateNewThreadSafeModule(m, self.tsctx) };
-        assert!(!tm.is_null());
+        // ThreadSafeModule has unique ownership.
+        // Takes ownership of module and increments ThreadSafeContext ref count.
+        //
+        // We must not reference/dispose `m` after this call, but we need to dispose our `tsctx`
+        // reference.
+        let tm = unsafe { LLVMOrcCreateNewThreadSafeModule(m, self.tsctx) };
+        assert!(!tm.is_null());
 
-        tm
+        tm
     }
 
-    /// Dump LLVM IR emitted into the Module to stdout.
-    pub fn dump(&self) {
-        unsafe { LLVMDumpModule(self.module) };
+    /// Dump LLVM IR emitted into the Module to stdout.
+    pub fn dump(&self) {
+        unsafe { LLVMDumpModule(self.module) };
     }
 
-    /// Get a type reference representing a `f64` float.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn type_f64(&self) -> Type<'llvm> {
-        let type_ref = unsafe { LLVMDoubleTypeInContext(self.ctx) };
-        Type::new(type_ref)
+    /// Get a type reference representing a `f64` float.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn type_f64(&self) -> Type<'llvm> {
+        let type_ref = unsafe { LLVMDoubleTypeInContext(self.ctx) };
+        Type::new(type_ref)
     }
 
-    /// Get a type reference representing a `fn(args) -> ret` function.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn type_fn(&'llvm self, args: &mut [Type<'llvm>], ret: Type<'llvm>) -> Type<'llvm> {
-        let type_ref = unsafe {
-            LLVMFunctionType(
-                ret,
-                args.as_mut_ptr(),
-                args.len() as libc::c_uint,
-                0, /* IsVarArg */
-            )
+    /// Get a type reference representing a `fn(args) -> ret` function.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn type_fn(&'llvm self, args: &mut [Type<'llvm>], ret: Type<'llvm>) -> Type<'llvm> {
+        let type_ref = unsafe {
+            LLVMFunctionType(
+                ret,
+                args.as_mut_ptr(),
+                args.len() as libc::c_uint,
+                0, /* IsVarArg */
+            )
         };
-        Type::new(type_ref)
+        Type::new(type_ref)
     }
 
-    /// Add a function with the given `name` and `fn_type` to the module and return a value
-    /// reference representing the function.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer or `name` could not be converted to a
-    /// [`SmallCStr`].
-    pub fn add_fn(&'llvm self, name: &str, fn_type: Type<'llvm>) -> FnValue<'llvm> {
+    /// Add a function with the given `name` and `fn_type` to the module and return a value
+    /// reference representing the function.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer or `name` could not be converted to a
+    /// [`SmallCStr`].
+    pub fn add_fn(&'llvm self, name: &str, fn_type: Type<'llvm>) -> FnValue<'llvm> {
         debug_assert_eq!(
-            fn_type.kind(),
-            LLVMTypeKind::LLVMFunctionTypeKind,
-            "Expected a function type when adding a function!"
-        );
+            fn_type.kind(),
+            LLVMTypeKind::LLVMFunctionTypeKind,
+            "Expected a function type when adding a function!"
+        );
 
-        let name = SmallCStr::try_from(name)
-            .expect("Failed to convert 'name' argument to small C string!");
+        let name = SmallCStr::try_from(name)
+            .expect("Failed to convert 'name' argument to small C string!");
 
-        let value_ref = unsafe { LLVMAddFunction(self.module, name.as_ptr(), fn_type.type_ref()) };
-        FnValue::new(value_ref)
+        let value_ref = unsafe { LLVMAddFunction(self.module, name.as_ptr(), fn_type.type_ref()) };
+        FnValue::new(value_ref)
     }
 
-    /// Get a function value reference to the function with the given `name` if it was previously
-    /// added to the module with [`add_fn`][Module::add_fn].
-    ///
-    /// # Panics
-    ///
-    /// Panics if `name` could not be converted to a [`SmallCStr`].
-    pub fn get_fn(&'llvm self, name: &str) -> Option<FnValue<'llvm>> {
-        let name = SmallCStr::try_from(name)
-            .expect("Failed to convert 'name' argument to small C string!");
+    /// Get a function value reference to the function with the given `name` if it was previously
+    /// added to the module with [`add_fn`][Module::add_fn].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `name` could not be converted to a [`SmallCStr`].
+    pub fn get_fn(&'llvm self, name: &str) -> Option<FnValue<'llvm>> {
+        let name = SmallCStr::try_from(name)
+            .expect("Failed to convert 'name' argument to small C string!");
 
-        let value_ref = unsafe { LLVMGetNamedFunction(self.module, name.as_ptr()) };
+        let value_ref = unsafe { LLVMGetNamedFunction(self.module, name.as_ptr()) };
 
-        (!value_ref.is_null()).then(|| FnValue::new(value_ref))
+        (!value_ref.is_null()).then(|| FnValue::new(value_ref))
     }
 
-    /// Append a Basic Block to the end of the function referenced by the value reference
-    /// `fn_value`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn append_basic_block(&'llvm self, fn_value: FnValue<'llvm>) -> BasicBlock<'llvm> {
-        let block = unsafe {
-            LLVMAppendBasicBlockInContext(
-                self.ctx,
-                fn_value.value_ref(),
-                b"block\0".as_ptr().cast(),
+    /// Append a Basic Block to the end of the function referenced by the value reference
+    /// `fn_value`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn append_basic_block(&'llvm self, fn_value: FnValue<'llvm>) -> BasicBlock<'llvm> {
+        let block = unsafe {
+            LLVMAppendBasicBlockInContext(
+                self.ctx,
+                fn_value.value_ref(),
+                b"block\0".as_ptr().cast(),
             )
         };
-        assert!(!block.is_null());
+        assert!(!block.is_null());
 
-        BasicBlock::new(block)
+        BasicBlock::new(block)
     }
 
-    /// Create a free-standing Basic Block without adding it to a function.
-    /// This can be added to a function at a later point in time with
-    /// [`FnValue::append_basic_block`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn create_basic_block(&self) -> BasicBlock<'llvm> {
-        let block = unsafe { LLVMCreateBasicBlockInContext(self.ctx, b"block\0".as_ptr().cast()) };
-        assert!(!block.is_null());
+    /// Create a free-standing Basic Block without adding it to a function.
+    /// This can be added to a function at a later point in time with
+    /// [`FnValue::append_basic_block`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn create_basic_block(&self) -> BasicBlock<'llvm> {
+        let block = unsafe { LLVMCreateBasicBlockInContext(self.ctx, b"block\0".as_ptr().cast()) };
+        assert!(!block.is_null());
 
-        BasicBlock::new(block)
+        BasicBlock::new(block)
     }
 }
 
-impl Drop for Module {
-    fn drop(&mut self) {
-        unsafe {
-            // In case we turned the module into a ThreadSafeModule, we must not dispose the module
-            // reference because ThreadSafeModule took ownership!
-            if !self.module.is_null() {
-                LLVMDisposeModule(self.module);
+impl Drop for Module {
+    fn drop(&mut self) {
+        unsafe {
+            // In case we turned the module into a ThreadSafeModule, we must not dispose the module
+            // reference because ThreadSafeModule took ownership!
+            if !self.module.is_null() {
+                LLVMDisposeModule(self.module);
             }
 
-            // Dispose ThreadSafeContext reference (dec ref count) in any case.
-            LLVMOrcDisposeThreadSafeContext(self.tsctx);
+            // Dispose ThreadSafeContext reference (dec ref count) in any case.
+            LLVMOrcDisposeThreadSafeContext(self.tsctx);
         }
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/pass_manager.rs.html b/src/llvm_kaleidoscope_rs/llvm/pass_manager.rs.html index ebf9b28..968856f 100644 --- a/src/llvm_kaleidoscope_rs/llvm/pass_manager.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/pass_manager.rs.html @@ -1,10 +1,4 @@ -pass_manager.rs - source - 
1
+pass_manager.rs - source
1
 2
 3
 4
@@ -79,81 +73,80 @@
 73
 74
 75
-
use llvm_sys::{
-    core::{
-        LLVMCreateFunctionPassManagerForModule, LLVMDisposePassManager,
-        LLVMInitializeFunctionPassManager, LLVMRunFunctionPassManager,
+
use llvm_sys::{
+    core::{
+        LLVMCreateFunctionPassManagerForModule, LLVMDisposePassManager,
+        LLVMInitializeFunctionPassManager, LLVMRunFunctionPassManager,
     },
-    prelude::LLVMPassManagerRef,
-    transforms::{
-        instcombine::LLVMAddInstructionCombiningPass,
-        scalar::{LLVMAddCFGSimplificationPass, LLVMAddNewGVNPass, LLVMAddReassociatePass},
+    prelude::LLVMPassManagerRef,
+    transforms::{
+        instcombine::LLVMAddInstructionCombiningPass,
+        scalar::{LLVMAddCFGSimplificationPass, LLVMAddNewGVNPass, LLVMAddReassociatePass},
     },
 };
 
-use std::marker::PhantomData;
+use std::marker::PhantomData;
 
-use super::{FnValue, Module};
+use super::{FnValue, Module};
 
-/// Wrapper for a LLVM Function PassManager (legacy).
-pub struct FunctionPassManager<'llvm> {
-    fpm: LLVMPassManagerRef,
-    _ctx: PhantomData<&'llvm ()>,
+/// Wrapper for a LLVM Function PassManager (legacy).
+pub struct FunctionPassManager<'llvm> {
+    fpm: LLVMPassManagerRef,
+    _ctx: PhantomData<&'llvm ()>,
 }
 
-impl<'llvm> FunctionPassManager<'llvm> {
-    /// Create a new Function PassManager with the following optimization passes
-    /// - InstructionCombiningPass
-    /// - ReassociatePass
-    /// - NewGVNPass
-    /// - CFGSimplificationPass
-    ///
-    /// The list of selected optimization passes is taken from the tutorial chapter [LLVM
-    /// Optimization Passes](https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.html#id3).
-    pub fn with_ctx(module: &'llvm Module) -> FunctionPassManager<'llvm> {
-        let fpm = unsafe {
-            // Borrows module reference.
-            LLVMCreateFunctionPassManagerForModule(module.module())
+impl<'llvm> FunctionPassManager<'llvm> {
+    /// Create a new Function PassManager with the following optimization passes
+    /// - InstructionCombiningPass
+    /// - ReassociatePass
+    /// - NewGVNPass
+    /// - CFGSimplificationPass
+    ///
+    /// The list of selected optimization passes is taken from the tutorial chapter [LLVM
+    /// Optimization Passes](https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.html#id3).
+    pub fn with_ctx(module: &'llvm Module) -> FunctionPassManager<'llvm> {
+        let fpm = unsafe {
+            // Borrows module reference.
+            LLVMCreateFunctionPassManagerForModule(module.module())
         };
-        assert!(!fpm.is_null());
+        assert!(!fpm.is_null());
 
-        unsafe {
-            // Do simple "peephole" optimizations and bit-twiddling optzns.
-            LLVMAddInstructionCombiningPass(fpm);
-            // Reassociate expressions.
-            LLVMAddReassociatePass(fpm);
-            // Eliminate Common SubExpressions.
-            LLVMAddNewGVNPass(fpm);
-            // Simplify the control flow graph (deleting unreachable blocks, etc).
-            LLVMAddCFGSimplificationPass(fpm);
+        unsafe {
+            // Do simple "peephole" optimizations and bit-twiddling optzns.
+            LLVMAddInstructionCombiningPass(fpm);
+            // Reassociate expressions.
+            LLVMAddReassociatePass(fpm);
+            // Eliminate Common SubExpressions.
+            LLVMAddNewGVNPass(fpm);
+            // Simplify the control flow graph (deleting unreachable blocks, etc).
+            LLVMAddCFGSimplificationPass(fpm);
 
-            let fail = LLVMInitializeFunctionPassManager(fpm);
-            assert_eq!(fail, 0);
+            let fail = LLVMInitializeFunctionPassManager(fpm);
+            assert_eq!(fail, 0);
         }
 
-        FunctionPassManager {
-            fpm,
-            _ctx: PhantomData,
+        FunctionPassManager {
+            fpm,
+            _ctx: PhantomData,
         }
     }
 
-    /// Run the optimization passes registered with the Function PassManager on the function
-    /// referenced by `fn_value`.
-    pub fn run(&'llvm self, fn_value: FnValue<'llvm>) {
-        unsafe {
-            // Returns 1 if any of the passes modified the function, false otherwise.
-            LLVMRunFunctionPassManager(self.fpm, fn_value.value_ref());
+    /// Run the optimization passes registered with the Function PassManager on the function
+    /// referenced by `fn_value`.
+    pub fn run(&'llvm self, fn_value: FnValue<'llvm>) {
+        unsafe {
+            // Returns 1 if any of the passes modified the function, false otherwise.
+            LLVMRunFunctionPassManager(self.fpm, fn_value.value_ref());
         }
     }
 }
 
-impl Drop for FunctionPassManager<'_> {
-    fn drop(&mut self) {
-        unsafe {
-            LLVMDisposePassManager(self.fpm);
+impl Drop for FunctionPassManager<'_> {
+    fn drop(&mut self) {
+        unsafe {
+            LLVMDisposePassManager(self.fpm);
         }
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/type_.rs.html b/src/llvm_kaleidoscope_rs/llvm/type_.rs.html index 98daee4..7df4f4d 100644 --- a/src/llvm_kaleidoscope_rs/llvm/type_.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/type_.rs.html @@ -1,10 +1,4 @@ -type_.rs - source - 
1
+type_.rs - source
1
 2
 3
 4
@@ -62,64 +56,63 @@
 56
 57
 58
-
use llvm_sys::{
-    core::{LLVMConstReal, LLVMDumpType, LLVMGetTypeKind},
-    prelude::LLVMTypeRef,
-    LLVMTypeKind,
+
use llvm_sys::{
+    core::{LLVMConstReal, LLVMDumpType, LLVMGetTypeKind},
+    prelude::LLVMTypeRef,
+    LLVMTypeKind,
 };
 
-use std::marker::PhantomData;
+use std::marker::PhantomData;
 
-use super::Value;
+use super::Value;
 
-/// Wrapper for a LLVM Type Reference.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct Type<'llvm>(LLVMTypeRef, PhantomData<&'llvm ()>);
+/// Wrapper for a LLVM Type Reference.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Type<'llvm>(LLVMTypeRef, PhantomData<&'llvm ()>);
 
-impl<'llvm> Type<'llvm> {
-    /// Create a new Type instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `type_ref` is a null pointer.
-    pub(super) fn new(type_ref: LLVMTypeRef) -> Self {
-        assert!(!type_ref.is_null());
-        Type(type_ref, PhantomData)
+impl<'llvm> Type<'llvm> {
+    /// Create a new Type instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `type_ref` is a null pointer.
+    pub(super) fn new(type_ref: LLVMTypeRef) -> Self {
+        assert!(!type_ref.is_null());
+        Type(type_ref, PhantomData)
     }
 
-    /// Get the raw LLVM type reference.
-    #[inline]
-    pub(super) fn type_ref(&self) -> LLVMTypeRef {
-        self.0
-    }
+    /// Get the raw LLVM type reference.
+    #[inline]
+    pub(super) fn type_ref(&self) -> LLVMTypeRef {
+        self.0
+    }
 
-    /// Get the LLVM type kind for the given type reference.
-    pub(super) fn kind(&self) -> LLVMTypeKind {
-        unsafe { LLVMGetTypeKind(self.type_ref()) }
+    /// Get the LLVM type kind for the given type reference.
+    pub(super) fn kind(&self) -> LLVMTypeKind {
+        unsafe { LLVMGetTypeKind(self.type_ref()) }
     }
 
-    /// Dump the LLVM Type to stdout.
-    pub fn dump(&self) {
-        unsafe { LLVMDumpType(self.type_ref()) };
+    /// Dump the LLVM Type to stdout.
+    pub fn dump(&self) {
+        unsafe { LLVMDumpType(self.type_ref()) };
     }
 
-    /// Get a value reference representing the const `f64` value.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn const_f64(self, n: f64) -> Value<'llvm> {
+    /// Get a value reference representing the const `f64` value.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn const_f64(self, n: f64) -> Value<'llvm> {
         debug_assert_eq!(
-            self.kind(),
-            LLVMTypeKind::LLVMDoubleTypeKind,
-            "Expected a double type when creating const f64 value!"
-        );
+            self.kind(),
+            LLVMTypeKind::LLVMDoubleTypeKind,
+            "Expected a double type when creating const f64 value!"
+        );
 
-        let value_ref = unsafe { LLVMConstReal(self.type_ref(), n) };
-        Value::new(value_ref)
+        let value_ref = unsafe { LLVMConstReal(self.type_ref(), n) };
+        Value::new(value_ref)
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file diff --git a/src/llvm_kaleidoscope_rs/llvm/value.rs.html b/src/llvm_kaleidoscope_rs/llvm/value.rs.html index eaea9c3..102c957 100644 --- a/src/llvm_kaleidoscope_rs/llvm/value.rs.html +++ b/src/llvm_kaleidoscope_rs/llvm/value.rs.html @@ -1,10 +1,4 @@ -value.rs - source - 
1
+value.rs - source
1
 2
 3
 4
@@ -241,243 +235,242 @@
 235
 236
 237
-
#![allow(unused)]
-
-use llvm_sys::{
-    analysis::{LLVMVerifierFailureAction, LLVMVerifyFunction},
-    core::{
-        LLVMAddIncoming, LLVMAppendExistingBasicBlock, LLVMCountBasicBlocks, LLVMCountParams,
-        LLVMDumpValue, LLVMGetParam, LLVMGetReturnType, LLVMGetValueKind, LLVMGetValueName2,
-        LLVMIsAFunction, LLVMIsAPHINode, LLVMSetValueName2, LLVMTypeOf,
+
#![allow(unused)]
+
+use llvm_sys::{
+    analysis::{LLVMVerifierFailureAction, LLVMVerifyFunction},
+    core::{
+        LLVMAddIncoming, LLVMAppendExistingBasicBlock, LLVMCountBasicBlocks, LLVMCountParams,
+        LLVMDumpValue, LLVMGetParam, LLVMGetReturnType, LLVMGetValueKind, LLVMGetValueName2,
+        LLVMIsAFunction, LLVMIsAPHINode, LLVMSetValueName2, LLVMTypeOf,
     },
-    prelude::LLVMValueRef,
-    LLVMTypeKind, LLVMValueKind,
+    prelude::LLVMValueRef,
+    LLVMTypeKind, LLVMValueKind,
 };
 
-use std::ffi::CStr;
-use std::marker::PhantomData;
-use std::ops::Deref;
-
-use super::BasicBlock;
-use super::Type;
-
-/// Wrapper for a LLVM Value Reference.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct Value<'llvm>(LLVMValueRef, PhantomData<&'llvm ()>);
-
-impl<'llvm> Value<'llvm> {
-    /// Create a new Value instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `value_ref` is a null pointer.
-    pub(super) fn new(value_ref: LLVMValueRef) -> Self {
-        assert!(!value_ref.is_null());
-        Value(value_ref, PhantomData)
+use std::ffi::CStr;
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+use super::BasicBlock;
+use super::Type;
+
+/// Wrapper for a LLVM Value Reference.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Value<'llvm>(LLVMValueRef, PhantomData<&'llvm ()>);
+
+impl<'llvm> Value<'llvm> {
+    /// Create a new Value instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `value_ref` is a null pointer.
+    pub(super) fn new(value_ref: LLVMValueRef) -> Self {
+        assert!(!value_ref.is_null());
+        Value(value_ref, PhantomData)
     }
 
-    /// Get the raw LLVM value reference.
-    #[inline]
-    pub(super) fn value_ref(&self) -> LLVMValueRef {
-        self.0
-    }
+    /// Get the raw LLVM value reference.
+    #[inline]
+    pub(super) fn value_ref(&self) -> LLVMValueRef {
+        self.0
+    }
 
-    /// Get the LLVM value kind for the given value reference.
-    pub(super) fn kind(&self) -> LLVMValueKind {
-        unsafe { LLVMGetValueKind(self.value_ref()) }
+    /// Get the LLVM value kind for the given value reference.
+    pub(super) fn kind(&self) -> LLVMValueKind {
+        unsafe { LLVMGetValueKind(self.value_ref()) }
     }
 
-    /// Check if value is `function` type.
-    pub(super) fn is_function(&self) -> bool {
-        let cast = unsafe { LLVMIsAFunction(self.value_ref()) };
-        !cast.is_null()
+    /// Check if value is `function` type.
+    pub(super) fn is_function(&self) -> bool {
+        let cast = unsafe { LLVMIsAFunction(self.value_ref()) };
+        !cast.is_null()
     }
 
-    /// Check if value is `phinode` type.
-    pub(super) fn is_phinode(&self) -> bool {
-        let cast = unsafe { LLVMIsAPHINode(self.value_ref()) };
-        !cast.is_null()
+    /// Check if value is `phinode` type.
+    pub(super) fn is_phinode(&self) -> bool {
+        let cast = unsafe { LLVMIsAPHINode(self.value_ref()) };
+        !cast.is_null()
     }
 
-    /// Dump the LLVM Value to stdout.
-    pub fn dump(&self) {
-        unsafe { LLVMDumpValue(self.value_ref()) };
+    /// Dump the LLVM Value to stdout.
+    pub fn dump(&self) {
+        unsafe { LLVMDumpValue(self.value_ref()) };
     }
 
-    /// Get a type reference representing for the given value reference.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn type_of(&self) -> Type<'llvm> {
-        let type_ref = unsafe { LLVMTypeOf(self.value_ref()) };
-        Type::new(type_ref)
+    /// Get a type reference representing for the given value reference.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn type_of(&self) -> Type<'llvm> {
+        let type_ref = unsafe { LLVMTypeOf(self.value_ref()) };
+        Type::new(type_ref)
     }
 
-    /// Set the name for the given value reference.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn set_name(&self, name: &str) {
-        unsafe { LLVMSetValueName2(self.value_ref(), name.as_ptr().cast(), name.len()) };
+    /// Set the name for the given value reference.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn set_name(&self, name: &str) {
+        unsafe { LLVMSetValueName2(self.value_ref(), name.as_ptr().cast(), name.len()) };
     }
 
-    /// Get the name for the given value reference.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn get_name(&self) -> &'llvm str {
-        let name = unsafe {
-            let mut len: libc::size_t = 0;
-            let name = LLVMGetValueName2(self.0, &mut len as _);
-            assert!(!name.is_null());
-
-            CStr::from_ptr(name)
+    /// Get the name for the given value reference.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn get_name(&self) -> &'llvm str {
+        let name = unsafe {
+            let mut len: libc::size_t = 0;
+            let name = LLVMGetValueName2(self.0, &mut len as _);
+            assert!(!name.is_null());
+
+            CStr::from_ptr(name)
         };
 
-        // TODO: Does this string live for the time of the LLVM context?!
-        name.to_str()
-            .expect("Expected valid UTF8 string from LLVM API")
+        // TODO: Does this string live for the time of the LLVM context?!
+        name.to_str()
+            .expect("Expected valid UTF8 string from LLVM API")
     }
 
-    /// Check if value is of `f64` type.
-    pub fn is_f64(&self) -> bool {
-        self.type_of().kind() == LLVMTypeKind::LLVMDoubleTypeKind
+    /// Check if value is of `f64` type.
+    pub fn is_f64(&self) -> bool {
+        self.type_of().kind() == LLVMTypeKind::LLVMDoubleTypeKind
     }
 
-    /// Check if value is of integer type.
-    pub fn is_int(&self) -> bool {
-        self.type_of().kind() == LLVMTypeKind::LLVMIntegerTypeKind
+    /// Check if value is of integer type.
+    pub fn is_int(&self) -> bool {
+        self.type_of().kind() == LLVMTypeKind::LLVMIntegerTypeKind
     }
 }
 
-/// Wrapper for a LLVM Value Reference specialized for contexts where function values are needed.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct FnValue<'llvm>(Value<'llvm>);
+/// Wrapper for a LLVM Value Reference specialized for contexts where function values are needed.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct FnValue<'llvm>(Value<'llvm>);
 
-impl<'llvm> Deref for FnValue<'llvm> {
-    type Target = Value<'llvm>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
+impl<'llvm> Deref for FnValue<'llvm> {
+    type Target = Value<'llvm>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
-impl<'llvm> FnValue<'llvm> {
-    /// Create a new FnValue instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `value_ref` is a null pointer.
-    pub(super) fn new(value_ref: LLVMValueRef) -> Self {
-        let value = Value::new(value_ref);
+impl<'llvm> FnValue<'llvm> {
+    /// Create a new FnValue instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `value_ref` is a null pointer.
+    pub(super) fn new(value_ref: LLVMValueRef) -> Self {
+        let value = Value::new(value_ref);
         debug_assert!(
-            value.is_function(),
-            "Expected a fn value when constructing FnValue!"
-        );
+            value.is_function(),
+            "Expected a fn value when constructing FnValue!"
+        );
 
-        FnValue(value)
+        FnValue(value)
     }
 
-    /// Get a type reference representing the return value of the given function value.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer.
-    pub fn ret_type(&self) -> Type<'llvm> {
-        let type_ref = unsafe { LLVMGetReturnType(LLVMTypeOf(self.value_ref())) };
-        Type::new(type_ref)
+    /// Get a type reference representing the return value of the given function value.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer.
+    pub fn ret_type(&self) -> Type<'llvm> {
+        let type_ref = unsafe { LLVMGetReturnType(LLVMTypeOf(self.value_ref())) };
+        Type::new(type_ref)
     }
 
-    /// Get the number of function arguments for the given function value.
-    pub fn args(&self) -> usize {
-        unsafe { LLVMCountParams(self.value_ref()) as usize }
+    /// Get the number of function arguments for the given function value.
+    pub fn args(&self) -> usize {
+        unsafe { LLVMCountParams(self.value_ref()) as usize }
     }
 
-    /// Get a value reference for the function argument at index `idx`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if LLVM API returns a `null` pointer or indexed out of bounds.
-    pub fn arg(&self, idx: usize) -> Value<'llvm> {
-        assert!(idx < self.args());
+    /// Get a value reference for the function argument at index `idx`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if LLVM API returns a `null` pointer or indexed out of bounds.
+    pub fn arg(&self, idx: usize) -> Value<'llvm> {
+        assert!(idx < self.args());
 
-        let value_ref = unsafe { LLVMGetParam(self.value_ref(), idx as libc::c_uint) };
-        Value::new(value_ref)
+        let value_ref = unsafe { LLVMGetParam(self.value_ref(), idx as libc::c_uint) };
+        Value::new(value_ref)
     }
 
-    /// Get the number of Basic Blocks for the given function value.
-    pub fn basic_blocks(&self) -> usize {
-        unsafe { LLVMCountBasicBlocks(self.value_ref()) as usize }
+    /// Get the number of Basic Blocks for the given function value.
+    pub fn basic_blocks(&self) -> usize {
+        unsafe { LLVMCountBasicBlocks(self.value_ref()) as usize }
     }
 
-    /// Append a Basic Block to the end of the function value.
-    pub fn append_basic_block(&self, bb: BasicBlock<'llvm>) {
-        unsafe {
-            LLVMAppendExistingBasicBlock(self.value_ref(), bb.bb_ref());
+    /// Append a Basic Block to the end of the function value.
+    pub fn append_basic_block(&self, bb: BasicBlock<'llvm>) {
+        unsafe {
+            LLVMAppendExistingBasicBlock(self.value_ref(), bb.bb_ref());
         }
     }
 
-    /// Verify that the given function is valid.
-    pub fn verify(&self) -> bool {
-        unsafe {
-            LLVMVerifyFunction(
-                self.value_ref(),
-                LLVMVerifierFailureAction::LLVMPrintMessageAction,
-            ) == 0
-        }
+    /// Verify that the given function is valid.
+    pub fn verify(&self) -> bool {
+        unsafe {
+            LLVMVerifyFunction(
+                self.value_ref(),
+                LLVMVerifierFailureAction::LLVMPrintMessageAction,
+            ) == 0
+        }
     }
 }
 
-/// Wrapper for a LLVM Value Reference specialized for contexts where phi values are needed.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct PhiValue<'llvm>(Value<'llvm>);
+/// Wrapper for a LLVM Value Reference specialized for contexts where phi values are needed.
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct PhiValue<'llvm>(Value<'llvm>);
 
-impl<'llvm> Deref for PhiValue<'llvm> {
-    type Target = Value<'llvm>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
+impl<'llvm> Deref for PhiValue<'llvm> {
+    type Target = Value<'llvm>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
-impl<'llvm> PhiValue<'llvm> {
-    /// Create a new PhiValue instance.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `value_ref` is a null pointer.
-    pub(super) fn new(value_ref: LLVMValueRef) -> Self {
-        let value = Value::new(value_ref);
+impl<'llvm> PhiValue<'llvm> {
+    /// Create a new PhiValue instance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `value_ref` is a null pointer.
+    pub(super) fn new(value_ref: LLVMValueRef) -> Self {
+        let value = Value::new(value_ref);
         debug_assert!(
-            value.is_phinode(),
-            "Expected a phinode value when constructing PhiValue!"
-        );
+            value.is_phinode(),
+            "Expected a phinode value when constructing PhiValue!"
+        );
 
-        PhiValue(value)
+        PhiValue(value)
     }
 
-    /// Add an incoming value to the end of a PHI list.
-    pub fn add_incoming(&self, ival: Value<'llvm>, ibb: BasicBlock<'llvm>) {
+    /// Add an incoming value to the end of a PHI list.
+    pub fn add_incoming(&self, ival: Value<'llvm>, ibb: BasicBlock<'llvm>) {
         debug_assert_eq!(
-            ival.type_of().kind(),
-            self.type_of().kind(),
-            "Type of incoming phi value must be the same as the type used to build the phi node."
-        );
-
-        unsafe {
-            LLVMAddIncoming(
-                self.value_ref(),
-                &mut ival.value_ref() as _,
-                &mut ibb.bb_ref() as _,
+            ival.type_of().kind(),
+            self.type_of().kind(),
+            "Type of incoming phi value must be the same as the type used to build the phi node."
+        );
+
+        unsafe {
+            LLVMAddIncoming(
+                self.value_ref(),
+                &mut ival.value_ref() as _,
+                &mut ibb.bb_ref() as _,
                 1,
             );
         }
     }
 }
 

-

-
\ No newline at end of file
+
\ No newline at end of file -- cgit v1.2.3