pub use crate::llvm::Type;
+use crate::context::CodegenCx;
use crate::llvm;
use crate::llvm::{Bool, False, True};
-use crate::context::CodegenCx;
use crate::value::Value;
-use rustc_codegen_ssa::traits::*;
use rustc::bug;
+use rustc_codegen_ssa::traits::*;
+use crate::abi::{FnAbiLlvmExt, LlvmType};
use crate::common;
use crate::type_of::LayoutLlvmExt;
-use crate::abi::{LlvmType, FnAbiLlvmExt};
-use syntax::ast;
-use rustc::ty::Ty;
use rustc::ty::layout::{self, Align, Size, TyLayout};
-use rustc_target::abi::call::{CastTarget, FnAbi, Reg};
-use rustc_data_structures::small_c_str::SmallCStr;
+use rustc::ty::Ty;
+use rustc_ast::ast;
use rustc_codegen_ssa::common::TypeKind;
+use rustc_data_structures::small_c_str::SmallCStr;
+use rustc_target::abi::call::{CastTarget, FnAbi, Reg};
use std::fmt;
use std::ptr;
impl fmt::Debug for Type {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.write_str(&llvm::build_string(|s| unsafe {
- llvm::LLVMRustWriteTypeToString(self, s);
- }).expect("non-UTF8 type description from LLVM"))
+ f.write_str(
+ &llvm::build_string(|s| unsafe {
+ llvm::LLVMRustWriteTypeToString(self, s);
+ })
+ .expect("non-UTF8 type description from LLVM"),
+ )
}
}
impl CodegenCx<'ll, 'tcx> {
crate fn type_named_struct(&self, name: &str) -> &'ll Type {
let name = SmallCStr::new(name);
- unsafe {
- llvm::LLVMStructCreateNamed(self.llcx, name.as_ptr())
- }
+ unsafe { llvm::LLVMStructCreateNamed(self.llcx, name.as_ptr()) }
}
crate fn set_struct_body(&self, ty: &'ll Type, els: &[&'ll Type], packed: bool) {
- unsafe {
- llvm::LLVMStructSetBody(ty, els.as_ptr(),
- els.len() as c_uint, packed as Bool)
- }
+ unsafe { llvm::LLVMStructSetBody(ty, els.as_ptr(), els.len() as c_uint, packed as Bool) }
}
crate fn type_void(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMVoidTypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMVoidTypeInContext(self.llcx) }
}
crate fn type_metadata(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMRustMetadataTypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMRustMetadataTypeInContext(self.llcx) }
}
///x Creates an integer type with the given number of bits, e.g., i24
crate fn type_ix(&self, num_bits: u64) -> &'ll Type {
- unsafe {
- llvm::LLVMIntTypeInContext(self.llcx, num_bits as c_uint)
- }
+ unsafe { llvm::LLVMIntTypeInContext(self.llcx, num_bits as c_uint) }
}
crate fn type_x86_mmx(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMX86MMXTypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMX86MMXTypeInContext(self.llcx) }
}
crate fn type_vector(&self, ty: &'ll Type, len: u64) -> &'ll Type {
- unsafe {
- llvm::LLVMVectorType(ty, len as c_uint)
- }
+ unsafe { llvm::LLVMVectorType(ty, len as c_uint) }
}
crate fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {
self.type_array(self.type_from_integer(unit), size / unit_size)
}
- crate fn type_variadic_func(
- &self,
- args: &[&'ll Type],
- ret: &'ll Type
- ) -> &'ll Type {
- unsafe {
- llvm::LLVMFunctionType(ret, args.as_ptr(),
- args.len() as c_uint, True)
- }
+ crate fn type_variadic_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'ll Type {
+ unsafe { llvm::LLVMFunctionType(ret, args.as_ptr(), args.len() as c_uint, True) }
}
crate fn type_array(&self, ty: &'ll Type, len: u64) -> &'ll Type {
- unsafe {
- llvm::LLVMRustArrayType(ty, len)
- }
+ unsafe { llvm::LLVMRustArrayType(ty, len) }
}
}
impl BaseTypeMethods<'tcx> for CodegenCx<'ll, 'tcx> {
fn type_i1(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMInt1TypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMInt1TypeInContext(self.llcx) }
}
fn type_i8(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMInt8TypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMInt8TypeInContext(self.llcx) }
}
-
fn type_i16(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMInt16TypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMInt16TypeInContext(self.llcx) }
}
fn type_i32(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMInt32TypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMInt32TypeInContext(self.llcx) }
}
fn type_i64(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMInt64TypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMInt64TypeInContext(self.llcx) }
}
fn type_i128(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMIntTypeInContext(self.llcx, 128)
- }
+ unsafe { llvm::LLVMIntTypeInContext(self.llcx, 128) }
}
fn type_isize(&self) -> &'ll Type {
}
fn type_f32(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMFloatTypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMFloatTypeInContext(self.llcx) }
}
fn type_f64(&self) -> &'ll Type {
- unsafe {
- llvm::LLVMDoubleTypeInContext(self.llcx)
- }
+ unsafe { llvm::LLVMDoubleTypeInContext(self.llcx) }
}
- fn type_func(
- &self,
- args: &[&'ll Type],
- ret: &'ll Type
- ) -> &'ll Type {
- unsafe {
- llvm::LLVMFunctionType(ret, args.as_ptr(),
- args.len() as c_uint, False)
- }
+ fn type_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'ll Type {
+ unsafe { llvm::LLVMFunctionType(ret, args.as_ptr(), args.len() as c_uint, False) }
}
- fn type_struct(
- &self,
- els: &[&'ll Type],
- packed: bool
- ) -> &'ll Type {
+ fn type_struct(&self, els: &[&'ll Type], packed: bool) -> &'ll Type {
unsafe {
- llvm::LLVMStructTypeInContext(self.llcx, els.as_ptr(),
- els.len() as c_uint,
- packed as Bool)
+ llvm::LLVMStructTypeInContext(
+ self.llcx,
+ els.as_ptr(),
+ els.len() as c_uint,
+ packed as Bool,
+ )
}
}
fn type_kind(&self, ty: &'ll Type) -> TypeKind {
- unsafe {
- llvm::LLVMRustGetTypeKind(ty).to_generic()
- }
+ unsafe { llvm::LLVMRustGetTypeKind(ty).to_generic() }
}
fn type_ptr_to(&self, ty: &'ll Type) -> &'ll Type {
- assert_ne!(self.type_kind(ty), TypeKind::Function,
- "don't call ptr_to on function types, use ptr_to_llvm_type on FnAbi instead");
+ assert_ne!(
+ self.type_kind(ty),
+ TypeKind::Function,
+ "don't call ptr_to on function types, use ptr_to_llvm_type on FnAbi instead"
+ );
ty.ptr_to()
}
fn element_type(&self, ty: &'ll Type) -> &'ll Type {
- unsafe {
- llvm::LLVMGetElementType(ty)
- }
+ unsafe { llvm::LLVMGetElementType(ty) }
}
fn vector_length(&self, ty: &'ll Type) -> usize {
- unsafe {
- llvm::LLVMGetVectorSize(ty) as usize
- }
+ unsafe { llvm::LLVMGetVectorSize(ty) as usize }
}
fn float_width(&self, ty: &'ll Type) -> usize {
TypeKind::Double => 64,
TypeKind::X86_FP80 => 80,
TypeKind::FP128 | TypeKind::PPC_FP128 => 128,
- _ => bug!("llvm_float_width called on a non-float type")
+ _ => bug!("llvm_float_width called on a non-float type"),
}
}
fn int_width(&self, ty: &'ll Type) -> u64 {
- unsafe {
- llvm::LLVMGetIntTypeWidth(ty) as u64
- }
+ unsafe { llvm::LLVMGetIntTypeWidth(ty) as u64 }
}
fn val_ty(&self, v: &'ll Value) -> &'ll Type {
impl Type {
pub fn i8_llcx(llcx: &llvm::Context) -> &Type {
- unsafe {
- llvm::LLVMInt8TypeInContext(llcx)
- }
+ unsafe { llvm::LLVMInt8TypeInContext(llcx) }
}
// Creates an integer type with the given number of bits, e.g., i24
- pub fn ix_llcx(
- llcx: &llvm::Context,
- num_bits: u64
- ) -> &Type {
- unsafe {
- llvm::LLVMIntTypeInContext(llcx, num_bits as c_uint)
- }
+ pub fn ix_llcx(llcx: &llvm::Context, num_bits: u64) -> &Type {
+ unsafe { llvm::LLVMIntTypeInContext(llcx, num_bits as c_uint) }
}
pub fn i8p_llcx(llcx: &'ll llvm::Context) -> &'ll Type {
}
fn ptr_to(&self) -> &Type {
- unsafe {
- llvm::LLVMPointerType(&self, 0)
- }
+ unsafe { llvm::LLVMPointerType(&self, 0) }
}
}
-
impl LayoutTypeMethods<'tcx> for CodegenCx<'ll, 'tcx> {
fn backend_type(&self, layout: TyLayout<'tcx>) -> &'ll Type {
layout.llvm_type(self)
&self,
layout: TyLayout<'tcx>,
index: usize,
- immediate: bool
+ immediate: bool,
) -> &'ll Type {
layout.scalar_pair_element_llvm_type(self, index, immediate)
}
projects / rust.git / blobdiff