1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use llvm_sys::core::*;
use llvm_sys::{LLVMValue, LLVMValueKind};

use std::ptr::NonNull;

pub struct Value {
  pub(crate) llvm_ptr: NonNull<LLVMValue>,
}

impl Value {
  pub fn value_kind(&self) -> ValueKind {
    unsafe { ValueKind::from(LLVMGetValueKind(self.llvm_ptr.as_ptr())) }
  }

  pub fn is_constant(&self) -> bool {
    unsafe { LLVMIsConstant(self.llvm_ptr.as_ptr()) != 0 }
  }

  pub fn is_undefined(&self) -> bool {
    unsafe { LLVMIsUndef(self.llvm_ptr.as_ptr()) != 0 }
  }

  pub fn is_null(&self) -> bool {
    unsafe { LLVMIsNull(self.llvm_ptr.as_ptr()) != 0 }
  }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ValueKind {
  Argument,
  BasicBlock,
  MemoryUse,
  MemoryDef,
  MemoryPhi,
  Function,
  GlobalAlias,
  GlobalIFunc,
  GlobalVariable,
  BlockAddress,
  ConstantExpr,
  ConstantArray,
  ConstantStruct,
  ConstantVector,
  UndefValue,
  ConstantAggregateZero,
  ConstantDataArray,
  ConstantDataVector,
  ConstantInt,
  ConstantFP,
  ConstantPointerNull,
  ConstantTokenNone,
  MetadataAsValue,
  InlineAsm,
  Instruction,
}

impl From<LLVMValueKind> for ValueKind {
  fn from(value_kind: LLVMValueKind) -> ValueKind {
    match value_kind {
      LLVMValueKind::LLVMArgumentValueKind => ValueKind::Argument,
      LLVMValueKind::LLVMBasicBlockValueKind => ValueKind::BasicBlock,
      LLVMValueKind::LLVMMemoryUseValueKind => ValueKind::MemoryUse,
      LLVMValueKind::LLVMMemoryDefValueKind => ValueKind::MemoryDef,
      LLVMValueKind::LLVMMemoryPhiValueKind => ValueKind::MemoryPhi,
      LLVMValueKind::LLVMFunctionValueKind => ValueKind::Function,
      LLVMValueKind::LLVMGlobalAliasValueKind => ValueKind::GlobalAlias,
      LLVMValueKind::LLVMGlobalIFuncValueKind => ValueKind::GlobalIFunc,
      LLVMValueKind::LLVMGlobalVariableValueKind => ValueKind::GlobalVariable,
      LLVMValueKind::LLVMBlockAddressValueKind => ValueKind::BlockAddress,
      LLVMValueKind::LLVMConstantExprValueKind => ValueKind::ConstantExpr,
      LLVMValueKind::LLVMConstantArrayValueKind => ValueKind::ConstantArray,
      LLVMValueKind::LLVMConstantStructValueKind => ValueKind::ConstantStruct,
      LLVMValueKind::LLVMConstantVectorValueKind => ValueKind::ConstantVector,
      LLVMValueKind::LLVMUndefValueValueKind => ValueKind::UndefValue,
      LLVMValueKind::LLVMConstantAggregateZeroValueKind => ValueKind::ConstantAggregateZero,
      LLVMValueKind::LLVMConstantDataArrayValueKind => ValueKind::ConstantDataArray,
      LLVMValueKind::LLVMConstantDataVectorValueKind => ValueKind::ConstantDataVector,
      LLVMValueKind::LLVMConstantIntValueKind => ValueKind::ConstantInt,
      LLVMValueKind::LLVMConstantFPValueKind => ValueKind::ConstantFP,
      LLVMValueKind::LLVMConstantPointerNullValueKind => ValueKind::ConstantPointerNull,
      LLVMValueKind::LLVMConstantTokenNoneValueKind => ValueKind::ConstantTokenNone,
      LLVMValueKind::LLVMMetadataAsValueValueKind => ValueKind::MetadataAsValue,
      LLVMValueKind::LLVMInlineAsmValueKind => ValueKind::InlineAsm,
      LLVMValueKind::LLVMInstructionValueKind => ValueKind::Instruction,
    }
  }
}

impl From<ValueKind> for LLVMValueKind {
  fn from(value_kind: ValueKind) -> LLVMValueKind {
    match value_kind {
      ValueKind::Argument => LLVMValueKind::LLVMArgumentValueKind,
      ValueKind::BasicBlock => LLVMValueKind::LLVMBasicBlockValueKind,
      ValueKind::MemoryUse => LLVMValueKind::LLVMMemoryUseValueKind,
      ValueKind::MemoryDef => LLVMValueKind::LLVMMemoryDefValueKind,
      ValueKind::MemoryPhi => LLVMValueKind::LLVMMemoryPhiValueKind,
      ValueKind::Function => LLVMValueKind::LLVMFunctionValueKind,
      ValueKind::GlobalAlias => LLVMValueKind::LLVMGlobalAliasValueKind,
      ValueKind::GlobalIFunc => LLVMValueKind::LLVMGlobalIFuncValueKind,
      ValueKind::GlobalVariable => LLVMValueKind::LLVMGlobalVariableValueKind,
      ValueKind::BlockAddress => LLVMValueKind::LLVMBlockAddressValueKind,
      ValueKind::ConstantExpr => LLVMValueKind::LLVMConstantExprValueKind,
      ValueKind::ConstantArray => LLVMValueKind::LLVMConstantArrayValueKind,
      ValueKind::ConstantStruct => LLVMValueKind::LLVMConstantStructValueKind,
      ValueKind::ConstantVector => LLVMValueKind::LLVMConstantVectorValueKind,
      ValueKind::UndefValue => LLVMValueKind::LLVMUndefValueValueKind,
      ValueKind::ConstantAggregateZero => LLVMValueKind::LLVMConstantAggregateZeroValueKind,
      ValueKind::ConstantDataArray => LLVMValueKind::LLVMConstantDataArrayValueKind,
      ValueKind::ConstantDataVector => LLVMValueKind::LLVMConstantDataVectorValueKind,
      ValueKind::ConstantInt => LLVMValueKind::LLVMConstantIntValueKind,
      ValueKind::ConstantFP => LLVMValueKind::LLVMConstantFPValueKind,
      ValueKind::ConstantPointerNull => LLVMValueKind::LLVMConstantPointerNullValueKind,
      ValueKind::ConstantTokenNone => LLVMValueKind::LLVMConstantTokenNoneValueKind,
      ValueKind::MetadataAsValue => LLVMValueKind::LLVMMetadataAsValueValueKind,
      ValueKind::InlineAsm => LLVMValueKind::LLVMInlineAsmValueKind,
      ValueKind::Instruction => LLVMValueKind::LLVMInstructionValueKind,
    }
  }
}