Skip to content

Commit 0c89065

Browse files
antoyoantoyo
authored
Update to nightly-2021-08-12 (#61)
1 parent afae271 commit 0c89065

File tree

6 files changed

+42
-19
lines changed

6 files changed

+42
-19
lines changed

‎rust-toolchain‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1 +1 @@
1-
nightly-2021-07-21
1+
nightly-2021-08-12

‎src/builder.rs‎

Lines changed: 22 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@ use rustc_codegen_ssa::traits::{
2525
BuilderMethods,
2626
ConstMethods,
2727
DerivedTypeMethods,
28+
LayoutTypeMethods,
2829
HasCodegen,
2930
OverflowOp,
3031
StaticBuilderMethods,
@@ -514,8 +515,12 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
514515
self.block.expect("block").end_with_switch(None, value, default_block, &gcc_cases);
515516
}
516517

517-
fn invoke(&mut self, _func: RValue<'gcc>, _args: &[RValue<'gcc>], _then: Block<'gcc>, _catch: Block<'gcc>, _funclet: Option<&Funclet>) -> RValue<'gcc> {
518-
unimplemented!();
518+
fn invoke(&mut self, _typ: Type<'gcc>, _func: RValue<'gcc>, _args: &[RValue<'gcc>], then: Block<'gcc>, catch: Block<'gcc>, _funclet: Option<&Funclet>) -> RValue<'gcc> {
519+
let condition = self.context.new_rvalue_from_int(self.bool_type, 0);
520+
self.llbb().end_with_conditional(None, condition, then, catch);
521+
self.context.new_rvalue_from_int(self.int_type, 0)
522+
523+
// TODO
519524
/*debug!("invoke {:?} with args ({:?})", func, args);
520525
521526
let args = self.check_call("invoke", func, args);
@@ -1001,9 +1006,10 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
10011006
}
10021007
else if let abi::Abi::ScalarPair(ref a, ref b) = place.layout.abi {
10031008
let b_offset = a.value.size(self).align_to(b.value.align(self).abi);
1009+
let pair_type = place.layout.gcc_type(self, false);
10041010

10051011
let mut load = |i, scalar: &abi::Scalar, align| {
1006-
let llptr = self.struct_gep(place.llval, i as u64);
1012+
let llptr = self.struct_gep(pair_type, place.llval, i as u64);
10071013
let load = self.load(llptr.get_type(), llptr, align);
10081014
scalar_load_metadata(self, load, scalar);
10091015
if scalar.is_bool() { self.trunc(load, self.type_i1()) } else { load }
@@ -1044,7 +1050,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
10441050
let align = dest.align.restrict_for_offset(dest.layout.field(self.cx(), 0).size);
10451051
cg_elem.val.store(&mut body_bx, PlaceRef::new_sized_aligned(current_val, cg_elem.layout, align));
10461052

1047-
let next = body_bx.inbounds_gep(current.to_rvalue(), &[self.const_usize(1)]);
1053+
let next = body_bx.inbounds_gep(self.backend_type(cg_elem.layout), current.to_rvalue(), &[self.const_usize(1)]);
10481054
body_bx.llbb().add_assignment(None, current, next);
10491055
body_bx.br(header_bx.llbb());
10501056

@@ -1130,15 +1136,15 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
11301136
.add_eval(None, self.context.new_call(None, atomic_store, &[ptr, value, ordering]));
11311137
}
11321138

1133-
fn gep(&mut self, ptr: RValue<'gcc>, indices: &[RValue<'gcc>]) -> RValue<'gcc> {
1139+
fn gep(&mut self, _typ: Type<'gcc>, ptr: RValue<'gcc>, indices: &[RValue<'gcc>]) -> RValue<'gcc> {
11341140
let mut result = ptr;
11351141
for index in indices {
11361142
result = self.context.new_array_access(None, result, *index).get_address(None).to_rvalue();
11371143
}
11381144
result
11391145
}
11401146

1141-
fn inbounds_gep(&mut self, ptr: RValue<'gcc>, indices: &[RValue<'gcc>]) -> RValue<'gcc> {
1147+
fn inbounds_gep(&mut self, _typ: Type<'gcc>, ptr: RValue<'gcc>, indices: &[RValue<'gcc>]) -> RValue<'gcc> {
11421148
// FIXME: would be safer if doing the same thing (loop) as gep.
11431149
// TODO: specify inbounds somehow.
11441150
match indices.len() {
@@ -1153,11 +1159,10 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
11531159
}
11541160
}
11551161

1156-
fn struct_gep(&mut self, ptr: RValue<'gcc>, idx: u64) -> RValue<'gcc> {
1162+
fn struct_gep(&mut self, value_type: Type<'gcc>, ptr: RValue<'gcc>, idx: u64) -> RValue<'gcc> {
11571163
// FIXME: it would be better if the API only called this on struct, not on arrays.
11581164
assert_eq!(idx as usize as u64, idx);
11591165
let value = ptr.dereference(None).to_rvalue();
1160-
let value_type = value.get_type();
11611166

11621167
if value_type.is_array().is_some() {
11631168
let index = self.context.new_rvalue_from_long(self.u64_type, i64::try_from(idx).expect("i64::try_from"));
@@ -1449,14 +1454,19 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
14491454
}
14501455

14511456
fn landing_pad(&mut self, _ty: Type<'gcc>, _pers_fn: RValue<'gcc>, _num_clauses: usize) -> RValue<'gcc> {
1452-
unimplemented!();
1457+
let field1 = self.context.new_field(None, self.u8_type, "landing_pad_field_1");
1458+
let field2 = self.context.new_field(None, self.i32_type, "landing_pad_field_1");
1459+
let struct_type = self.context.new_struct_type(None, "landing_pad", &[field1, field2]);
1460+
self.current_func().new_local(None, struct_type.as_type(), "landing_pad")
1461+
.to_rvalue()
1462+
// TODO
14531463
/*unsafe {
14541464
llvm::LLVMBuildLandingPad(self.llbuilder, ty, pers_fn, num_clauses as c_uint, UNNAMED)
14551465
}*/
14561466
}
14571467

14581468
fn set_cleanup(&mut self, _landing_pad: RValue<'gcc>) {
1459-
unimplemented!();
1469+
// TODO
14601470
/*unsafe {
14611471
llvm::LLVMSetCleanup(landing_pad, llvm::True);
14621472
}*/
@@ -1527,7 +1537,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
15271537
}
15281538

15291539
fn set_personality_fn(&mut self, _personality: RValue<'gcc>) {
1530-
unimplemented!();
1540+
// TODO
15311541
/*unsafe {
15321542
llvm::LLVMSetPersonalityFn(self.llfn(), personality);
15331543
}*/
@@ -1620,7 +1630,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
16201630
//self.call_lifetime_intrinsic("llvm.lifetime.end.p0i8", ptr, size);
16211631
}
16221632

1623-
fn call(&mut self, func: RValue<'gcc>, args: &[RValue<'gcc>], funclet: Option<&Funclet>) -> RValue<'gcc> {
1633+
fn call(&mut self, _typ: Type<'gcc>, func: RValue<'gcc>, args: &[RValue<'gcc>], funclet: Option<&Funclet>) -> RValue<'gcc> {
16241634
// FIXME: remove when having a proper API.
16251635
let gcc_func = unsafe { std::mem::transmute(func) };
16261636
if self.functions.borrow().values().find(|value| **value == gcc_func).is_some() {

‎src/context.rs‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,6 @@ use gccjit::{
1414
use rustc_codegen_ssa::base::wants_msvc_seh;
1515
use rustc_codegen_ssa::traits::{
1616
BackendTypes,
17-
BaseTypeMethods,
1817
MiscMethods,
1918
};
2019
use rustc_data_structures::base_n;
@@ -349,12 +348,15 @@ impl<'gcc, 'tcx> MiscMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
349348
.unwrap().unwrap(),
350349
),
351350
_ => {
352-
let name = if wants_msvc_seh(self.sess()) {
351+
let _name = if wants_msvc_seh(self.sess()) {
353352
"__CxxFrameHandler3"
354353
} else {
355354
"rust_eh_personality"
356355
};
357-
self.declare_func(name, self.type_i32(), &[], true)
356+
//let func = self.declare_func(name, self.type_i32(), &[], true);
357+
// FIXME: this hack should not be needed. That will probably be removed when
358+
// unwinding support is added.
359+
self.context.new_rvalue_from_int(self.int_type, 0)
358360
}
359361
};
360362
//attributes::apply_target_cpu_attr(self, llfn);

‎src/intrinsic/mod.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
9898
_ if simple.is_some() => {
9999
// FIXME: remove this cast when the API supports function.
100100
let func = unsafe { std::mem::transmute(simple.expect("simple")) };
101-
self.call(func, &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(), None)
101+
self.call(self.type_void(), func, &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(), None)
102102
},
103103
sym::likely => {
104104
self.expect(args[0].immediate(), true)
@@ -392,7 +392,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
392392
fn abort(&mut self) {
393393
let func = self.context.get_builtin_function("abort");
394394
let func: RValue<'gcc> = unsafe { std::mem::transmute(func) };
395-
self.call(func, &[], None);
395+
self.call(self.type_void(), func, &[], None);
396396
}
397397

398398
fn assume(&mut self, value: Self::Value) {
@@ -1075,7 +1075,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
10751075

10761076
fn try_intrinsic<'gcc, 'tcx>(bx: &mut Builder<'_, 'gcc, 'tcx>, try_func: RValue<'gcc>, data: RValue<'gcc>, _catch_func: RValue<'gcc>, dest: RValue<'gcc>) {
10771077
if bx.sess().panic_strategy() == PanicStrategy::Abort {
1078-
bx.call(try_func, &[data], None);
1078+
bx.call(bx.type_void(), try_func, &[data], None);
10791079
// Return 0 unconditionally from the intrinsic call;
10801080
// we can never unwind.
10811081
let ret_align = bx.tcx.data_layout.i32_align.abi;

‎src/type_.rs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -293,6 +293,11 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
293293
}
294294
}
295295

296+
// NOTE: see note above. Some other test uses usize::MAX.
297+
if len == u64::MAX {
298+
len = 0;
299+
}
300+
296301
let len: i32 = len.try_into().expect("array len");
297302

298303
self.context.new_array_type(None, ty, len)

‎src/type_of.rs‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -363,4 +363,10 @@ impl<'gcc, 'tcx> LayoutTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
363363
unimplemented!();
364364
//ty.gcc_type(self)
365365
}
366+
367+
fn fn_decl_backend_type(&self, _fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Type<'gcc> {
368+
// FIXME: return correct type.
369+
self.type_void()
370+
//fn_abi.gcc_type(self)
371+
}
366372
}

0 commit comments

Comments
 (0)