Skip to content

Commit 96a7267

Browse files
erikdesjardinserikdesjardins
committed
use [N x i8] for byval/sret types
This avoids depending on LLVM's struct types to determine the size of the byval/sret slot.
1 parent 3c02972 commit 96a7267

File tree

10 files changed

+80
-73
lines changed

10 files changed

+80
-73
lines changed

‎compiler/rustc_codegen_llvm/src/abi.rs‎

Lines changed: 16 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -424,7 +424,10 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
424424
PassMode::Indirect { attrs, meta_attrs: _, on_stack } => {
425425
assert!(!on_stack);
426426
let i = apply(attrs);
427-
let sret = llvm::CreateStructRetAttr(cx.llcx, self.ret.layout.llvm_type(cx));
427+
let sret = llvm::CreateStructRetAttr(
428+
cx.llcx,
429+
cx.type_array(cx.type_i8(), self.ret.layout.size.bytes()),
430+
);
428431
attributes::apply_to_llfn(llfn, llvm::AttributePlace::Argument(i), &[sret]);
429432
}
430433
PassMode::Cast { cast, pad_i32: _ } => {
@@ -437,7 +440,10 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
437440
PassMode::Ignore => {}
438441
PassMode::Indirect { attrs, meta_attrs: None, on_stack: true } => {
439442
let i = apply(attrs);
440-
let byval = llvm::CreateByValAttr(cx.llcx, arg.layout.llvm_type(cx));
443+
let byval = llvm::CreateByValAttr(
444+
cx.llcx,
445+
cx.type_array(cx.type_i8(), arg.layout.size.bytes()),
446+
);
441447
attributes::apply_to_llfn(llfn, llvm::AttributePlace::Argument(i), &[byval]);
442448
}
443449
PassMode::Direct(attrs)
@@ -486,7 +492,10 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
486492
PassMode::Indirect { attrs, meta_attrs: _, on_stack } => {
487493
assert!(!on_stack);
488494
let i = apply(bx.cx, attrs);
489-
let sret = llvm::CreateStructRetAttr(bx.cx.llcx, self.ret.layout.llvm_type(bx));
495+
let sret = llvm::CreateStructRetAttr(
496+
bx.cx.llcx,
497+
bx.cx.type_array(bx.cx.type_i8(), self.ret.layout.size.bytes()),
498+
);
490499
attributes::apply_to_callsite(callsite, llvm::AttributePlace::Argument(i), &[sret]);
491500
}
492501
PassMode::Cast { cast, pad_i32: _ } => {
@@ -513,7 +522,10 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
513522
PassMode::Ignore => {}
514523
PassMode::Indirect { attrs, meta_attrs: None, on_stack: true } => {
515524
let i = apply(bx.cx, attrs);
516-
let byval = llvm::CreateByValAttr(bx.cx.llcx, arg.layout.llvm_type(bx));
525+
let byval = llvm::CreateByValAttr(
526+
bx.cx.llcx,
527+
bx.cx.type_array(bx.cx.type_i8(), arg.layout.size.bytes()),
528+
);
517529
attributes::apply_to_callsite(
518530
callsite,
519531
llvm::AttributePlace::Argument(i),

‎tests/codegen/align-byval-vector.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -37,12 +37,12 @@ pub struct DoubleFoo {
3737
}
3838

3939
extern "C" {
40-
// x86-linux: declare void @f({{.*}}byval(%Foo) align 4{{.*}})
41-
// x86-darwin: declare void @f({{.*}}byval(%Foo) align 16{{.*}})
40+
// x86-linux: declare void @f({{.*}}byval([32 x i8]) align 4{{.*}})
41+
// x86-darwin: declare void @f({{.*}}byval([32 x i8]) align 16{{.*}})
4242
fn f(foo: Foo);
4343

44-
// x86-linux: declare void @g({{.*}}byval(%DoubleFoo) align 4{{.*}})
45-
// x86-darwin: declare void @g({{.*}}byval(%DoubleFoo) align 16{{.*}})
44+
// x86-linux: declare void @g({{.*}}byval([64 x i8]) align 4{{.*}})
45+
// x86-darwin: declare void @g({{.*}}byval([64 x i8]) align 16{{.*}})
4646
fn g(foo: DoubleFoo);
4747
}
4848

‎tests/codegen/align-byval.rs‎

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -107,20 +107,20 @@ pub unsafe fn call_na1(x: NaturalAlign1) {
107107
// CHECK: start:
108108

109109
// m68k: [[ALLOCA:%[a-z0-9+]]] = alloca %NaturalAlign1, align 1
110-
// m68k: call void @natural_align_1({{.*}}byval(%NaturalAlign1) align 1{{.*}} [[ALLOCA]])
110+
// m68k: call void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}} [[ALLOCA]])
111111

112112
// wasm: [[ALLOCA:%[a-z0-9+]]] = alloca %NaturalAlign1, align 1
113-
// wasm: call void @natural_align_1({{.*}}byval(%NaturalAlign1) align 1{{.*}} [[ALLOCA]])
113+
// wasm: call void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}} [[ALLOCA]])
114114

115115
// x86_64-linux: call void @natural_align_1(i16
116116

117117
// x86_64-windows: call void @natural_align_1(i16
118118

119119
// i686-linux: [[ALLOCA:%[a-z0-9+]]] = alloca %NaturalAlign1, align 4
120-
// i686-linux: call void @natural_align_1({{.*}}byval(%NaturalAlign1) align 4{{.*}} [[ALLOCA]])
120+
// i686-linux: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
121121

122122
// i686-windows: [[ALLOCA:%[a-z0-9+]]] = alloca %NaturalAlign1, align 4
123-
// i686-windows: call void @natural_align_1({{.*}}byval(%NaturalAlign1) align 4{{.*}} [[ALLOCA]])
123+
// i686-windows: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
124124
natural_align_1(x);
125125
}
126126

@@ -135,10 +135,10 @@ pub unsafe fn call_na2(x: NaturalAlign2) {
135135
// x86_64-windows-NEXT: call void @natural_align_2
136136

137137
// i686-linux: [[ALLOCA:%[0-9]+]] = alloca %NaturalAlign2, align 4
138-
// i686-linux: call void @natural_align_2({{.*}}byval(%NaturalAlign2) align 4{{.*}} [[ALLOCA]])
138+
// i686-linux: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
139139

140140
// i686-windows: [[ALLOCA:%[0-9]+]] = alloca %NaturalAlign2, align 4
141-
// i686-windows: call void @natural_align_2({{.*}}byval(%NaturalAlign2) align 4{{.*}} [[ALLOCA]])
141+
// i686-windows: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
142142
natural_align_2(x);
143143
}
144144

@@ -199,141 +199,141 @@ pub unsafe fn call_fa16(x: ForceAlign16) {
199199
}
200200

201201
extern "C" {
202-
// m68k: declare void @natural_align_1({{.*}}byval(%NaturalAlign1) align 1{{.*}})
202+
// m68k: declare void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}})
203203

204-
// wasm: declare void @natural_align_1({{.*}}byval(%NaturalAlign1) align 1{{.*}})
204+
// wasm: declare void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}})
205205

206206
// x86_64-linux: declare void @natural_align_1(i16)
207207

208208
// x86_64-windows: declare void @natural_align_1(i16)
209209

210-
// i686-linux: declare void @natural_align_1({{.*}}byval(%NaturalAlign1) align 4{{.*}})
210+
// i686-linux: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
211211

212-
// i686-windows: declare void @natural_align_1({{.*}}byval(%NaturalAlign1) align 4{{.*}})
212+
// i686-windows: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
213213
fn natural_align_1(x: NaturalAlign1);
214214

215-
// m68k: declare void @natural_align_2({{.*}}byval(%NaturalAlign2) align 2{{.*}})
215+
// m68k: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
216216

217-
// wasm: declare void @natural_align_2({{.*}}byval(%NaturalAlign2) align 2{{.*}})
217+
// wasm: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
218218

219-
// x86_64-linux: declare void @natural_align_2({{.*}}byval(%NaturalAlign2) align 2{{.*}})
219+
// x86_64-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
220220

221221
// x86_64-windows: declare void @natural_align_2(
222222
// x86_64-windows-NOT: byval
223223
// x86_64-windows-SAME: align 2{{.*}})
224224

225-
// i686-linux: declare void @natural_align_2({{.*}}byval(%NaturalAlign2) align 4{{.*}})
225+
// i686-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
226226

227-
// i686-windows: declare void @natural_align_2({{.*}}byval(%NaturalAlign2) align 4{{.*}})
227+
// i686-windows: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
228228
fn natural_align_2(x: NaturalAlign2);
229229

230-
// m68k: declare void @force_align_4({{.*}}byval(%ForceAlign4) align 4{{.*}})
230+
// m68k: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
231231

232-
// wasm: declare void @force_align_4({{.*}}byval(%ForceAlign4) align 4{{.*}})
232+
// wasm: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
233233

234-
// x86_64-linux: declare void @force_align_4({{.*}}byval(%ForceAlign4) align 4{{.*}})
234+
// x86_64-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
235235

236236
// x86_64-windows: declare void @force_align_4(
237237
// x86_64-windows-NOT: byval
238238
// x86_64-windows-SAME: align 4{{.*}})
239239

240-
// i686-linux: declare void @force_align_4({{.*}}byval(%ForceAlign4) align 4{{.*}})
240+
// i686-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
241241

242-
// i686-windows: declare void @force_align_4({{.*}}byval(%ForceAlign4) align 4{{.*}})
242+
// i686-windows: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
243243
fn force_align_4(x: ForceAlign4);
244244

245-
// m68k: declare void @natural_align_8({{.*}}byval(%NaturalAlign8) align 4{{.*}})
245+
// m68k: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
246246

247-
// wasm: declare void @natural_align_8({{.*}}byval(%NaturalAlign8) align 8{{.*}})
247+
// wasm: declare void @natural_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
248248

249-
// x86_64-linux: declare void @natural_align_8({{.*}}byval(%NaturalAlign8) align 8{{.*}})
249+
// x86_64-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
250250

251251
// x86_64-windows: declare void @natural_align_8(
252252
// x86_64-windows-NOT: byval
253253
// x86_64-windows-SAME: align 8{{.*}})
254254

255-
// i686-linux: declare void @natural_align_8({{.*}}byval(%NaturalAlign8) align 4{{.*}})
255+
// i686-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
256256

257-
// i686-windows: declare void @natural_align_8({{.*}}byval(%NaturalAlign8) align 4{{.*}})
257+
// i686-windows: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
258258
fn natural_align_8(x: NaturalAlign8);
259259

260-
// m68k: declare void @force_align_8({{.*}}byval(%ForceAlign8) align 8{{.*}})
260+
// m68k: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
261261

262-
// wasm: declare void @force_align_8({{.*}}byval(%ForceAlign8) align 8{{.*}})
262+
// wasm: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
263263

264-
// x86_64-linux: declare void @force_align_8({{.*}}byval(%ForceAlign8) align 8{{.*}})
264+
// x86_64-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
265265

266266
// x86_64-windows: declare void @force_align_8(
267267
// x86_64-windows-NOT: byval
268268
// x86_64-windows-SAME: align 8{{.*}})
269269

270-
// i686-linux: declare void @force_align_8({{.*}}byval(%ForceAlign8) align 4{{.*}})
270+
// i686-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
271271

272272
// i686-windows: declare void @force_align_8(
273273
// i686-windows-NOT: byval
274274
// i686-windows-SAME: align 8{{.*}})
275275
fn force_align_8(x: ForceAlign8);
276276

277-
// m68k: declare void @lower_fa8({{.*}}byval(%LowerFA8) align 4{{.*}})
277+
// m68k: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
278278

279-
// wasm: declare void @lower_fa8({{.*}}byval(%LowerFA8) align 8{{.*}})
279+
// wasm: declare void @lower_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
280280

281-
// x86_64-linux: declare void @lower_fa8({{.*}}byval(%LowerFA8) align 8{{.*}})
281+
// x86_64-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
282282

283283
// x86_64-windows: declare void @lower_fa8(
284284
// x86_64-windows-NOT: byval
285285
// x86_64-windows-SAME: align 8{{.*}})
286286

287-
// i686-linux: declare void @lower_fa8({{.*}}byval(%LowerFA8) align 4{{.*}})
287+
// i686-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
288288

289-
// i686-windows: declare void @lower_fa8({{.*}}byval(%LowerFA8) align 4{{.*}})
289+
// i686-windows: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
290290
fn lower_fa8(x: LowerFA8);
291291

292-
// m68k: declare void @wrapped_fa8({{.*}}byval(%WrappedFA8) align 8{{.*}})
292+
// m68k: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
293293

294-
// wasm: declare void @wrapped_fa8({{.*}}byval(%WrappedFA8) align 8{{.*}})
294+
// wasm: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
295295

296-
// x86_64-linux: declare void @wrapped_fa8({{.*}}byval(%WrappedFA8) align 8{{.*}})
296+
// x86_64-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
297297

298298
// x86_64-windows: declare void @wrapped_fa8(
299299
// x86_64-windows-NOT: byval
300300
// x86_64-windows-SAME: align 8{{.*}})
301301

302-
// i686-linux: declare void @wrapped_fa8({{.*}}byval(%WrappedFA8) align 4{{.*}})
302+
// i686-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
303303

304304
// i686-windows: declare void @wrapped_fa8(
305305
// i686-windows-NOT: byval
306306
// i686-windows-SAME: align 8{{.*}})
307307
fn wrapped_fa8(x: WrappedFA8);
308308

309-
// m68k: declare void @transparent_fa8({{.*}}byval(%TransparentFA8) align 8{{.*}})
309+
// m68k: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
310310

311-
// wasm: declare void @transparent_fa8({{.*}}byval(%TransparentFA8) align 8{{.*}})
311+
// wasm: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
312312

313-
// x86_64-linux: declare void @transparent_fa8({{.*}}byval(%TransparentFA8) align 8{{.*}})
313+
// x86_64-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
314314

315315
// x86_64-windows: declare void @transparent_fa8(
316316
// x86_64-windows-NOT: byval
317317
// x86_64-windows-SAME: align 8{{.*}})
318318

319-
// i686-linux: declare void @transparent_fa8({{.*}}byval(%TransparentFA8) align 4{{.*}})
319+
// i686-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
320320

321321
// i686-windows: declare void @transparent_fa8(
322322
// i686-windows-NOT: byval
323323
// i686-windows-SAME: align 8{{.*}})
324324
fn transparent_fa8(x: TransparentFA8);
325325

326-
// m68k: declare void @force_align_16({{.*}}byval(%ForceAlign16) align 16{{.*}})
326+
// m68k: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
327327

328-
// wasm: declare void @force_align_16({{.*}}byval(%ForceAlign16) align 16{{.*}})
328+
// wasm: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
329329

330-
// x86_64-linux: declare void @force_align_16({{.*}}byval(%ForceAlign16) align 16{{.*}})
330+
// x86_64-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
331331

332332
// x86_64-windows: declare void @force_align_16(
333333
// x86_64-windows-NOT: byval
334334
// x86_64-windows-SAME: align 16{{.*}})
335335

336-
// i686-linux: declare void @force_align_16({{.*}}byval(%ForceAlign16) align 4{{.*}})
336+
// i686-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 4{{.*}})
337337

338338
// i686-windows: declare void @force_align_16(
339339
// i686-windows-NOT: byval

‎tests/codegen/align-enum.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,6 @@ pub enum Align64 {
88
A(u32),
99
B(u32),
1010
}
11-
// CHECK: %Align64 = type { i32, [15 x i32] }
1211

1312
pub struct Nested64 {
1413
a: u8,

‎tests/codegen/align-struct.rs‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,27 +5,23 @@
55

66
#[repr(align(64))]
77
pub struct Align64(i32);
8-
// CHECK: %Align64 = type { i32, [15 x i32] }
98

109
pub struct Nested64 {
1110
a: Align64,
1211
b: i32,
1312
c: i32,
1413
d: i8,
1514
}
16-
// CHECK: %Nested64 = type { %Align64, i32, i32, i8, [55 x i8] }
1715

1816
pub enum Enum4 {
1917
A(i32),
2018
B(i32),
2119
}
22-
// No Aggregate type, and hence nothing in LLVM IR.
2320

2421
pub enum Enum64 {
2522
A(Align64),
2623
B(i32),
2724
}
28-
// CHECK: %Enum64 = type { i32, [31 x i32] }
2925

3026
// CHECK-LABEL: @align64
3127
#[no_mangle]

‎tests/codegen/function-arguments-noopt.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ pub fn borrow_call(x: &i32, f: fn(&i32) -> &i32) -> &i32 {
4242
f(x)
4343
}
4444

45-
// CHECK: void @struct_(ptr sret(%S) align 4{{( %_0)?}}, ptr align 4 %x)
45+
// CHECK: void @struct_(ptr sret([32 x i8]) align 4{{( %_0)?}}, ptr align 4 %x)
4646
#[no_mangle]
4747
pub fn struct_(x: S) -> S {
4848
x
@@ -51,7 +51,7 @@ pub fn struct_(x: S) -> S {
5151
// CHECK-LABEL: @struct_call
5252
#[no_mangle]
5353
pub fn struct_call(x: S, f: fn(S) -> S) -> S {
54-
// CHECK: call void %f(ptr sret(%S) align 4{{( %_0)?}}, ptr align 4 %{{.+}})
54+
// CHECK: call void %f(ptr sret([32 x i8]) align 4{{( %_0)?}}, ptr align 4 %{{.+}})
5555
f(x)
5656
}
5757

‎tests/codegen/function-arguments.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -188,7 +188,7 @@ pub fn notunpin_box(x: Box<NotUnpin>) -> Box<NotUnpin> {
188188
x
189189
}
190190

191-
// CHECK: @struct_return(ptr noalias nocapture noundef sret(%S) align 4 dereferenceable(32){{( %_0)?}})
191+
// CHECK: @struct_return(ptr noalias nocapture noundef sret([32 x i8]) align 4 dereferenceable(32){{( %_0)?}})
192192
#[no_mangle]
193193
pub fn struct_return() -> S {
194194
S {

‎tests/codegen/mem-replace-big-type.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ pub fn replace_big(dst: &mut Big, src: Big) -> Big {
2323
// CHECK-NOT: call void @llvm.memcpy
2424

2525
// For a large type, we expect exactly three `memcpy`s
26-
// CHECK-LABEL: define internal void @{{.+}}mem{{.+}}replace{{.+}}sret(%Big)
26+
// CHECK-LABEL: define internal void @{{.+}}mem{{.+}}replace{{.+}}sret([56 x i8])
2727
// CHECK-NOT: call void @llvm.memcpy
2828
// CHECK: call void @llvm.memcpy.{{.+}}(ptr align 8 %result, ptr align 8 %dest, i{{.*}} 56, i1 false)
2929
// CHECK-NOT: call void @llvm.memcpy

0 commit comments

Comments
 (0)