Skip to content

Commit 12dc481

Browse files
fw-immunantfw-immunant
committed
update atomic intrinsic usage for newer rustc
1 parent df32e6c commit 12dc481

File tree

2 files changed

+44
-79
lines changed

2 files changed

+44
-79
lines changed

‎c2rust-transpile/src/translator/atomics.rs

Lines changed: 36 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -68,35 +68,32 @@ impl<'c> Translation<'c> {
6868
.transpose()?;
6969
let weak = weak_id.and_then(|x| self.convert_constant_bool(x));
7070

71-
fn static_order<T>(order: Option<T>) -> T {
71+
fn static_order(order: Option<Ordering>) -> Ordering {
7272
order.unwrap_or_else(|| {
7373
// We have to select which intrinsic to use at runtime
7474
unimplemented!("Dynamic memory consistency arguments are not yet supported");
7575
})
7676
}
7777

78+
fn order_name(order: Ordering) -> &'static str {
79+
use Ordering::*;
80+
match order {
81+
SeqCst => "seqcst",
82+
AcqRel => "acqrel",
83+
Acquire => "acquire",
84+
Release => "release",
85+
Relaxed => "relaxed",
86+
_ => unreachable!("Did we not handle a case above??"),
87+
}
88+
}
89+
7890
match name {
7991
"__atomic_load" | "__atomic_load_n" => ptr.and_then(|ptr| {
80-
use Ordering::*;
81-
let intrinsic_name = match static_order(order) {
82-
SeqCst => Some("atomic_load"),
83-
AcqRel => None,
84-
Acquire => Some("atomic_load_acq"),
85-
Release => None,
86-
Relaxed => Some("atomic_load_relaxed"),
87-
_ => unreachable!("Did we not handle a case above??"),
88-
}
89-
.ok_or_else(|| {
90-
format_translation_err!(
91-
self.ast_context
92-
.display_loc(&self.ast_context[order_id].loc),
93-
"Invalid memory ordering for __atomic_load",
94-
)
95-
})?;
92+
let intrinsic_name = "atomic_load_".to_owned() + order_name(static_order(order));
9693

9794
self.use_feature("core_intrinsics");
9895

99-
let atomic_load = mk().abs_path_expr(vec!["core", "intrinsics", intrinsic_name]);
96+
let atomic_load = mk().abs_path_expr(vec!["core", "intrinsics", &intrinsic_name]);
10097
let call = mk().call_expr(atomic_load, vec![ptr]);
10198
if name == "__atomic_load" {
10299
let ret = val1.expect("__atomic_load should have a ret argument");
@@ -124,27 +121,13 @@ impl<'c> Translation<'c> {
124121
let val = val1.expect("__atomic_store must have a val argument");
125122
ptr.and_then(|ptr| {
126123
val.and_then(|val| {
127-
use Ordering::*;
128-
let intrinsic_name = match static_order(order) {
129-
SeqCst => Some("atomic_store"),
130-
AcqRel => None,
131-
Acquire => None,
132-
Release => Some("atomic_store_rel"),
133-
Relaxed => Some("atomic_store_relaxed"),
134-
_ => unreachable!("Did we not handle a case above??"),
135-
}
136-
.ok_or_else(|| {
137-
format_translation_err!(
138-
self.ast_context
139-
.display_loc(&self.ast_context[order_id].loc),
140-
"Invalid memory ordering for __atomic_store",
141-
)
142-
})?;
124+
let intrinsic_name =
125+
"atomic_store_".to_owned() + order_name(static_order(order));
143126

144127
self.use_feature("core_intrinsics");
145128

146129
let atomic_store =
147-
mk().abs_path_expr(vec!["core", "intrinsics", intrinsic_name]);
130+
mk().abs_path_expr(vec!["core", "intrinsics", &intrinsic_name]);
148131
let val = if name == "__atomic_store" {
149132
mk().unary_expr(UnOp::Deref(Default::default()), val)
150133
} else {
@@ -164,27 +147,13 @@ impl<'c> Translation<'c> {
164147
let val = val1.expect("__atomic_store must have a val argument");
165148
ptr.and_then(|ptr| {
166149
val.and_then(|val| {
167-
use Ordering::*;
168-
let intrinsic_name = match static_order(order) {
169-
SeqCst => Some("atomic_xchg"),
170-
AcqRel => Some("atomic_xchg_acqrel"),
171-
Acquire => Some("atomic_xchg_acq"),
172-
Release => Some("atomic_xchg_rel"),
173-
Relaxed => Some("atomic_xchg_relaxed"),
174-
_ => unreachable!("Did we not handle a case above??"),
175-
}
176-
.ok_or_else(|| {
177-
format_translation_err!(
178-
self.ast_context
179-
.display_loc(&self.ast_context[order_id].loc),
180-
"Invalid memory ordering for __atomic_exchange",
181-
)
182-
})?;
150+
let intrinsic_name =
151+
"atomic_xchg_".to_owned() + order_name(static_order(order));
183152

184153
self.use_feature("core_intrinsics");
185154

186155
let fn_path =
187-
mk().abs_path_expr(vec!["core", "intrinsics", intrinsic_name]);
156+
mk().abs_path_expr(vec!["core", "intrinsics", &intrinsic_name]);
188157
let val = if name == "__atomic_exchange" {
189158
mk().unary_expr(UnOp::Deref(Default::default()), val)
190159
} else {
@@ -226,22 +195,25 @@ impl<'c> Translation<'c> {
226195
ptr.and_then(|ptr| {
227196
expected.and_then(|expected| {
228197
desired.and_then(|desired| {
229-
let weak = static_order(weak);
198+
// If this expect fails, we have to select which intrinsic to use at runtime
199+
let weak = weak.expect(
200+
"Dynamic memory consistency arguments are not yet supported",
201+
);
230202
let order = static_order(order);
231203
let order_fail = static_order(order_fail);
232204
use Ordering::*;
233205
let intrinsic_name = (|| {
234206
Some(match (order, order_fail) {
235207
(_, Release | AcqRel) => return None,
236-
(SeqCst, SeqCst) => "",
237-
(SeqCst, Acquire) => "_failacq",
238-
(SeqCst, Relaxed) => "_failrelaxed",
239-
(AcqRel, Acquire) => "_acqrel",
240-
(AcqRel, Relaxed) => "_acqrel_failrelaxed",
241-
(Release, Relaxed) => "_rel",
242-
(Acquire, Acquire) => "_acq",
243-
(Acquire, Relaxed) => "_acq_failrelaxed",
244-
(Relaxed, Relaxed) => "_relaxed",
208+
(SeqCst, SeqCst) => "_seqcst_seqcst",
209+
(SeqCst, Acquire) => "_seqcst_acquire",
210+
(SeqCst, Relaxed) => "_seqcst_relaxed",
211+
(AcqRel, Acquire) => "_acqrel_acquire",
212+
(AcqRel, Relaxed) => "_acqrel_relaxed",
213+
(Release, Relaxed) => "_release_relaxed",
214+
(Acquire, Acquire) => "_acquire_acquire",
215+
(Acquire, Relaxed) => "_acquire_relaxed",
216+
(Relaxed, Relaxed) => "_relaxed_relaxed",
245217
(SeqCst | AcqRel | Release | Acquire | Relaxed, _) => {
246218
return None
247219
}
@@ -320,16 +292,8 @@ impl<'c> Translation<'c> {
320292
"atomic_and"
321293
};
322294

323-
use Ordering::*;
324-
let intrinsic_suffix = match static_order(order) {
325-
SeqCst => "",
326-
AcqRel => "_acqrel",
327-
Acquire => "_acq",
328-
Release => "_rel",
329-
Relaxed => "_relaxed",
330-
_ => unreachable!("Unknown memory ordering"),
331-
};
332-
let intrinsic_name = format!("{intrinsic_name}{intrinsic_suffix}");
295+
let intrinsic_suffix = order_name(static_order(order));
296+
let intrinsic_name = format!("{intrinsic_name}_{intrinsic_suffix}");
333297

334298
let fetch_first = name.starts_with("__atomic_fetch");
335299
let val = val1.expect("__atomic arithmetic operations must have a val argument");

‎c2rust-transpile/src/translator/builtins.rs

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -493,18 +493,18 @@ impl<'c> Translation<'c> {
493493
| "__sync_nand_and_fetch_8"
494494
| "__sync_nand_and_fetch_16" => {
495495
let func_name = if builtin_name.contains("_add_") {
496-
"atomic_xadd"
496+
"atomic_xadd_seqcst"
497497
} else if builtin_name.contains("_sub_") {
498-
"atomic_xsub"
498+
"atomic_xsub_seqcst"
499499
} else if builtin_name.contains("_or_") {
500-
"atomic_or"
500+
"atomic_or_seqcst"
501501
} else if builtin_name.contains("_xor_") {
502-
"atomic_xor"
502+
"atomic_xor_seqcst"
503503
} else if builtin_name.contains("_nand_") {
504-
"atomic_nand"
504+
"atomic_nand_seqcst"
505505
} else {
506506
// We can't explicitly check for "_and_" since they all contain it
507-
"atomic_and"
507+
"atomic_and_seqcst"
508508
};
509509

510510
let arg0 = self.convert_expr(ctx.used(), args[0])?;
@@ -520,7 +520,8 @@ impl<'c> Translation<'c> {
520520
"__sync_synchronize" => {
521521
self.use_feature("core_intrinsics");
522522

523-
let atomic_func = mk().abs_path_expr(vec!["core", "intrinsics", "atomic_fence"]);
523+
let atomic_func =
524+
mk().abs_path_expr(vec!["core", "intrinsics", "atomic_fence_seqcst"]);
524525
let call_expr = mk().call_expr(atomic_func, vec![]);
525526
self.convert_side_effects_expr(
526527
ctx,

0 commit comments

Comments
 (0)