koopa 0.0.10

Library for generating/parsing/optimizing Koopa IR.
Documentation 
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

//! Value/basic block/function ID manager.

use std::num::NonZeroU32;
use std::sync::atomic::{AtomicU32, Ordering};

/// Type of `Value` identifier.
///
/// The IDs of `Value`s are unique, but two different IDs may correspond to
/// the same `Value`. For example, two integer constants are the same but
/// have different IDs.
pub(in crate::ir) type ValueId = NonZeroU32;

/// The value of `ValueId` (global value) should start from 1,
/// because we want to use `NonZeroU32` to enable some
/// memory layout optimization.
const GLOBAL_VALUE_ID_STARTS_FROM: ValueId = NonZeroU32::new(1).unwrap();

/// The value of `ValueId` (local value) should start from 0x40000000,
/// because we want to use `NonZeroU32` to enable some
/// memory layout optimization.
const LOCAL_VALUE_ID_STARTS_FROM: ValueId = NonZeroU32::new(0x40000000).unwrap();

/// Type of `BasicBlock` identifier.
///
/// The IDs of `BasicBlock`s are unique.
pub(in crate::ir) type BasicBlockId = NonZeroU32;

/// The value of `BasicBlockId` should start from 1,
/// because we want to use `NonZeroU32` to enable some
/// memory layout optimization.
const BB_ID_STARTS_FROM: BasicBlockId = NonZeroU32::new(1).unwrap();

/// Type of `Function` identifier.
///
/// The IDs of `Function`s are unique.
pub(in crate::ir) type FunctionId = NonZeroU32;

/// The value of `FunctionId` should start from 1,
/// because we want to use `NonZeroU32` to enable some
/// memory layout optimization.
const FUNC_ID_STARTS_FROM: FunctionId = NonZeroU32::new(1).unwrap();

/// Returns the next global value ID.
pub(in crate::ir) fn next_global_value_id() -> ValueId {
  static NEXT_GLOBAL_VALUE_ID: AtomicU32 = AtomicU32::new(GLOBAL_VALUE_ID_STARTS_FROM.get());
  let id = NEXT_GLOBAL_VALUE_ID.fetch_add(1, Ordering::Relaxed);
  unsafe { NonZeroU32::new_unchecked(id) }
}

/// Returns the next local value ID.
pub(in crate::ir) fn next_local_value_id() -> ValueId {
  static NEXT_LOCAL_VALUE_ID: AtomicU32 = AtomicU32::new(LOCAL_VALUE_ID_STARTS_FROM.get());
  let id = NEXT_LOCAL_VALUE_ID.fetch_add(1, Ordering::Relaxed);
  unsafe { NonZeroU32::new_unchecked(id) }
}

/// Returns `true` if the given value ID is a global value ID.
pub(in crate::ir) fn is_global_id(value: ValueId) -> bool {
  value >= GLOBAL_VALUE_ID_STARTS_FROM && value < LOCAL_VALUE_ID_STARTS_FROM
}

/// Returns the next basic block ID.
pub(in crate::ir) fn next_bb_id() -> BasicBlockId {
  static NEXT_BB_ID: AtomicU32 = AtomicU32::new(BB_ID_STARTS_FROM.get());
  let id = NEXT_BB_ID.fetch_add(1, Ordering::Relaxed);
  unsafe { NonZeroU32::new_unchecked(id) }
}

/// Returns the next function ID.
pub(in crate::ir) fn next_func_id() -> FunctionId {
  static NEXT_FUNC_ID: AtomicU32 = AtomicU32::new(FUNC_ID_STARTS_FROM.get());
  let id = NEXT_FUNC_ID.fetch_add(1, Ordering::Relaxed);
  unsafe { NonZeroU32::new_unchecked(id) }
}