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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
use crate::x86::assembler::*;
use crate::x86::operands::*;
use super::super::opcodes::*;
use crate::core::emitter::*;
use crate::core::operand::*;
/// A dummy operand that represents no register. Here just for simplicity.
const NOREG: Operand = Operand::new();
/// `TPAUSE` (TPAUSE).
/// TPAUSE instructs the processor to enter an implementation-dependent optimized state. There are two such optimized states to choose from: light-weight power/performance optimized state, and improved power/performance optimized state. The selection between the two is governed by the explicit input register bit[0] source operand.
///
///
/// For more details, see the [Intel manual](https://www.felixcloutier.com/x86/TPAUSE.html).
///
/// Supported operand variants:
///
/// ```text
/// +---+----------+
/// | # | Operands |
/// +---+----------+
/// | 1 | Gpd |
/// +---+----------+
/// ```
pub trait TpauseEmitter<A> {
fn tpause(&mut self, op0: A);
}
impl<'a> TpauseEmitter<Gpd> for Assembler<'a> {
fn tpause(&mut self, op0: Gpd) {
self.emit(TPAUSER, op0.as_operand(), &NOREG, &NOREG, &NOREG);
}
}
/// `UMONITOR` (UMONITOR).
/// The UMONITOR instruction arms address monitoring hardware using an address specified in the source register (the address range that the monitoring hardware checks for store operations can be determined by using the CPUID monitor leaf function, EAX=05H). A store to an address within the specified address range triggers the monitoring hardware. The state of monitor hardware is used by UMWAIT.
///
///
/// For more details, see the [Intel manual](https://www.felixcloutier.com/x86/UMONITOR.html).
///
/// Supported operand variants:
///
/// ```text
/// +---+----------+
/// | # | Operands |
/// +---+----------+
/// | 1 | Gpd |
/// | 2 | Gpq |
/// +---+----------+
/// ```
pub trait UmonitorEmitter<A> {
fn umonitor(&mut self, op0: A);
}
impl<'a> UmonitorEmitter<Gpd> for Assembler<'a> {
fn umonitor(&mut self, op0: Gpd) {
self.emit(UMONITOR32R, op0.as_operand(), &NOREG, &NOREG, &NOREG);
}
}
impl<'a> UmonitorEmitter<Gpq> for Assembler<'a> {
fn umonitor(&mut self, op0: Gpq) {
self.emit(UMONITOR64R, op0.as_operand(), &NOREG, &NOREG, &NOREG);
}
}
/// `UMWAIT` (UMWAIT).
/// UMWAIT instructs the processor to enter an implementation-dependent optimized state while monitoring a range of addresses. The optimized state may be either a light-weight power/performance optimized state or an improved power/performance optimized state. The selection between the two states is governed by the explicit input register bit[0] source operand.
///
///
/// For more details, see the [Intel manual](https://www.felixcloutier.com/x86/UMWAIT.html).
///
/// Supported operand variants:
///
/// ```text
/// +---+----------+
/// | # | Operands |
/// +---+----------+
/// | 1 | Gpd |
/// +---+----------+
/// ```
pub trait UmwaitEmitter<A> {
fn umwait(&mut self, op0: A);
}
impl<'a> UmwaitEmitter<Gpd> for Assembler<'a> {
fn umwait(&mut self, op0: Gpd) {
self.emit(UMWAITR, op0.as_operand(), &NOREG, &NOREG, &NOREG);
}
}
impl<'a> Assembler<'a> {
/// `TPAUSE` (TPAUSE).
/// TPAUSE instructs the processor to enter an implementation-dependent optimized state. There are two such optimized states to choose from: light-weight power/performance optimized state, and improved power/performance optimized state. The selection between the two is governed by the explicit input register bit[0] source operand.
///
///
/// For more details, see the [Intel manual](https://www.felixcloutier.com/x86/TPAUSE.html).
///
/// Supported operand variants:
///
/// ```text
/// +---+----------+
/// | # | Operands |
/// +---+----------+
/// | 1 | Gpd |
/// +---+----------+
/// ```
#[inline]
pub fn tpause<A>(&mut self, op0: A)
where Assembler<'a>: TpauseEmitter<A> {
<Self as TpauseEmitter<A>>::tpause(self, op0);
}
/// `UMONITOR` (UMONITOR).
/// The UMONITOR instruction arms address monitoring hardware using an address specified in the source register (the address range that the monitoring hardware checks for store operations can be determined by using the CPUID monitor leaf function, EAX=05H). A store to an address within the specified address range triggers the monitoring hardware. The state of monitor hardware is used by UMWAIT.
///
///
/// For more details, see the [Intel manual](https://www.felixcloutier.com/x86/UMONITOR.html).
///
/// Supported operand variants:
///
/// ```text
/// +---+----------+
/// | # | Operands |
/// +---+----------+
/// | 1 | Gpd |
/// | 2 | Gpq |
/// +---+----------+
/// ```
#[inline]
pub fn umonitor<A>(&mut self, op0: A)
where Assembler<'a>: UmonitorEmitter<A> {
<Self as UmonitorEmitter<A>>::umonitor(self, op0);
}
/// `UMWAIT` (UMWAIT).
/// UMWAIT instructs the processor to enter an implementation-dependent optimized state while monitoring a range of addresses. The optimized state may be either a light-weight power/performance optimized state or an improved power/performance optimized state. The selection between the two states is governed by the explicit input register bit[0] source operand.
///
///
/// For more details, see the [Intel manual](https://www.felixcloutier.com/x86/UMWAIT.html).
///
/// Supported operand variants:
///
/// ```text
/// +---+----------+
/// | # | Operands |
/// +---+----------+
/// | 1 | Gpd |
/// +---+----------+
/// ```
#[inline]
pub fn umwait<A>(&mut self, op0: A)
where Assembler<'a>: UmwaitEmitter<A> {
<Self as UmwaitEmitter<A>>::umwait(self, op0);
}
}