| use gccjit::{Function, FunctionType, GlobalKind, LValue, RValue, Type}; |
| #[cfg(feature="master")] |
| use gccjit::{FnAttribute, ToRValue}; |
| use rustc_codegen_ssa::traits::BaseTypeMethods; |
| use rustc_middle::ty::Ty; |
| use rustc_span::Symbol; |
| use rustc_target::abi::call::FnAbi; |
| |
| use crate::abi::{FnAbiGcc, FnAbiGccExt}; |
| use crate::context::CodegenCx; |
| use crate::intrinsic::llvm; |
| |
| impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> { |
| pub fn get_or_insert_global(&self, name: &str, ty: Type<'gcc>, is_tls: bool, link_section: Option<Symbol>) -> LValue<'gcc> { |
| if self.globals.borrow().contains_key(name) { |
| let typ = self.globals.borrow()[name].get_type(); |
| let global = self.context.new_global(None, GlobalKind::Imported, typ, name); |
| if is_tls { |
| global.set_tls_model(self.tls_model); |
| } |
| if let Some(link_section) = link_section { |
| global.set_link_section(link_section.as_str()); |
| } |
| global |
| } |
| else { |
| self.declare_global(name, ty, GlobalKind::Exported, is_tls, link_section) |
| } |
| } |
| |
| pub fn declare_unnamed_global(&self, ty: Type<'gcc>) -> LValue<'gcc> { |
| let name = self.generate_local_symbol_name("global"); |
| self.context.new_global(None, GlobalKind::Internal, ty, &name) |
| } |
| |
| pub fn declare_global_with_linkage(&self, name: &str, ty: Type<'gcc>, linkage: GlobalKind) -> LValue<'gcc> { |
| let global = self.context.new_global(None, linkage, ty, name); |
| let global_address = global.get_address(None); |
| self.globals.borrow_mut().insert(name.to_string(), global_address); |
| global |
| } |
| |
| pub fn declare_func(&self, name: &str, return_type: Type<'gcc>, params: &[Type<'gcc>], variadic: bool) -> Function<'gcc> { |
| self.linkage.set(FunctionType::Extern); |
| declare_raw_fn(self, name, () /*llvm::CCallConv*/, return_type, params, variadic) |
| } |
| |
| pub fn declare_global(&self, name: &str, ty: Type<'gcc>, global_kind: GlobalKind, is_tls: bool, link_section: Option<Symbol>) -> LValue<'gcc> { |
| let global = self.context.new_global(None, global_kind, ty, name); |
| if is_tls { |
| global.set_tls_model(self.tls_model); |
| } |
| if let Some(link_section) = link_section { |
| global.set_link_section(link_section.as_str()); |
| } |
| let global_address = global.get_address(None); |
| self.globals.borrow_mut().insert(name.to_string(), global_address); |
| global |
| } |
| |
| pub fn declare_private_global(&self, name: &str, ty: Type<'gcc>) -> LValue<'gcc> { |
| let global = self.context.new_global(None, GlobalKind::Internal, ty, name); |
| let global_address = global.get_address(None); |
| self.globals.borrow_mut().insert(name.to_string(), global_address); |
| global |
| } |
| |
| pub fn declare_entry_fn(&self, name: &str, _fn_type: Type<'gcc>, callconv: () /*llvm::CCallConv*/) -> RValue<'gcc> { |
| // TODO(antoyo): use the fn_type parameter. |
| let const_string = self.context.new_type::<u8>().make_pointer().make_pointer(); |
| let return_type = self.type_i32(); |
| let variadic = false; |
| self.linkage.set(FunctionType::Exported); |
| let func = declare_raw_fn(self, name, callconv, return_type, &[self.type_i32(), const_string], variadic); |
| // NOTE: it is needed to set the current_func here as well, because get_fn() is not called |
| // for the main function. |
| *self.current_func.borrow_mut() = Some(func); |
| // FIXME(antoyo): this is a wrong cast. That requires changing the compiler API. |
| unsafe { std::mem::transmute(func) } |
| } |
| |
| pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Function<'gcc> { |
| let FnAbiGcc { |
| return_type, |
| arguments_type, |
| is_c_variadic, |
| on_stack_param_indices, |
| #[cfg(feature="master")] |
| fn_attributes, |
| } = fn_abi.gcc_type(self); |
| let func = declare_raw_fn(self, name, () /*fn_abi.llvm_cconv()*/, return_type, &arguments_type, is_c_variadic); |
| self.on_stack_function_params.borrow_mut().insert(func, on_stack_param_indices); |
| #[cfg(feature="master")] |
| for fn_attr in fn_attributes { |
| func.add_attribute(fn_attr); |
| } |
| func |
| } |
| |
| pub fn define_global(&self, name: &str, ty: Type<'gcc>, is_tls: bool, link_section: Option<Symbol>) -> LValue<'gcc> { |
| self.get_or_insert_global(name, ty, is_tls, link_section) |
| } |
| |
| pub fn get_declared_value(&self, name: &str) -> Option<RValue<'gcc>> { |
| // TODO(antoyo): use a different field than globals, because this seems to return a function? |
| self.globals.borrow().get(name).cloned() |
| } |
| } |
| |
| /// Declare a function. |
| /// |
| /// If there’s a value with the same name already declared, the function will |
| /// update the declaration and return existing Value instead. |
| fn declare_raw_fn<'gcc>(cx: &CodegenCx<'gcc, '_>, name: &str, _callconv: () /*llvm::CallConv*/, return_type: Type<'gcc>, param_types: &[Type<'gcc>], variadic: bool) -> Function<'gcc> { |
| if name.starts_with("llvm.") { |
| let intrinsic = llvm::intrinsic(name, cx); |
| cx.intrinsics.borrow_mut().insert(name.to_string(), intrinsic); |
| return intrinsic; |
| } |
| let func = |
| if cx.functions.borrow().contains_key(name) { |
| cx.functions.borrow()[name] |
| } |
| else { |
| let params: Vec<_> = param_types.into_iter().enumerate() |
| .map(|(index, param)| cx.context.new_parameter(None, *param, &format!("param{}", index))) // TODO(antoyo): set name. |
| .collect(); |
| let func = cx.context.new_function(None, cx.linkage.get(), return_type, ¶ms, mangle_name(name), variadic); |
| cx.functions.borrow_mut().insert(name.to_string(), func); |
| |
| #[cfg(feature="master")] |
| if name == "rust_eh_personality" { |
| // NOTE: GCC will sometimes change the personality function set on a function from |
| // rust_eh_personality to __gcc_personality_v0 as an optimization. |
| // As such, we need to create a weak alias from __gcc_personality_v0 to |
| // rust_eh_personality in order to avoid a linker error. |
| // This needs to be weak in order to still allow using the standard |
| // __gcc_personality_v0 when the linking to it. |
| // Since aliases don't work (maybe because of a bug in LTO partitioning?), we |
| // create a wrapper function that calls rust_eh_personality. |
| |
| let params: Vec<_> = param_types.into_iter().enumerate() |
| .map(|(index, param)| cx.context.new_parameter(None, *param, &format!("param{}", index))) // TODO(antoyo): set name. |
| .collect(); |
| let gcc_func = cx.context.new_function(None, FunctionType::Exported, return_type, ¶ms, "__gcc_personality_v0", variadic); |
| |
| // We need a normal extern function for the crates that access rust_eh_personality |
| // without defining it, otherwise we'll get a compiler error. |
| // |
| // For the crate defining it, that needs to be a weak alias instead. |
| gcc_func.add_attribute(FnAttribute::Weak); |
| |
| let block = gcc_func.new_block("start"); |
| let mut args = vec![]; |
| for param in ¶ms { |
| args.push(param.to_rvalue()); |
| } |
| let call = cx.context.new_call(None, func, &args); |
| if return_type == cx.type_void() { |
| block.add_eval(None, call); |
| block.end_with_void_return(None); |
| } |
| else { |
| block.end_with_return(None, call); |
| } |
| } |
| |
| func |
| }; |
| |
| // TODO(antoyo): set function calling convention. |
| // TODO(antoyo): set unnamed address. |
| // TODO(antoyo): set no red zone function attribute. |
| // TODO(antoyo): set attributes for optimisation. |
| // TODO(antoyo): set attributes for non lazy bind. |
| |
| // FIXME(antoyo): invalid cast. |
| func |
| } |
| |
| // FIXME(antoyo): this is a hack because libgccjit currently only supports alpha, num and _. |
| // Unsupported characters: `$` and `.`. |
| pub fn mangle_name(name: &str) -> String { |
| name.replace(|char: char| { |
| if !char.is_alphanumeric() && char != '_' { |
| debug_assert!("$.*".contains(char), "Unsupported char in function name {}: {}", name, char); |
| true |
| } |
| else { |
| false |
| } |
| }, "_") |
| } |
