Merge pull request TomBebbington#7 from HeroesGrave/master

Implement more functionality for globals + more

Author: TomBebbington

Cargo.lock

@@ -1,14 +1,14 @@
 use ffi::core;
 use ffi::prelude::LLVMBasicBlockRef;
-use value::Value;
+use value::Function;
 use util;
 
 /// A container of instructions that execute sequentially.
 pub struct BasicBlock;
 native_ref!(&BasicBlock = LLVMBasicBlockRef);
 impl BasicBlock {
     /// Return the enclosing method, or `None` if it is not attached to a method.
-    pub fn get_parent(&self) -> Option<&Value> {
+    pub fn get_parent(&self) -> Option<&Function> {
         unsafe { util::ptr_to_null(core::LLVMGetBasicBlockParent(self.into())) }
     }
     /// Move this basic block after the `other` basic block in its function.

src/block.rs

@@ -119,6 +119,10 @@ impl Builder {
     pub fn build_insert_value(&self, agg: &Value, elem: &Value, index: usize) -> &Value {
         unsafe { core::LLVMBuildInsertValue(self.into(), agg.into(), elem.into(), index as c_uint, NULL_NAME.as_ptr()).into() }
     }
+    /// Build an instruction that extracts a value from an aggregate data value.
+    pub fn build_extract_value(&self, agg: &Value, index: usize) -> &Value {
+        unsafe { core::LLVMBuildExtractValue(self.into(), agg.into(), index as c_uint, NULL_NAME.as_ptr()).into() }
+    }
     /// Build an instruction that computes the address of a subelement of an aggregate data structure.
     ///
     /// Basically type-safe pointer arithmetic.

src/builder.rs

@@ -17,7 +17,7 @@ use value::{Function, Value};
 /// An abstract interface for implementation execution of LLVM modules.
 ///
 /// This is designed to support both interpreter and just-in-time (JIT) compiler implementations.
-pub trait ExecutionEngine<'a, 'b:'a> where LLVMExecutionEngineRef:From<&'b Self> {
+pub trait ExecutionEngine<'a, 'b:'a>:Sized+'b where LLVMExecutionEngineRef:From<&'b Self> {
     /// The options given to the engine upon creation.
     type Options : Copy;
     /// Create a new execution engine with the given `Module` and options, or return a
@@ -130,9 +130,9 @@ impl<'a, 'b> JitEngine<'a> {
         mem::transmute(ptr)
     }
 }
-impl<'a, 'b:'a> ExecutionEngine<'a, 'b> for JitEngine<'a> {
+impl<'a, 'b:'a> ExecutionEngine<'a, 'b> for JitEngine<'b> {
     type Options = JitOptions;
-    fn new(module: &'a Module, options: JitOptions) -> Result<JitEngine<'a>, CBox<str>> {
+    fn new(module: &'a Module, options: JitOptions) -> Result<JitEngine<'b>, CBox<str>> {
         unsafe {
             let mut ee = mem::uninitialized();
             let mut out = mem::zeroed();
@@ -176,9 +176,9 @@ impl<'a> Interpreter<'a> {
         unsafe { engine::LLVMRunFunction(self.into(), function.into(), args.len() as c_uint, ptr).into() }
     }
 }
-impl<'a, 'b:'a> ExecutionEngine<'a, 'b> for Interpreter<'a> {
+impl<'a, 'b:'a> ExecutionEngine<'a, 'b> for Interpreter<'b> {
     type Options = ();
-    fn new(module: &'a Module, _: ()) -> Result<Interpreter<'a>, CBox<str>> {
+    fn new(module: &'a Module, _: ()) -> Result<Interpreter<'b>, CBox<str>> {
         unsafe {
             let mut ee = mem::uninitialized();
             let mut out = mem::zeroed();

src/engine.rs

@@ -29,9 +29,9 @@ pub use block::BasicBlock;
 pub use compile::Compile;
 pub use context::{Context, GetContext};
 pub use engine::{JitEngine, JitOptions, Interpreter, ExecutionEngine, GenericValue, GenericValueCast};
-pub use module::{Module, Functions};
+pub use module::{AddressSpace, Module, Functions};
 pub use object::{ObjectFile, Symbol, Symbols};
 pub use target::{TargetData, Target};
 pub use ty::{FunctionType, StructType, Type};
-pub use value::{Arg, Attribute, Value, Function, Predicate};
+pub use value::{Alias, Arg, Attribute, Value, Function, GlobalValue, GlobalVariable, Linkage, Predicate};
 pub use util::CastFrom;

src/lib.rs

@@ -16,7 +16,7 @@ use std::path::Path;
 use std::process::Command;
 use buffer::MemoryBuffer;
 use context::{Context, GetContext};
-use value::{Function, Value};
+use value::{Alias, Function, GlobalValue, GlobalVariable, Value};
 use ty::Type;
 use util;
 
@@ -43,21 +43,31 @@ impl Module {
         unsafe { CSemiBox::new(core::LLVMModuleCreateWithNameInContext(c_name.as_ptr(), context.into())) }
     }
     /// Add a global to the module with the given type and name.
-    pub fn add_global<'a>(&'a self, name: &str, ty: &'a Type) -> &'a Value {
+    pub fn add_global<'a>(&'a self, name: &str, ty: &'a Type) -> &'a GlobalVariable {
         util::with_cstr(name, |ptr| unsafe {
             core::LLVMAddGlobal(self.into(), ty.into(), ptr).into()
         })
     }
-    /// Add a constant global to the module with the given type, name and value.
-    pub fn add_global_constant<'a>(&'a self, name: &str, val: &'a Value) -> &'a Value {
+    /// Add a global variable to the module with the given type, name and initial value.
+    pub fn add_global_in_address_space<'a>(&'a self, name: &str, ty: &'a Type, address: AddressSpace) -> &'a GlobalVariable {
         util::with_cstr(name, |ptr| unsafe {
-            let global = core::LLVMAddGlobal(self.into(), val.get_type().into(), ptr);
-            core::LLVMSetInitializer (global.into(), val.into());
-            global.into()
+            core::LLVMAddGlobalInAddressSpace(self.into(), ty.into(), ptr, address as u32).into()
+        })
+    }
+    /// Add a global variable to the module with the given type, name and initial value.
+    pub fn add_global_variable<'a>(&'a self, name: &str, val: &'a Value) -> &'a GlobalVariable {
+        let global = self.add_global(name, val.get_type());
+        global.set_initializer(val);
+        global
+    }
+    /// Add a global to the module with the given type and name.
+    pub fn add_global_alias<'a>(&'a self, name: &str, val: &'a GlobalValue) -> &'a Alias {
+        util::with_cstr(name, |ptr| unsafe {
+            core::LLVMAddAlias(self.into(), val.get_type().into(), val.into(), ptr).into()
         })
     }
     /// Get the global with the name given, or `None` if no global with that name exists.
-    pub fn get_global<'a>(&'a self, name: &str) -> Option<&'a Value> {
+    pub fn get_global<'a>(&'a self, name: &str) -> Option<&'a GlobalValue> {
         util::with_cstr(name, |ptr| unsafe {
             let ptr = core::LLVMGetNamedGlobal(self.into(), ptr);
             util::ptr_to_null(ptr)
@@ -238,3 +248,13 @@ impl<'a> Iterator for Functions<'a> {
         }
     }
 }
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[repr(C)]
+pub enum AddressSpace {
+    Generic = 0,
+    Global = 1,
+    Shared = 3,
+    Const = 4,
+    Local = 5,
+}

src/module.rs

@@ -35,8 +35,8 @@ impl Type {
         unsafe { core::LLVMPointerType(elem.into(), 0 as c_uint) }.into()
     }
     /// Make a new structure type with the given types.
-    pub fn new_struct<'a>(elems: &[&'a Type], packed: bool) -> &'a Type {
-        unsafe { core::LLVMStructType(elems.as_ptr() as *mut LLVMTypeRef, elems.len() as c_uint, packed as c_int) }.into()
+    pub fn new_struct<'a>(context:&'a Context, elems: &[&'a Type], packed: bool) -> &'a Type {
+        unsafe { core::LLVMStructTypeInContext(context.into(), elems.as_ptr() as *mut LLVMTypeRef, elems.len() as c_uint, packed as c_int) }.into()
     }
     /// Returns true if the size of the type is known at compile-time.
     ///

src/ty.rs

@@ -1,6 +1,7 @@
 use libc::{c_char, c_uint, c_int};
 use ffi::prelude::LLVMValueRef;
 use ffi::{core, LLVMAttribute};
+use ffi::LLVMLinkage;
 use std::ffi::CString;
 use std::{fmt, mem};
 use std::ops::{Deref, Index};
@@ -109,12 +110,119 @@ impl Arg {
         unsafe { core::LLVMRemoveAttribute(self.into(), attr.into()) }
     }
 }
+
+/// A global value (eg: Function, Alias, Global variable)
+pub struct GlobalValue;
+native_ref!(&GlobalValue = LLVMValueRef);
+impl Deref for GlobalValue {
+    type Target = Value;
+    fn deref(&self) -> &Value {
+        unsafe { mem::transmute(self) }
+    }
+}
+impl CastFrom for GlobalValue {
+    type From = Value;
+    fn cast<'a>(val: &'a Value) -> Option<&'a GlobalValue> {
+        unsafe {
+            let global = mem::transmute(core::LLVMIsAGlobalValue(val.into()));
+            util::ptr_to_null(global)
+        }
+    }
+}
+impl GlobalValue {
+    /// Set the linkage type for this global
+    pub fn set_linkage(&self, linkage: Linkage) {
+        unsafe {
+            core::LLVMSetLinkage(self.into(), linkage.into());
+        }
+    }
+    /// Returns the linkage type for this global
+    pub fn get_linkage(&self) -> Linkage {
+        unsafe {
+            core::LLVMGetLinkage(self.into()).into()
+        }
+    }
+    /// Returns true if this global is a declaration (as opposed to a definition).
+    pub fn is_declaration(&self) -> bool {
+        unsafe {
+            // FIXME: There should be a constant somewhere, instead of '1'
+            core::LLVMIsDeclaration(self.into()) == 1
+        }
+    }
+}
+
+/// A global variable
+pub struct GlobalVariable;
+native_ref!(&GlobalVariable = LLVMValueRef);
+impl Deref for GlobalVariable {
+    type Target = GlobalValue;
+    fn deref(&self) -> &GlobalValue {
+        unsafe { mem::transmute(self) }
+    }
+}
+impl CastFrom for GlobalVariable {
+    type From = Value;
+    fn cast<'a>(val: &'a Value) -> Option<&'a GlobalVariable> {
+        unsafe {
+            let global = mem::transmute(core::LLVMIsAGlobalVariable(val.into()));
+            util::ptr_to_null(global)
+        }
+    }
+}
+impl GlobalVariable {
+    /// Set the initial value of the global
+    pub fn set_initializer(&self, val: &Value) {
+        unsafe {
+            core::LLVMSetInitializer(self.into(), val.into())
+        }
+    }
+    /// Set the initial value of the global
+    pub fn get_initializer(&self) -> Option<&Value> {
+        unsafe {
+            util::ptr_to_null(core::LLVMGetInitializer(self.into()))
+        }
+    }
+    /// Set whether this global is a constant.
+    pub fn set_constant(&self, is_constant: bool) {
+        let llvm_bool = if is_constant { 1 } else { 0 };
+        unsafe {
+            core::LLVMSetGlobalConstant(self.into(), llvm_bool);
+        }
+    }
+    /// Returns true if this global is a constant.
+    pub fn get_constant(&self) -> bool {
+        unsafe {
+            // FIXME: There should be a constant for True/False
+            core::LLVMIsGlobalConstant(self.into()) == 1
+        }
+    }
+}
+
+/// An alias to another global
+pub struct Alias;
+native_ref!(&Alias = LLVMValueRef);
+impl Deref for Alias {
+    type Target = GlobalValue;
+    fn deref(&self) -> &GlobalValue {
+        unsafe { mem::transmute(self) }
+    }
+}
+impl CastFrom for Alias {
+    type From = Value;
+    fn cast<'a>(val: &'a Value) -> Option<&'a Alias> {
+        unsafe {
+            let alias = mem::transmute(core::LLVMIsAGlobalAlias(val.into()));
+            util::ptr_to_null(alias)
+        }
+    }
+}
+
 /// A function that can be called and contains blocks.
 pub struct Function;
 native_ref!(&Function = LLVMValueRef);
 impl Deref for Function {
-    type Target = Value;
-    fn deref(&self) -> &Value {
+    type Target = GlobalValue;
+    fn deref(&self) -> &GlobalValue {
         unsafe { mem::transmute(self) }
     }
 }
@@ -279,6 +387,45 @@ impl From<Attribute> for LLVMAttribute {
         unsafe { mem::transmute(attr) }
     }
 }
+
+/// A way of indicating to LLVM how you want a global to interact during linkage.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[repr(C)]
+pub enum Linkage {
+    /// Default linkage. The global is externally visible and participates in linkage normally.
+    External            = 0,
+    /// Never emitted to the containing module's object file. Used to allow inlining and/or other optimisations to take place, given knowledge of the definition of the global, which is somewhere outside of the module. Otherwise the same as LinkOnceODR. Only allowed on definitions, not declarations.
+    AvailableExternally = 1,
+    /// Merged with other globals of the same name during linkage. Unreferenced LinkOnce globals may be discarded.
+    LinkOnceAny         = 2,
+    /// Similar to LinkOnceAny, but indicates that it will only be merged with equivalent globals.
+    LinkOnceODR         = 3,
+    /// Same merging semantics as LinkOnceAny. Unlike LinkOnce, unreference globals will not be discarded.
+    WeakAny             = 5,
+    /// Similar to WeakAny, but indicates that it will only be merged with equivalent globals.
+    WeakODR             = 6,
+    /// Only allowed on global array pointers. When two globals with Appending linkage are merged, they are appended together.
+    Appending           = 7,
+    /// Similar to Private, but shows as a local symbol in the object file.
+    Internal            = 8,
+    /// Only directly accessible by objects in the current module. May be renamed as neccessary to avoid collisions, and all references will be updated. Will not show up in the object file's symbol table.
+    Private             = 9,
+    /// Weak until linked. If not linked, the output symbol is null, instead of undefined.
+    ExternalWeak        = 12,
+    /// Similar to Weak, but may not have an explicit section, must have a zero initializer, and may not be marked constant. Cannot be used on functions or aliases.
+    Common              = 14,
+}
+impl From<LLVMLinkage> for Linkage {
+    fn from(attr: LLVMLinkage) -> Linkage {
+        unsafe { mem::transmute(attr) }
+    }
+}
+impl From<Linkage> for LLVMLinkage {
+    fn from(attr: Linkage) -> LLVMLinkage {
+        unsafe { mem::transmute(attr) }
+    }
+}
+
 impl GetContext for Value {
     fn get_context(&self) -> &Context {
         self.get_type().get_context()