661 lines
21 KiB
Rust
661 lines
21 KiB
Rust
//! Reid LLVM Lib is an ergonomic Rust'y API which is used to produce a
|
|
//! Low-Level IR (LLIR) using [`Context`] and [`Builder`]. This Builder can then
|
|
//! be used at the end to compile said LLIR into LLVM IR.
|
|
|
|
use std::{fmt::Debug, marker::PhantomData};
|
|
|
|
use builder::{BlockValue, Builder, FunctionValue, InstructionValue, ModuleValue, TypeValue};
|
|
use debug_information::{DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue};
|
|
use fmt::PrintableModule;
|
|
|
|
use crate::debug_information::DebugScopeValue;
|
|
|
|
pub mod builder;
|
|
pub mod compile;
|
|
pub mod debug_information;
|
|
mod fmt;
|
|
mod pad_adapter;
|
|
mod util;
|
|
|
|
#[derive(thiserror::Error, Debug, Clone, PartialEq, PartialOrd)]
|
|
pub enum ErrorKind {
|
|
#[error("NULL error, should never occur!")]
|
|
Null,
|
|
}
|
|
|
|
pub type CompileResult<T> = Result<T, ErrorKind>;
|
|
|
|
#[derive(Debug)]
|
|
pub struct Context {
|
|
builder: Builder,
|
|
}
|
|
|
|
impl Context {
|
|
pub fn new<T: Into<String>>(producer: T) -> Context {
|
|
Context {
|
|
builder: Builder::new(producer.into()),
|
|
}
|
|
}
|
|
|
|
pub fn module<'ctx>(&'ctx self, name: &str, main: bool) -> Module<'ctx> {
|
|
let value = self.builder.add_module(ModuleData {
|
|
name: name.to_owned(),
|
|
is_main: main,
|
|
});
|
|
Module {
|
|
phantom: PhantomData,
|
|
builder: self.builder.clone(),
|
|
value,
|
|
debug_info: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Hash)]
|
|
pub struct ModuleData {
|
|
name: String,
|
|
is_main: bool,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Module<'ctx> {
|
|
phantom: PhantomData<&'ctx ()>,
|
|
builder: Builder,
|
|
value: ModuleValue,
|
|
debug_info: Option<DebugInformation>,
|
|
}
|
|
|
|
impl<'ctx> Module<'ctx> {
|
|
pub fn function(&self, name: &str, ret: Type, params: Vec<Type>, flags: FunctionFlags) -> Function<'ctx> {
|
|
unsafe {
|
|
Function {
|
|
phantom: PhantomData,
|
|
builder: self.builder.clone(),
|
|
value: self.builder.add_function(
|
|
&self.value,
|
|
FunctionData {
|
|
name: name.to_owned(),
|
|
ret,
|
|
params,
|
|
flags,
|
|
},
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn custom_type(&self, ty: CustomTypeKind) -> TypeValue {
|
|
unsafe {
|
|
let (name, kind) = match &ty {
|
|
CustomTypeKind::NamedStruct(NamedStruct(name, _)) => (name.clone(), ty),
|
|
};
|
|
self.builder.add_type(&self.value, TypeData { name, kind })
|
|
}
|
|
}
|
|
|
|
pub fn value(&self) -> ModuleValue {
|
|
self.value
|
|
}
|
|
|
|
pub fn as_printable(&self) -> PrintableModule<'ctx> {
|
|
PrintableModule {
|
|
phantom: PhantomData,
|
|
module: self.builder.find_module(self.value),
|
|
}
|
|
}
|
|
|
|
pub fn create_debug_info(&mut self, file: DebugFileData) -> (DebugInformation, DebugScopeValue) {
|
|
let (debug_info, scope_value) = DebugInformation::from_file(file);
|
|
self.debug_info = Some(debug_info.clone());
|
|
(debug_info, scope_value)
|
|
}
|
|
|
|
pub fn get_debug_info(&self) -> &Option<DebugInformation> {
|
|
&self.debug_info
|
|
}
|
|
}
|
|
|
|
impl<'ctx> Drop for Module<'ctx> {
|
|
fn drop(&mut self) {
|
|
if let Some(debug_info) = self.debug_info.take() {
|
|
self.builder.set_debug_information(&self.value, debug_info);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Hash)]
|
|
pub struct FunctionData {
|
|
name: String,
|
|
ret: Type,
|
|
params: Vec<Type>,
|
|
flags: FunctionFlags,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Hash)]
|
|
pub struct FunctionFlags {
|
|
/// True in the destination module of the import, false in the source module.
|
|
pub is_extern: bool,
|
|
/// Whether this function is the main function of the module, that should be
|
|
/// executed (and linked externally also).
|
|
pub is_main: bool,
|
|
/// Whether this function should be available externally always.
|
|
pub is_pub: bool,
|
|
/// If this function is an imported function (either in the source or
|
|
/// destination module)
|
|
pub is_imported: bool,
|
|
/// Whether this function should add "alwaysinline"-attribute.
|
|
pub inline: bool,
|
|
}
|
|
|
|
impl Default for FunctionFlags {
|
|
fn default() -> FunctionFlags {
|
|
FunctionFlags {
|
|
is_extern: false,
|
|
is_main: false,
|
|
is_pub: false,
|
|
is_imported: false,
|
|
inline: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct Function<'ctx> {
|
|
phantom: PhantomData<&'ctx ()>,
|
|
builder: Builder,
|
|
value: FunctionValue,
|
|
}
|
|
|
|
impl<'ctx> Function<'ctx> {
|
|
pub fn block(&self, name: &str) -> Block<'ctx> {
|
|
unsafe {
|
|
Block {
|
|
phantom: PhantomData,
|
|
builder: self.builder.clone(),
|
|
value: self.builder.add_block(
|
|
&self.value,
|
|
BlockData {
|
|
name: name.to_owned(),
|
|
terminator: None,
|
|
terminator_location: None,
|
|
deleted: false,
|
|
},
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn set_debug(&self, subprogram: DebugScopeValue) {
|
|
unsafe {
|
|
self.builder.set_debug_subprogram(&self.value, subprogram);
|
|
}
|
|
}
|
|
|
|
pub fn value(&self) -> FunctionValue {
|
|
self.value
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Hash)]
|
|
pub struct BlockData {
|
|
name: String,
|
|
terminator: Option<TerminatorKind>,
|
|
terminator_location: Option<DebugLocationValue>,
|
|
deleted: bool,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Block<'builder> {
|
|
phantom: PhantomData<&'builder ()>,
|
|
builder: Builder,
|
|
value: BlockValue,
|
|
}
|
|
|
|
impl Instr {
|
|
pub fn default_name(&self) -> &str {
|
|
match self {
|
|
Instr::Param(_) => "param",
|
|
Instr::Constant(_) => "const1",
|
|
Instr::Add(..) => "add",
|
|
Instr::FAdd(..) => "fadd",
|
|
Instr::Sub(..) => "sub",
|
|
Instr::FSub(..) => "fsub",
|
|
Instr::Mul(..) => "mul",
|
|
Instr::FMul(..) => "fmul",
|
|
Instr::UDiv(..) => "udiv",
|
|
Instr::SDiv(..) => "sdiv",
|
|
Instr::FDiv(..) => "fdiv",
|
|
Instr::URem(..) => "urem",
|
|
Instr::SRem(..) => "srem",
|
|
Instr::FRem(..) => "frem",
|
|
Instr::And(..) => "and",
|
|
Instr::Phi(_) => "phi",
|
|
Instr::Alloca(_) => "alloca",
|
|
Instr::Load(_, _) => "load",
|
|
Instr::Store(..) => "store",
|
|
Instr::ArrayAlloca(_, _) => "arrayalloca",
|
|
Instr::GetElemPtr(..) => "getelemptr",
|
|
Instr::GetStructElemPtr(..) => "getstructelemptr",
|
|
Instr::ExtractValue(..) => "extractvalue",
|
|
Instr::ICmp(..) => "icmp",
|
|
Instr::FunctionCall(..) => "call",
|
|
Instr::FCmp(_, _, _) => "fcmp",
|
|
Instr::Trunc(_, _) => "trunc",
|
|
Instr::ZExt(_, _) => "zext",
|
|
Instr::SExt(_, _) => "sext",
|
|
Instr::FPTrunc(_, _) => "fptrunc",
|
|
Instr::FPExt(_, _) => "pfext",
|
|
Instr::FPToUI(_, _) => "fptoui",
|
|
Instr::FPToSI(_, _) => "fptosi",
|
|
Instr::UIToFP(_, _) => "uitofp",
|
|
Instr::SIToFP(_, _) => "sitofp",
|
|
Instr::PtrToInt(_, _) => "ptrtoint",
|
|
Instr::IntToPtr(_, _) => "inttoptr",
|
|
Instr::BitCast(_, _) => "bitcast",
|
|
Instr::Or(..) => "or",
|
|
Instr::XOr(..) => "xor",
|
|
Instr::ShiftRightLogical(..) => "lshr",
|
|
Instr::ShiftRightArithmetic(..) => "ashr",
|
|
Instr::ShiftLeft(..) => "shl",
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'builder> Block<'builder> {
|
|
pub fn build_named<T: Into<String>>(&mut self, name: T, instruction: Instr) -> CompileResult<InstructionValue> {
|
|
unsafe {
|
|
self.builder.add_instruction(
|
|
&self.value,
|
|
InstructionData {
|
|
kind: instruction,
|
|
location: None,
|
|
meta: None,
|
|
},
|
|
name.into(),
|
|
)
|
|
}
|
|
}
|
|
|
|
pub fn build(&mut self, instruction: Instr) -> CompileResult<InstructionValue> {
|
|
unsafe {
|
|
let name = instruction.default_name().to_owned();
|
|
self.builder.add_instruction(
|
|
&self.value,
|
|
InstructionData {
|
|
kind: instruction,
|
|
location: None,
|
|
meta: None,
|
|
},
|
|
name,
|
|
)
|
|
}
|
|
}
|
|
|
|
pub fn set_instr_location(&self, instruction: InstructionValue, location: DebugLocationValue) {
|
|
unsafe {
|
|
self.builder.add_instruction_location(&instruction, location);
|
|
}
|
|
}
|
|
|
|
pub fn set_instr_metadata(&self, instruction: InstructionValue, location: DebugMetadataValue) {
|
|
unsafe {
|
|
self.builder.add_instruction_metadata(&instruction, location);
|
|
}
|
|
}
|
|
|
|
pub fn terminate(&mut self, instruction: TerminatorKind) -> CompileResult<()> {
|
|
unsafe { self.builder.terminate(&self.value, instruction) }
|
|
}
|
|
|
|
pub fn set_terminator_location(&mut self, location: DebugLocationValue) -> CompileResult<()> {
|
|
unsafe { self.builder.set_terminator_location(&self.value, location) }
|
|
}
|
|
|
|
/// Delete block if it is unused. Return true if deleted, false if not.
|
|
pub fn delete_if_unused(&mut self) -> CompileResult<bool> {
|
|
unsafe {
|
|
if !self.builder.is_block_used(self.value()) {
|
|
self.builder.delete_block(&self.value)?;
|
|
Ok(true)
|
|
} else {
|
|
Ok(false)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn value(&self) -> BlockValue {
|
|
self.value
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct InstructionData {
|
|
kind: Instr,
|
|
location: Option<DebugLocationValue>,
|
|
meta: Option<DebugMetadataValue>,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Hash)]
|
|
pub enum CmpPredicate {
|
|
LT,
|
|
LE,
|
|
GT,
|
|
GE,
|
|
EQ,
|
|
NE,
|
|
}
|
|
|
|
/// https://llvm.org/docs/LangRef.html#instruction-reference
|
|
#[derive(Clone)]
|
|
pub enum Instr {
|
|
Param(usize),
|
|
Constant(ConstValue),
|
|
|
|
/// Add two integers
|
|
Add(InstructionValue, InstructionValue),
|
|
/// Add two floats
|
|
FAdd(InstructionValue, InstructionValue),
|
|
/// Subtract two integers
|
|
Sub(InstructionValue, InstructionValue),
|
|
/// Subtract two floats
|
|
FSub(InstructionValue, InstructionValue),
|
|
/// Multiply two integers
|
|
Mul(InstructionValue, InstructionValue),
|
|
/// Multiply two floats
|
|
FMul(InstructionValue, InstructionValue),
|
|
/// Divide two unsigned integers
|
|
UDiv(InstructionValue, InstructionValue),
|
|
/// Divide two signed integers
|
|
SDiv(InstructionValue, InstructionValue),
|
|
/// Divide two floats
|
|
FDiv(InstructionValue, InstructionValue),
|
|
/// Get the remainder from two unsigned integers
|
|
URem(InstructionValue, InstructionValue),
|
|
/// Get the remainder from two signed integers
|
|
SRem(InstructionValue, InstructionValue),
|
|
/// Get the remainder from two floats
|
|
FRem(InstructionValue, InstructionValue),
|
|
|
|
And(InstructionValue, InstructionValue),
|
|
Or(InstructionValue, InstructionValue),
|
|
XOr(InstructionValue, InstructionValue),
|
|
ShiftRightLogical(InstructionValue, InstructionValue),
|
|
ShiftRightArithmetic(InstructionValue, InstructionValue),
|
|
ShiftLeft(InstructionValue, InstructionValue),
|
|
|
|
Phi(Vec<InstructionValue>),
|
|
|
|
Alloca(Type),
|
|
Load(InstructionValue, Type),
|
|
Store(InstructionValue, InstructionValue),
|
|
ArrayAlloca(Type, InstructionValue),
|
|
GetElemPtr(InstructionValue, Vec<InstructionValue>),
|
|
GetStructElemPtr(InstructionValue, u32),
|
|
ExtractValue(InstructionValue, u32),
|
|
|
|
/// Integer Comparison
|
|
ICmp(CmpPredicate, InstructionValue, InstructionValue),
|
|
/// FLoat Comparison
|
|
FCmp(CmpPredicate, InstructionValue, InstructionValue),
|
|
|
|
/// The `trunc` instruction truncates the high order bits in value and
|
|
/// converts the remaining bits to ty2. Since the source size must be larger
|
|
/// than the destination size, `trunc` cannot be a no-op cast. It will
|
|
/// always truncate bits.
|
|
Trunc(InstructionValue, Type),
|
|
/// The `zext` fills the high order bits of the value with zero bits until
|
|
/// it reaches the size of the destination type, ty2.
|
|
ZExt(InstructionValue, Type),
|
|
/// The `sext` instruction performs a sign extension by copying the sign bit
|
|
/// (highest order bit) of the value until it reaches the bit size of the
|
|
/// type ty2.
|
|
SExt(InstructionValue, Type),
|
|
/// The `fptrunc` instruction casts a value from a larger floating-point
|
|
/// type to a smaller floating-point type.
|
|
FPTrunc(InstructionValue, Type),
|
|
/// The `fpext` instruction extends the value from a smaller floating-point
|
|
/// type to a larger floating-point type.
|
|
FPExt(InstructionValue, Type),
|
|
/// The `fptoui` instruction takes a value to cast, which must be a scalar
|
|
/// or vector floating-point value, and a type to cast it to ty2, which must
|
|
/// be an integer type.
|
|
FPToUI(InstructionValue, Type),
|
|
/// The `fptosi` instruction takes a value to cast, which must be a scalar
|
|
/// or vector floating-point value, and a type to cast it to ty2, which must
|
|
/// be an integer type.
|
|
FPToSI(InstructionValue, Type),
|
|
/// The `uitofp` instruction takes a value to cast, which must be a scalar
|
|
/// or vector integer value, and a type to cast it to ty2, which must be an
|
|
/// floating-point type.
|
|
UIToFP(InstructionValue, Type),
|
|
/// The `sitofp` instruction takes a value to cast, which must be a scalar
|
|
/// or vector integer value, and a type to cast it to ty2, which must be an
|
|
/// floating-point type
|
|
SIToFP(InstructionValue, Type),
|
|
/// The `ptrtoint` instruction converts value to integer type ty2 by
|
|
/// interpreting the all pointer representation bits as an integer
|
|
/// (equivalent to a bitcast) and either truncating or zero extending that
|
|
/// value to the size of the integer type.
|
|
PtrToInt(InstructionValue, Type),
|
|
/// The `inttoptr` instruction converts value to type ty2 by applying either
|
|
/// a zero extension or a truncation depending on the size of the integer
|
|
/// value.
|
|
IntToPtr(InstructionValue, Type),
|
|
/// The `bitcast` instruction converts value to type ty2. It is always a
|
|
/// no-op cast because no bits change with this conversion.
|
|
BitCast(InstructionValue, Type),
|
|
|
|
FunctionCall(FunctionValue, Vec<InstructionValue>),
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
|
|
pub enum Type {
|
|
I8,
|
|
I16,
|
|
I32,
|
|
I64,
|
|
I128,
|
|
U8,
|
|
U16,
|
|
U32,
|
|
U64,
|
|
U128,
|
|
F16,
|
|
F32B,
|
|
F32,
|
|
F64,
|
|
F80,
|
|
F128,
|
|
F128PPC,
|
|
Bool,
|
|
Void,
|
|
CustomType(TypeValue),
|
|
Array(Box<Type>, u64),
|
|
Ptr(Box<Type>),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum ConstValue {
|
|
I8(i8),
|
|
I16(i16),
|
|
I32(i32),
|
|
I64(i64),
|
|
I128(i128),
|
|
U8(u8),
|
|
U16(u16),
|
|
U32(u32),
|
|
U64(u64),
|
|
U128(u128),
|
|
Bool(bool),
|
|
Str(String),
|
|
F16(f32),
|
|
F32B(f32),
|
|
F32(f32),
|
|
F64(f64),
|
|
F80(f64),
|
|
F128(f64),
|
|
F128PPC(f64),
|
|
}
|
|
|
|
#[derive(Clone, Hash)]
|
|
pub enum TerminatorKind {
|
|
Ret(InstructionValue),
|
|
RetVoid,
|
|
Br(BlockValue),
|
|
CondBr(InstructionValue, BlockValue, BlockValue),
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
|
|
pub struct TypeData {
|
|
name: String,
|
|
kind: CustomTypeKind,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
|
|
pub enum CustomTypeKind {
|
|
NamedStruct(NamedStruct),
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
|
|
pub struct NamedStruct(pub String, pub Vec<Type>);
|
|
|
|
impl ConstValue {
|
|
pub fn get_type(&self) -> Type {
|
|
use Type::*;
|
|
match self {
|
|
ConstValue::I8(_) => I8,
|
|
ConstValue::I16(_) => I16,
|
|
ConstValue::I32(_) => I32,
|
|
ConstValue::I64(_) => I64,
|
|
ConstValue::I128(_) => I128,
|
|
ConstValue::U8(_) => U8,
|
|
ConstValue::U16(_) => U16,
|
|
ConstValue::U32(_) => U32,
|
|
ConstValue::U64(_) => U64,
|
|
ConstValue::U128(_) => U128,
|
|
ConstValue::Str(_) => Type::Ptr(Box::new(U8)),
|
|
ConstValue::Bool(_) => Bool,
|
|
ConstValue::F16(_) => F16,
|
|
ConstValue::F32B(_) => F32B,
|
|
ConstValue::F32(_) => F32,
|
|
ConstValue::F64(_) => F64,
|
|
ConstValue::F80(_) => F80,
|
|
ConstValue::F128(_) => F128,
|
|
ConstValue::F128PPC(_) => F128PPC,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
|
|
pub enum TypeCategory {
|
|
SignedInteger,
|
|
UnsignedInteger,
|
|
Void,
|
|
Real,
|
|
Ptr,
|
|
CustomType,
|
|
Array,
|
|
}
|
|
|
|
impl TypeCategory {
|
|
pub fn comparable(&self) -> bool {
|
|
match self {
|
|
TypeCategory::SignedInteger => true,
|
|
TypeCategory::UnsignedInteger => true,
|
|
TypeCategory::Real => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn signed(&self) -> bool {
|
|
match self {
|
|
TypeCategory::SignedInteger => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn integer(&self) -> bool {
|
|
match self {
|
|
TypeCategory::SignedInteger => true,
|
|
TypeCategory::UnsignedInteger => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Type {
|
|
pub fn category(&self) -> TypeCategory {
|
|
match self {
|
|
Type::I8 | Type::I16 | Type::I32 | Type::I64 | Type::I128 => TypeCategory::SignedInteger,
|
|
Type::U8 | Type::U16 | Type::U32 | Type::U64 | Type::U128 => TypeCategory::UnsignedInteger,
|
|
Type::F16 | Type::F32B | Type::F32 | Type::F64 | Type::F80 | Type::F128 | Type::F128PPC => {
|
|
TypeCategory::Real
|
|
}
|
|
Type::Bool => TypeCategory::UnsignedInteger,
|
|
Type::Void => TypeCategory::Void,
|
|
Type::CustomType(_) => TypeCategory::CustomType,
|
|
Type::Array(_, _) => TypeCategory::Array,
|
|
Type::Ptr(_) => TypeCategory::Ptr,
|
|
}
|
|
}
|
|
|
|
pub fn cast_instruction(&self, value: InstructionValue, other: &Type) -> Option<Instr> {
|
|
use Type::*;
|
|
match (self, other) {
|
|
(I8, I16 | I32 | I64 | I128) => Some(Instr::SExt(value, other.clone())),
|
|
(I16, I32 | I64 | I128) => Some(Instr::SExt(value, other.clone())),
|
|
(I32, I64 | I128) => Some(Instr::SExt(value, other.clone())),
|
|
(I64, I128) => Some(Instr::SExt(value, other.clone())),
|
|
(I128 | U128, I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
|
|
(I64 | U64, I32 | U32 | I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
|
|
(I32 | U32, I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
|
|
(I16 | U16, I8 | U8) => Some(Instr::Trunc(value, other.clone())),
|
|
(U8 | I8, U8 | I8 | U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => {
|
|
Some(Instr::ZExt(value, other.clone()))
|
|
}
|
|
(U16 | I16, U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
|
|
(U32 | I32, U32 | I32 | U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
|
|
(U64 | I64, U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
|
|
(U128 | I128, U128 | I128) => Some(Instr::ZExt(value, other.clone())),
|
|
(U8 | U16 | U32 | U64 | U128, F16 | F32 | F32B | F64 | F80 | F128 | F128PPC) => {
|
|
Some(Instr::UIToFP(value, other.clone()))
|
|
}
|
|
(I8 | I16 | I32 | I64 | I128, F16 | F32 | F32B | F64 | F80 | F128 | F128PPC) => {
|
|
Some(Instr::SIToFP(value, other.clone()))
|
|
}
|
|
(F16 | F32 | F32B | F64 | F80 | F128 | F128PPC, U8 | U16 | U32 | U64 | U128) => {
|
|
Some(Instr::FPToUI(value, other.clone()))
|
|
}
|
|
(F16 | F32 | F32B | F64 | F80 | F128 | F128PPC, I8 | I16 | I32 | I64 | I128) => {
|
|
Some(Instr::FPToSI(value, other.clone()))
|
|
}
|
|
(I128 | U128 | I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8, Ptr(_)) => {
|
|
Some(Instr::IntToPtr(value, other.clone()))
|
|
}
|
|
(Ptr(_), I128 | U128 | I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => {
|
|
Some(Instr::PtrToInt(value, other.clone()))
|
|
}
|
|
(F16, F32 | F32B | F64 | F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
|
|
(F32 | F32B, F64 | F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
|
|
(F64, F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
|
|
(F80, F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
|
|
(F128PPC | F128, F80 | F64 | F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
|
|
(F80, F64 | F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
|
|
(F64, F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
|
|
(F32B | F32, F16) => Some(Instr::FPTrunc(value, other.clone())),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TerminatorKind {
|
|
pub(crate) fn get_type(&self, builder: &Builder) -> CompileResult<Type> {
|
|
use TerminatorKind::*;
|
|
match self {
|
|
Ret(instr_val) => instr_val.get_type(builder),
|
|
RetVoid => Ok(Type::Void),
|
|
Br(_) => Ok(Type::Void),
|
|
CondBr(_, _, _) => Ok(Type::Void),
|
|
}
|
|
}
|
|
}
|