| use std::ffi::{c_void, CStr, CString}; |
| use std::marker::PhantomData; |
| use std::mem; |
| use std::os::raw::{c_int, c_ulong}; |
| use std::ptr; |
| use std::str::Utf8Error; |
| |
| use gccjit_sys::gcc_jit_int_option::*; |
| use gccjit_sys::gcc_jit_str_option::*; |
| use gccjit_sys::gcc_jit_bool_option::*; |
| |
| use block::{self, BinaryOp, Block, UnaryOp, ComparisonOp}; |
| use field::{self, Field}; |
| use function::{self, Function, FunctionType}; |
| use location::{self, Location}; |
| use lvalue::{self, LValue}; |
| use object::{self, Object, ToObject}; |
| use parameter::{self, Parameter}; |
| use rvalue::{self, RValue, ToRValue}; |
| use structs::{self, Struct}; |
| #[cfg(feature="master")] |
| use target_info::{self, TargetInfo}; |
| use Type; |
| use types; |
| |
| #[repr(C)] |
| #[derive(Debug)] |
| pub enum GlobalKind { |
| Exported, |
| Internal, |
| Imported, |
| } |
| |
| /// Represents an optimization level that the JIT compiler |
| /// will use when compiling your code. |
| #[repr(C)] |
| #[derive(Debug)] |
| pub enum OptimizationLevel { |
| /// No optimizations are applied. |
| None, |
| /// Optimizies for both speed and code size, but doesn't apply |
| /// any optimizations that take extended periods of time. |
| Limited, |
| /// Performs all optimizations that do not involve a tradeoff |
| /// of code size for speed. |
| Standard, |
| /// Performs all optimizations at the Standard level, as well |
| /// as function inlining, loop vectorization, some loop unrolling, |
| /// and various other optimizations. |
| Aggressive |
| } |
| |
| /// This enum indicates to gccjit the format of the output |
| /// code that is written out by compile_to_file. |
| #[repr(C)] |
| pub enum OutputKind { |
| /// Outputs an assembly file (.S) |
| Assembler, |
| /// Outputs an object file (.o) |
| ObjectFile, |
| /// Outputs a dynamic library (.so) |
| DynamicLibrary, |
| /// Outputs an executable |
| Executable |
| } |
| |
| /// Represents a successful compilation of a context. This type |
| /// provides the means to access compiled functions and globals. |
| /// JIT compiled functions are exposted to Rust as an extern "C" function |
| /// pointer. |
| pub struct CompileResult { |
| ptr: *mut gccjit_sys::gcc_jit_result |
| } |
| |
| impl CompileResult { |
| /// Gets a function pointer to a JIT compiled function. If the function |
| /// does not exist (wasn't compiled by the Context that produced this |
| /// CompileResult), this function returns a null pointer. |
| /// |
| /// It is the caller's responsibility to ensure that this pointer is not used |
| /// past the lifetime of the CompileResult object. Second, it is |
| /// the caller's responsibility to check whether or not the pointer |
| /// is null. It is also expected that the caller of this function |
| /// will transmute this pointer to a function pointer type. |
| pub fn get_function<S: AsRef<str>>(&self, name: S) -> *mut () { |
| let c_str = CString::new(name.as_ref()).unwrap(); |
| unsafe { |
| let func = gccjit_sys::gcc_jit_result_get_code(self.ptr, |
| c_str.as_ptr()); |
| mem::transmute(func) |
| } |
| } |
| |
| /// Gets a pointer to a global variable that lives on the JIT heap. |
| /// |
| /// It is the caller's responsibility |
| /// to ensure that the pointer is not used past the lifetime of the |
| /// CompileResult object. It is also the caller's responsibility to |
| /// check whether or not the returned pointer is null. |
| pub fn get_global<S: AsRef<str>>(&self, name: S) -> *mut () { |
| let c_str = CString::new(name.as_ref()).unwrap(); |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_result_get_global(self.ptr, c_str.as_ptr()); |
| mem::transmute(ptr) |
| } |
| } |
| } |
| |
| impl Drop for CompileResult { |
| fn drop(&mut self) { |
| unsafe { |
| gccjit_sys::gcc_jit_result_release(self.ptr); |
| } |
| } |
| } |
| |
| pub struct Case<'ctx> { |
| marker: PhantomData<&'ctx Case<'ctx>>, |
| ptr: *mut gccjit_sys::gcc_jit_case, |
| } |
| |
| impl<'ctx> ToObject<'ctx> for Case<'ctx> { |
| fn to_object(&self) -> Object<'ctx> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_case_as_object(self.ptr); |
| object::from_ptr(ptr) |
| } |
| } |
| } |
| |
| /// Wrapper around a GCC JIT context object that keeps |
| /// the state of the JIT compiler. In GCCJIT, this object |
| /// is responsible for all memory management of JIT data |
| /// structures, and as such anything made from this context |
| /// must have a lifetime strictly less than this object. |
| /// |
| /// It's possible to create a child context from a parent context. |
| /// In that case, the child context must have a lifetime strictly |
| /// less than the parent context. |
| #[derive(Debug)] |
| pub struct Context<'ctx> { |
| marker: PhantomData<&'ctx Context<'ctx>>, |
| ptr: *mut gccjit_sys::gcc_jit_context |
| } |
| |
| impl Default for Context<'static> { |
| fn default() -> Context<'static> { |
| unsafe { |
| Context { |
| marker: PhantomData, |
| ptr: gccjit_sys::gcc_jit_context_acquire(), |
| } |
| } |
| } |
| } |
| |
| impl<'ctx> Context<'ctx> { |
| /// Sets the program name reported by the JIT. |
| pub fn set_program_name<S: AsRef<str>>(&self, name: S) { |
| let name_ref = name.as_ref(); |
| let c_str = CString::new(name_ref).unwrap(); |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_str_option(self.ptr, |
| GCC_JIT_STR_OPTION_PROGNAME, |
| c_str.as_ptr()); |
| } |
| } |
| |
| pub fn add_command_line_option<S: AsRef<str>>(&self, name: S) { |
| let c_str = CString::new(name.as_ref()).unwrap(); |
| unsafe { |
| gccjit_sys::gcc_jit_context_add_command_line_option(self.ptr, c_str.as_ptr()) |
| } |
| } |
| |
| pub fn add_driver_option<S: AsRef<str>>(&self, name: S) { |
| let c_str = CString::new(name.as_ref()).unwrap(); |
| unsafe { |
| gccjit_sys::gcc_jit_context_add_driver_option(self.ptr, c_str.as_ptr()) |
| } |
| } |
| |
| /// Sets the optimization level that the JIT compiler will use. |
| /// The higher the optimization level, the longer compilation will |
| /// take. |
| pub fn set_optimization_level(&self, level: OptimizationLevel) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_int_option(self.ptr, |
| GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, |
| level as i32); |
| } |
| } |
| |
| #[cfg(feature="master")] |
| pub fn set_output_ident(&self, ident: &str) { |
| let c_str = CString::new(ident).unwrap(); |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_output_ident(self.ptr, c_str.as_ptr()); |
| } |
| } |
| |
| #[cfg(feature="master")] |
| pub fn set_special_chars_allowed_in_func_names(&self, value: &str) { |
| let c_str = CString::new(value).unwrap(); |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_str_option(self.ptr, GCC_JIT_STR_OPTION_SPECIAL_CHARS_IN_FUNC_NAMES, c_str.as_ptr()); |
| } |
| } |
| |
| pub fn set_debug_info(&self, value: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_option(self.ptr, |
| GCC_JIT_BOOL_OPTION_DEBUGINFO, |
| value as i32); |
| } |
| } |
| |
| pub fn set_keep_intermediates(&self, value: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_option(self.ptr, |
| GCC_JIT_BOOL_OPTION_KEEP_INTERMEDIATES, |
| value as i32); |
| } |
| } |
| |
| pub fn set_print_errors_to_stderr(&self, enabled: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_print_errors_to_stderr(self.ptr, enabled as c_int); |
| } |
| } |
| |
| pub fn set_dump_everything(&self, value: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_option(self.ptr, |
| GCC_JIT_BOOL_OPTION_DUMP_EVERYTHING, |
| value as i32); |
| } |
| } |
| |
| pub fn set_dump_initial_gimple(&self, value: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_option(self.ptr, |
| GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE, |
| value as i32); |
| } |
| } |
| |
| /// When set to true, dumps the code that the JIT generates to standard |
| /// out during compilation. |
| pub fn set_dump_code_on_compile(&self, value: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_option(self.ptr, |
| GCC_JIT_BOOL_OPTION_DUMP_GENERATED_CODE, |
| value as i32); |
| } |
| } |
| |
| pub fn set_allow_unreachable_blocks(&self, value: bool) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_bool_allow_unreachable_blocks(self.ptr, value as i32); |
| } |
| } |
| |
| /// Compiles the context and returns a CompileResult that contains |
| /// the means to access functions and globals that have currently |
| /// been JIT compiled. |
| pub fn compile(&self) -> CompileResult { |
| unsafe { |
| CompileResult { |
| ptr: gccjit_sys::gcc_jit_context_compile(self.ptr) |
| } |
| } |
| } |
| |
| /// Compiles the context and saves the result to a file. The |
| /// type of the file is controlled by the OutputKind parameter. |
| pub fn compile_to_file<S: AsRef<str>>(&self, kind: OutputKind, file: S) { |
| unsafe { |
| let file_ref = file.as_ref(); |
| let cstr = CString::new(file_ref).unwrap(); |
| gccjit_sys::gcc_jit_context_compile_to_file(self.ptr, |
| mem::transmute::<OutputKind, gccjit_sys::gcc_jit_output_kind>(kind), |
| cstr.as_ptr()); |
| } |
| } |
| |
| #[cfg(feature="master")] |
| pub fn get_target_info(&self) -> TargetInfo { |
| unsafe { |
| target_info::from_ptr(gccjit_sys::gcc_jit_context_get_target_info(self.ptr)) |
| } |
| } |
| |
| /// Creates a new child context from this context. The child context |
| /// is a fully-featured context, but it has a lifetime that is strictly |
| /// less than the lifetime that spawned it. |
| pub fn new_child_context<'b>(&'b self) -> Context<'b> { |
| unsafe { |
| Context { |
| marker: PhantomData, |
| ptr: gccjit_sys::gcc_jit_context_new_child_context(self.ptr) |
| } |
| } |
| } |
| |
| pub fn new_case<S: ToRValue<'ctx>, T: ToRValue<'ctx>>(&self, min_value: S, max_value: T, dest_block: Block<'ctx>) -> Case<'ctx> { |
| let min_value = min_value.to_rvalue(); |
| let max_value = max_value.to_rvalue(); |
| let result = unsafe { |
| Case { |
| marker: PhantomData, |
| ptr: gccjit_sys::gcc_jit_context_new_case(self.ptr, rvalue::get_ptr(&min_value), rvalue::get_ptr(&max_value), |
| block::get_ptr(&dest_block)), |
| } |
| }; |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| result |
| } |
| |
| /// Creates a new location for use by gdb when debugging a JIT compiled |
| /// program. The filename, line, and col are used by gdb to "show" your |
| /// source when in a debugger. |
| pub fn new_location<'a, S: AsRef<str>>(&'a self, |
| filename: S, |
| line: i32, |
| col: i32) -> Location<'a> { |
| unsafe { |
| let filename_ref = filename.as_ref(); |
| let cstr = CString::new(filename_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_location(self.ptr, |
| cstr.as_ptr(), |
| line, |
| col); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| location::from_ptr(ptr) |
| } |
| } |
| |
| pub fn new_global<'a, S: AsRef<str>>(&self, loc: Option<Location<'a>>, kind: GlobalKind, ty: Type<'a>, name: S) -> LValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| let cstr = CString::new(name.as_ref()).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_global( |
| self.ptr, |
| loc_ptr, |
| mem::transmute::<GlobalKind, gccjit_sys::gcc_jit_global_kind>(kind), |
| types::get_ptr(&ty), |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| lvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Constructs a new type for any type that implements the Typeable trait. |
| /// This library only provides a handful of implementations of Typeable |
| /// for some primitive types - utilizers of this library are encouraged |
| /// to provide their own types that implement Typeable for ease of type |
| /// creation. |
| pub fn new_type<'a, T: types::Typeable>(&'a self) -> types::Type<'a> { |
| <T as types::Typeable>::get_type(self) |
| } |
| |
| pub fn new_c_type<'a>(&'a self, c_type: CType) -> types::Type<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_get_type(get_ptr(self), c_type.to_sys()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| types::from_ptr(ptr) |
| } |
| } |
| |
| pub fn new_int_type<'a>(&'a self, num_bytes: i32, signed: bool) -> types::Type<'a> { |
| unsafe { |
| let ctx_ptr = get_ptr(self); |
| let ptr = gccjit_sys::gcc_jit_context_get_int_type(ctx_ptr, num_bytes, signed as i32); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| types::from_ptr(ptr) |
| } |
| } |
| |
| /// Constructs a new field with an optional source location, type, and name. |
| /// This field can be used to compose unions or structs. |
| pub fn new_field<'a, S: AsRef<str>>(&'a self, |
| loc: Option<Location<'a>>, |
| ty: types::Type<'a>, |
| name: S) -> Field<'a> { |
| let name_ref = name.as_ref(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let cstr = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_field(self.ptr, |
| loc_ptr, |
| types::get_ptr(&ty), |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| field::from_ptr(ptr) |
| } |
| } |
| |
| /// Constructs a new array type with a given base element type and a |
| /// size. |
| pub fn new_array_type<'a>(&'a self, |
| loc: Option<Location<'a>>, |
| ty: types::Type<'a>, |
| num_elements: u64) -> types::Type<'a> { |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_array_type(self.ptr, |
| loc_ptr, |
| types::get_ptr(&ty), |
| num_elements as c_ulong); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| types::from_ptr(ptr) |
| } |
| } |
| |
| pub fn new_vector_type<'a>(&'a self, ty: types::Type<'a>, num_units: u64) -> types::Type<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_type_get_vector(types::get_ptr(&ty), num_units as _); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| types::from_ptr(ptr) |
| } |
| } |
| |
| /// Constructs a new struct type with the given name, optional source location, |
| /// and a list of fields. The returned struct is concrete and new fields cannot |
| /// be added to it. |
| pub fn new_struct_type<'a, S: AsRef<str>>(&'a self, |
| loc: Option<Location<'a>>, |
| name: S, |
| fields: &[Field<'a>]) -> Struct<'a> { |
| let name_ref = name.as_ref(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| let num_fields = fields.len() as i32; |
| let mut fields_ptrs : Vec<_> = fields.iter() |
| .map(|x| unsafe { field::get_ptr(x) }) |
| .collect(); |
| unsafe { |
| let cname = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_struct_type(self.ptr, |
| loc_ptr, |
| cname.as_ptr(), |
| num_fields, |
| fields_ptrs.as_mut_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| structs::from_ptr(ptr) |
| } |
| } |
| |
| /// Constructs a new struct type whose fields are not known. Fields can |
| /// be added to this struct later, but only once. |
| pub fn new_opaque_struct_type<'a, S: AsRef<str>>(&'a self, |
| loc: Option<Location<'a>>, |
| name: S) -> Struct<'a> { |
| let name_ref = name.as_ref(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let cstr = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_opaque_struct(self.ptr, |
| loc_ptr, |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| structs::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new union type from a set of fields. |
| pub fn new_union_type<'a, S: AsRef<str>>(&'a self, |
| loc: Option<Location<'a>>, |
| name: S, |
| fields: &[Field<'a>]) -> types::Type<'a> { |
| let name_ref = name.as_ref(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| let num_fields = fields.len() as i32; |
| let mut fields_ptrs : Vec<_> = fields.iter() |
| .map(|x| unsafe { field::get_ptr(x) }) |
| .collect(); |
| unsafe { |
| let cname = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_union_type(self.ptr, |
| loc_ptr, |
| cname.as_ptr(), |
| num_fields, |
| fields_ptrs.as_mut_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| types::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new function pointer type with the given return type |
| /// parameter types, and an optional location. The last flag can |
| /// make the function variadic, although Rust can't really handle |
| /// the varargs calling convention. |
| pub fn new_function_pointer_type<'a>(&'a self, |
| loc: Option<Location<'a>>, |
| return_type: types::Type<'a>, |
| param_types: &[types::Type<'a>], |
| is_variadic: bool) -> types::Type<'a> { |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| let num_types = param_types.len() as i32; |
| let mut types_ptrs : Vec<_> = param_types.iter() |
| .map(|x| unsafe { types::get_ptr(x) }) |
| .collect(); |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_function_ptr_type(self.ptr, |
| loc_ptr, |
| types::get_ptr(&return_type), |
| num_types, |
| types_ptrs.as_mut_ptr(), |
| is_variadic as i32); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| types::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new function with the given function kind, return type, parameters, name, |
| /// and whether or not the function is variadic. |
| pub fn new_function<'a, S: AsRef<str>>(&'a self, |
| loc: Option<Location<'a>>, |
| kind: FunctionType, |
| return_ty: types::Type<'a>, |
| params: &[Parameter<'a>], |
| name: S, |
| is_variadic: bool) -> Function<'a> { |
| let name_ref = name.as_ref(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| let num_params = params.len() as i32; |
| let mut params_ptrs : Vec<_> = params.iter() |
| .map(|x| unsafe { parameter::get_ptr(x) }) |
| .collect(); |
| unsafe { |
| let cstr = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_function(self.ptr, |
| loc_ptr, |
| mem::transmute::<FunctionType, gccjit_sys::gcc_jit_function_kind>(kind), |
| types::get_ptr(&return_ty), |
| cstr.as_ptr(), |
| num_params, |
| params_ptrs.as_mut_ptr(), |
| is_variadic as i32); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| function::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new binary operation between two RValues and produces a new RValue. |
| pub fn new_binary_op<'a, L: ToRValue<'a>, R: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| op: BinaryOp, |
| ty: types::Type<'a>, |
| left: L, |
| right: R) -> RValue<'a> { |
| let left_rvalue = left.to_rvalue(); |
| let right_rvalue = right.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_binary_op(self.ptr, |
| loc_ptr, |
| mem::transmute::<BinaryOp, gccjit_sys::gcc_jit_binary_op>(op), |
| types::get_ptr(&ty), |
| rvalue::get_ptr(&left_rvalue), |
| rvalue::get_ptr(&right_rvalue)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a unary operation on one RValue and produces a result RValue. |
| pub fn new_unary_op<'a, T: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| op: UnaryOp, |
| ty: types::Type<'a>, |
| target: T) -> RValue<'a> { |
| let rvalue = target.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_unary_op(self.ptr, |
| loc_ptr, |
| mem::transmute::<UnaryOp, gccjit_sys::gcc_jit_unary_op>(op), |
| types::get_ptr(&ty), |
| rvalue::get_ptr(&rvalue)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| pub fn new_comparison<'a, L: ToRValue<'a>, R: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| op: ComparisonOp, |
| left: L, |
| right: R) -> RValue<'a> { |
| let left_rvalue = left.to_rvalue(); |
| let right_rvalue = right.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_comparison(self.ptr, |
| loc_ptr, |
| mem::transmute::<ComparisonOp, gccjit_sys::gcc_jit_comparison>(op), |
| rvalue::get_ptr(&left_rvalue), |
| rvalue::get_ptr(&right_rvalue)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a function call to a function object with a given number of parameters. |
| /// The RValue that is returned is the result of the function call. |
| /// Note that due to the way that Rust's generics work, it is currently |
| /// not possible to be generic over different types of arguments (RValues |
| /// together with LValues and Parameters, for example), so in order to |
| /// mix the types of the arguments it may be necessary to call to_rvalue() |
| /// before calling this function. |
| #[must_use] |
| pub fn new_call<'a>(&'a self, |
| loc: Option<Location<'a>>, |
| func: Function<'a>, |
| args: &[RValue<'a>]) -> RValue<'a> { |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| let num_params = args.len() as i32; |
| let mut params_ptrs : Vec<_> = args.iter() |
| .map(|x| unsafe { rvalue::get_ptr(x) }) |
| .collect(); |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_call(self.ptr, |
| loc_ptr, |
| function::get_ptr(&func), |
| num_params, |
| params_ptrs.as_mut_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates an indirect function call that dereferences a function pointer and |
| /// attempts to invoke it with the given arguments. The RValue that is returned |
| /// is the result of the function call. |
| pub fn new_call_through_ptr<'a, F: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| fun_ptr: F, |
| args: &[RValue<'a>]) -> RValue<'a> { |
| let fun_ptr_rvalue = fun_ptr.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| let num_params = args.len() as i32; |
| let mut params_ptrs : Vec<_> = args.iter() |
| .map(|x| x.to_rvalue()) |
| .map(|x| unsafe { rvalue::get_ptr(&x) }) |
| .collect(); |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_call_through_ptr(self.ptr, |
| loc_ptr, |
| rvalue::get_ptr(&fun_ptr_rvalue), |
| num_params, |
| params_ptrs.as_mut_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Cast an RValue to a specific type. I don't know what happens when the cast fails yet. |
| pub fn new_cast<'a, T: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| value: T, |
| dest_type: types::Type<'a>) -> RValue<'a> { |
| let rvalue = value.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_cast(self.ptr, |
| loc_ptr, |
| rvalue::get_ptr(&rvalue), |
| types::get_ptr(&dest_type)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Bitcast an RValue to a specific type. |
| pub fn new_bitcast<'a, T: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| value: T, |
| dest_type: types::Type<'a>) -> RValue<'a> { |
| let rvalue = value.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_bitcast(self.ptr, |
| loc_ptr, |
| rvalue::get_ptr(&rvalue), |
| types::get_ptr(&dest_type)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates an LValue from an array pointer and an offset. The LValue can be the target |
| /// of an assignment, or it can be converted into an RValue (i.e. loaded). |
| pub fn new_array_access<'a, A: ToRValue<'a>, I: ToRValue<'a>>(&'a self, |
| loc: Option<Location<'a>>, |
| array_ptr: A, |
| index: I) -> LValue<'a> { |
| let array_rvalue = array_ptr.to_rvalue(); |
| let idx_rvalue = index.to_rvalue(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_array_access(self.ptr, |
| loc_ptr, |
| rvalue::get_ptr(&array_rvalue), |
| rvalue::get_ptr(&idx_rvalue)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| lvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new RValue from a given long value. |
| pub fn new_rvalue_from_long<'a>(&'a self, |
| ty: types::Type<'a>, |
| value: i64) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_rvalue_from_long(self.ptr, |
| types::get_ptr(&ty), |
| value as _); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| pub fn new_rvalue_from_vector<'a>(&'a self, loc: Option<Location<'a>>, vec_type: types::Type<'a>, elements: &[RValue<'a>]) -> RValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| let ptr = gccjit_sys::gcc_jit_context_new_rvalue_from_vector(self.ptr, loc_ptr, types::get_ptr(&vec_type), elements.len() as _, elements.as_ptr() as *mut *mut _); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| #[cfg(feature="master")] |
| pub fn new_rvalue_vector_perm<'a>(&'a self, loc: Option<Location<'a>>, elements1: RValue<'a>, elements2: RValue<'a>, mask: RValue<'a>) -> RValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| let ptr = gccjit_sys::gcc_jit_context_new_rvalue_vector_perm(self.ptr, loc_ptr, rvalue::get_ptr(&elements1), rvalue::get_ptr(&elements2), rvalue::get_ptr(&mask)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| //pub fn gcc_jit_context_new_union_constructor(ctxt: *mut gcc_jit_context, loc: *mut gcc_jit_location, typ: *mut gcc_jit_type, field: *mut gcc_jit_field, value: *mut gcc_jit_rvalue) -> *mut gcc_jit_rvalue; |
| |
| pub fn new_struct_constructor<'a>(&'a self, loc: Option<Location<'a>>, struct_type: types::Type<'a>, fields: Option<&[Field<'a>]>, values: &[RValue<'a>]) -> RValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| let fields_ptr = |
| match fields { |
| Some(fields) => fields.as_ptr(), |
| None => ptr::null_mut(), |
| }; |
| |
| let ptr = gccjit_sys::gcc_jit_context_new_struct_constructor(self.ptr, loc_ptr, types::get_ptr(&struct_type), values.len() as _, fields_ptr as *mut *mut _, values.as_ptr() as *mut *mut _); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| pub fn new_array_constructor<'a>(&'a self, loc: Option<Location<'a>>, array_type: types::Type<'a>, elements: &[RValue<'a>]) -> RValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| let ptr = gccjit_sys::gcc_jit_context_new_array_constructor(self.ptr, loc_ptr, types::get_ptr(&array_type), elements.len() as _, elements.as_ptr() as *mut *mut _); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| #[cfg(feature="master")] |
| pub fn new_vector_access<'a>(&'a self, loc: Option<Location<'a>>, vector: RValue<'a>, index: RValue<'a>) -> LValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| |
| let ptr = gccjit_sys::gcc_jit_context_new_vector_access(self.ptr, loc_ptr, rvalue::get_ptr(&vector), rvalue::get_ptr(&index)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| lvalue::from_ptr(ptr) |
| } |
| } |
| |
| #[cfg(feature="master")] |
| pub fn convert_vector<'a>(&'a self, loc: Option<Location<'a>>, vector: RValue<'a>, type_: Type<'a>) -> RValue<'a> { |
| unsafe { |
| let loc_ptr = match loc { |
| Some(loc) => location::get_ptr(&loc), |
| None => ptr::null_mut() |
| }; |
| let ptr = gccjit_sys::gcc_jit_context_convert_vector(self.ptr, loc_ptr, rvalue::get_ptr(&vector), types::get_ptr(&type_)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new RValue from a given int value. |
| pub fn new_rvalue_from_int<'a>(&'a self, |
| ty: types::Type<'a>, |
| value: i32) -> RValue<'a> { |
| |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_rvalue_from_int(self.ptr, |
| types::get_ptr(&ty), |
| value); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a new RValue from a given double value. |
| pub fn new_rvalue_from_double<'a>(&'a self, |
| ty: types::Type<'a>, |
| value: f64) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_rvalue_from_double(self.ptr, |
| types::get_ptr(&ty), |
| value); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a zero element for a given type. |
| pub fn new_rvalue_zero<'a>(&'a self, |
| ty: types::Type<'a>) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_zero(self.ptr, |
| types::get_ptr(&ty)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a one element for a given type. |
| pub fn new_rvalue_one<'a>(&'a self, |
| ty: types::Type<'a>) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_one(self.ptr, |
| types::get_ptr(&ty)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates an RValue for a raw pointer. This function |
| /// requires that the lifetime of the pointer be greater |
| /// than that of the jitted program. |
| #[allow(clippy::not_unsafe_ptr_arg_deref)] |
| pub fn new_rvalue_from_ptr<'a>(&'a self, |
| ty: types::Type<'a>, |
| value: *mut ()) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_rvalue_from_ptr(self.ptr, |
| types::get_ptr(&ty), |
| mem::transmute::<*mut (), *mut c_void>(value)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a null RValue. |
| pub fn new_null<'a>(&'a self, |
| ty: types::Type<'a>) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_null(self.ptr, |
| types::get_ptr(&ty)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Creates a string literal RValue. |
| pub fn new_string_literal<'a, S: AsRef<str>>(&'a self, |
| value: S) -> RValue<'a> { |
| unsafe { |
| let cstr = CString::new(value.as_ref()).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_string_literal(self.ptr, |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| #[cfg(feature="master")] |
| /// Creates a new RValue from a sizeof(type). |
| pub fn new_sizeof<'a>(&'a self, ty: types::Type<'a>) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_sizeof(self.ptr, types::get_ptr(&ty)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| #[cfg(feature="master")] |
| /// Creates a new RValue from a _Alignof(type). |
| pub fn new_alignof<'a>(&'a self, ty: types::Type<'a>) -> RValue<'a> { |
| unsafe { |
| let ptr = gccjit_sys::gcc_jit_context_new_alignof(self.ptr, types::get_ptr(&ty)); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| rvalue::from_ptr(ptr) |
| } |
| } |
| |
| /// Dumps a small C file to the path that can be used to reproduce a series |
| /// of API calls. You should only ever need to call this if you are debugging |
| /// an issue in gccjit itself or this library. |
| pub fn dump_reproducer_to_file<S: AsRef<str>>(&self, |
| path: S) { |
| unsafe { |
| let path_ref = path.as_ref(); |
| let cstr = CString::new(path_ref).unwrap(); |
| gccjit_sys::gcc_jit_context_dump_reproducer_to_file(self.ptr, |
| cstr.as_ptr()); |
| } |
| } |
| |
| pub fn dump_to_file<S: AsRef<str>>(&self, path: S, update_locations: bool) { |
| unsafe { |
| let path_ref = path.as_ref(); |
| let cstr = CString::new(path_ref).unwrap(); |
| gccjit_sys::gcc_jit_context_dump_to_file(self.ptr, cstr.as_ptr(), update_locations as c_int); |
| } |
| } |
| |
| /// Creates a new parameter with a given type, name, and location. |
| pub fn new_parameter<'a, S: AsRef<str>>(&'a self, |
| loc: Option<Location<'a>>, |
| ty: types::Type<'a>, |
| name: S) -> Parameter<'a> { |
| let name_ref = name.as_ref(); |
| let loc_ptr = match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut() |
| }; |
| unsafe { |
| let cstr = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_new_param(self.ptr, |
| loc_ptr, |
| types::get_ptr(&ty), |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| parameter::from_ptr(ptr) |
| } |
| } |
| |
| /// Get a builtin function from gcc. It's not clear what functions are |
| /// builtin and you'll likely need to consult the GCC internal docs |
| /// for a full list. |
| pub fn get_builtin_function<'a, S: AsRef<str>>(&'a self, name: S) -> Function<'a> { |
| let name_ref = name.as_ref(); |
| unsafe { |
| let cstr = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_get_builtin_function(self.ptr, |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| function::from_ptr(ptr) |
| } |
| } |
| |
| #[cfg(feature="master")] |
| /// Get a target-dependant builtin function from gcc. It's not clear what functions are |
| /// builtin and you'll likely need to consult the GCC internal docs |
| /// for a full list. |
| pub fn get_target_builtin_function<'a, S: AsRef<str>>(&'a self, name: S) -> Function<'a> { |
| let name_ref = name.as_ref(); |
| unsafe { |
| let cstr = CString::new(name_ref).unwrap(); |
| let ptr = gccjit_sys::gcc_jit_context_get_target_builtin_function(self.ptr, |
| cstr.as_ptr()); |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| function::from_ptr(ptr) |
| } |
| } |
| |
| pub fn get_first_error(&self) -> Result<Option<&'ctx str>, Utf8Error> { |
| unsafe { |
| let str = gccjit_sys::gcc_jit_context_get_first_error(self.ptr); |
| if str.is_null() { |
| Ok(None) |
| } |
| else { |
| Ok(Some(CStr::from_ptr(str).to_str()?)) |
| } |
| } |
| } |
| |
| pub fn get_last_error(&self) -> Result<Option<&'ctx str>, Utf8Error> { |
| unsafe { |
| let str = gccjit_sys::gcc_jit_context_get_last_error(self.ptr); |
| if str.is_null() { |
| Ok(None) |
| } |
| else { |
| Ok(Some(CStr::from_ptr(str).to_str()?)) |
| } |
| } |
| } |
| |
| // TODO: use the logfile argument. |
| pub fn set_logfile<S: AsRef<str>>(&self, _logfile: S) { |
| use std::os::raw::c_void; |
| |
| extern { |
| static stderr: *mut c_void; |
| } |
| |
| unsafe { |
| gccjit_sys::gcc_jit_context_set_logfile(self.ptr, stderr as *mut _, 0, 0); |
| } |
| } |
| |
| pub fn add_top_level_asm(&self, loc: Option<Location<'ctx>>, asm_stmts: &str) { |
| let asm_stmts = CString::new(asm_stmts).unwrap(); |
| let loc_ptr = |
| match loc { |
| Some(loc) => unsafe { location::get_ptr(&loc) }, |
| None => ptr::null_mut(), |
| }; |
| unsafe { |
| gccjit_sys::gcc_jit_context_add_top_level_asm(self.ptr, loc_ptr, asm_stmts.as_ptr()); |
| } |
| #[cfg(debug_assertions)] |
| if let Ok(Some(error)) = self.get_last_error() { |
| panic!("{}", error); |
| } |
| } |
| } |
| |
| impl<'ctx> Drop for Context<'ctx> { |
| fn drop(&mut self) { |
| unsafe { |
| gccjit_sys::gcc_jit_context_release(self.ptr); |
| } |
| } |
| } |
| |
| #[doc(hidden)] |
| pub unsafe fn get_ptr<'ctx>(ctx: &'ctx Context<'ctx>) -> *mut gccjit_sys::gcc_jit_context { |
| ctx.ptr |
| } |
| |
| pub unsafe fn from_ptr<'ctx>(ptr: *mut gccjit_sys::gcc_jit_context) -> Context<'ctx> { |
| Context { |
| marker: PhantomData, |
| ptr |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::super::*; |
| use std::mem; |
| |
| #[test] |
| fn create_context() { |
| let _ctx = Context::default(); |
| } |
| |
| #[test] |
| fn create_child_context() { |
| let ctx = Context::default(); |
| let _child = ctx.new_child_context(); |
| } |
| |
| #[test] |
| fn create_location() { |
| let ctx = Context::default(); |
| let _location = ctx.new_location("hello.rs", 1, 32); |
| } |
| |
| #[test] |
| fn create_type() { |
| let ctx = Context::default(); |
| let _int_type = ctx.new_type::<i32>(); |
| } |
| |
| #[test] |
| fn create_field() { |
| let ctx = Context::default(); |
| let int_type = ctx.new_type::<i32>(); |
| let _int_field = ctx.new_field(None, int_type, "x"); |
| } |
| |
| #[test] |
| fn basic_function() { |
| let context = Context::default(); |
| let int_ty = context.new_type::<i32>(); |
| let parameter = context.new_parameter(None, int_ty, "x"); |
| let fun = context.new_function(None, FunctionType::Exported, int_ty, &[parameter], "square", false); |
| let block = fun.new_block("main_block"); |
| let parm = fun.get_param(0).to_rvalue(); |
| let square = parm * parm; |
| block.end_with_return(None, square); |
| |
| let result = context.compile(); |
| unsafe { |
| let func_ptr = result.get_function("square"); |
| assert!(!func_ptr.is_null()); |
| let func : extern "C" fn(i32) -> i32 = mem::transmute(func_ptr); |
| assert_eq!(func(4), 16); |
| assert_eq!(func(9), 81); |
| assert_eq!(func(-2), 4); |
| } |
| } |
| |
| /* Uncomment these tests periodically to remind yourself of |
| * 1) why rust is awesome and 2) make sure that you've set up |
| * lifetimes correctly so that these invariant violations are |
| * caught at compile time. |
| #[test] |
| fn invalid_type_lifetime() { |
| panic!("this shouldn't compile!"); |
| let ty = { |
| let ctx = Context::default(); |
| ctx.new_type::<i32>() |
| }; |
| } |
| |
| #[test] |
| fn create_incorrect_child_context() { |
| let child = { |
| let mut ctx = Context::default(); |
| ctx.new_child_context() |
| }; |
| }*/ |
| } |
| |
| #[derive(Clone, Copy)] |
| pub enum CType { |
| Bool, |
| Char, |
| UChar, |
| SChar, |
| Short, |
| UShort, |
| Int, |
| UInt, |
| Long, |
| ULong, |
| LongLong, |
| ULongLong, |
| SizeT, |
| Int8t, |
| Int16t, |
| Int32t, |
| Int64t, |
| Int128t, |
| UInt8t, |
| UInt16t, |
| UInt32t, |
| UInt64t, |
| UInt128t, |
| ConstCharPtr, |
| BFloat16, |
| Float16, |
| Float32, |
| Float64, |
| Float128, |
| } |
| |
| impl CType { |
| pub(crate) fn to_sys(self) -> gccjit_sys::gcc_jit_types { |
| use gccjit_sys::gcc_jit_types::*; |
| use self::CType::*; |
| |
| match self { |
| Bool => GCC_JIT_TYPE_BOOL, |
| Char => GCC_JIT_TYPE_CHAR, |
| UChar => GCC_JIT_TYPE_UNSIGNED_CHAR, |
| SChar => GCC_JIT_TYPE_SIGNED_CHAR, |
| Short => GCC_JIT_TYPE_SHORT, |
| UShort => GCC_JIT_TYPE_UNSIGNED_SHORT, |
| Int => GCC_JIT_TYPE_INT, |
| UInt => GCC_JIT_TYPE_UNSIGNED_INT, |
| Long => GCC_JIT_TYPE_LONG, |
| ULong => GCC_JIT_TYPE_UNSIGNED_LONG, |
| LongLong => GCC_JIT_TYPE_LONG_LONG, |
| ULongLong => GCC_JIT_TYPE_UNSIGNED_LONG_LONG, |
| SizeT => GCC_JIT_TYPE_SIZE_T, |
| Int8t => GCC_JIT_TYPE_INT8_T, |
| Int16t => GCC_JIT_TYPE_INT16_T, |
| Int32t => GCC_JIT_TYPE_INT32_T, |
| Int64t => GCC_JIT_TYPE_INT64_T, |
| Int128t => GCC_JIT_TYPE_INT128_T, |
| UInt8t => GCC_JIT_TYPE_UINT8_T, |
| UInt16t => GCC_JIT_TYPE_UINT16_T, |
| UInt32t => GCC_JIT_TYPE_UINT32_T, |
| UInt64t => GCC_JIT_TYPE_UINT64_T, |
| UInt128t => GCC_JIT_TYPE_UINT128_T, |
| ConstCharPtr => GCC_JIT_TYPE_CONST_CHAR_PTR, |
| BFloat16 => GCC_JIT_TYPE_BFLOAT16, |
| Float16 => GCC_JIT_TYPE_FLOAT16, |
| Float32 => GCC_JIT_TYPE_FLOAT32, |
| Float64 => GCC_JIT_TYPE_FLOAT64, |
| Float128 => GCC_JIT_TYPE_FLOAT128, |
| } |
| } |
| } |
