Skip to content

Commit e8dca3e

Browse files
antoyoantoyo
authoredJun 7, 2022
Merge pull request #179 from rust-lang/sync_from_rust2
Sync from rust2
·
1.86.01.63.0
2 parents 7e0a42b + fb69f73 commit e8dca3e

14 files changed

+154
-67
lines changed
 

‎Readme.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ A secondary goal is to check if using the gcc backend will provide any run-time
1212
## Building
1313

1414
**This requires a patched libgccjit in order to work.
15-
The patches in [this repostory](https://github.com/antoyo/libgccjit-patches) need to be applied.
15+
The patches in [this repository](https://github.com/antoyo/libgccjit-patches) need to be applied.
1616
(Those patches should work when applied on master, but in case it doesn't work, they are known to work when applied on 079c23cfe079f203d5df83fea8e92a60c7d7e878.)
1717
You can also use my [fork of gcc](https://github.com/antoyo/gcc) which already includes these patches.**
1818

‎example/arbitrary_self_types_pointers_and_wrappers.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T> {}
3737

3838
trait Trait {
3939
// This method isn't object-safe yet. Unsized by-value `self` is object-safe (but not callable
40-
// without unsized_locals), but wrappers arond `Self` currently are not.
40+
// without unsized_locals), but wrappers around `Self` currently are not.
4141
// FIXME (mikeyhew) uncomment this when unsized rvalues object-safety is implemented
4242
// fn wrapper(self: Wrapper<Self>) -> i32;
4343
fn ptr_wrapper(self: Ptr<Wrapper<Self>>) -> i32;

‎rust-toolchain

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,3 @@
11
[toolchain]
2-
channel = "nightly-2022-03-26"
2+
channel = "nightly-2022-06-06"
33
components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

‎rustup.sh

+1-1
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ case $1 in
1010
rustup toolchain install --profile minimal nightly-${TOOLCHAIN} # Sanity check to see if the nightly exists
1111
echo nightly-${TOOLCHAIN} > rust-toolchain
1212

13-
echo "=> Uninstalling all old nighlies"
13+
echo "=> Uninstalling all old nightlies"
1414
for nightly in $(rustup toolchain list | grep nightly | grep -v $TOOLCHAIN | grep -v nightly-x86_64); do
1515
rustup toolchain uninstall $nightly
1616
done

‎src/asm.rs

+34-6
Original file line numberDiff line numberDiff line change
@@ -258,9 +258,14 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
258258
}
259259

260260
InlineAsmOperandRef::SymFn { instance } => {
261+
// TODO(@Amanieu): Additional mangling is needed on
262+
// some targets to add a leading underscore (Mach-O)
263+
// or byte count suffixes (x86 Windows).
261264
constants_len += self.tcx.symbol_name(instance).name.len();
262265
}
263266
InlineAsmOperandRef::SymStatic { def_id } => {
267+
// TODO(@Amanieu): Additional mangling is needed on
268+
// some targets to add a leading underscore (Mach-O).
264269
constants_len += self.tcx.symbol_name(Instance::mono(self.tcx, def_id)).name.len();
265270
}
266271
}
@@ -427,13 +432,16 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
427432
}
428433

429434
InlineAsmOperandRef::SymFn { instance } => {
435+
// TODO(@Amanieu): Additional mangling is needed on
436+
// some targets to add a leading underscore (Mach-O)
437+
// or byte count suffixes (x86 Windows).
430438
let name = self.tcx.symbol_name(instance).name;
431439
template_str.push_str(name);
432440
}
433441

434442
InlineAsmOperandRef::SymStatic { def_id } => {
435-
// TODO(@Commeownist): This may not be sufficient for all kinds of statics.
436-
// Some statics may need the `@plt` suffix, like thread-local vars.
443+
// TODO(@Amanieu): Additional mangling is needed on
444+
// some targets to add a leading underscore (Mach-O).
437445
let instance = Instance::mono(self.tcx, def_id);
438446
let name = self.tcx.symbol_name(instance).name;
439447
template_str.push_str(name);
@@ -596,9 +604,10 @@ fn reg_to_gcc(reg: InlineAsmRegOrRegClass) -> ConstraintOrRegister {
596604
| InlineAsmRegClass::X86(X86InlineAsmRegClass::ymm_reg) => "x",
597605
InlineAsmRegClass::X86(X86InlineAsmRegClass::zmm_reg) => "v",
598606
InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg) => "Yk",
607+
InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg0) => unimplemented!(),
599608
InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => unimplemented!(),
600609
InlineAsmRegClass::X86(
601-
X86InlineAsmRegClass::x87_reg | X86InlineAsmRegClass::mmx_reg,
610+
X86InlineAsmRegClass::x87_reg | X86InlineAsmRegClass::mmx_reg | X86InlineAsmRegClass::tmm_reg,
602611
) => unreachable!("clobber-only"),
603612
InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
604613
bug!("GCC backend does not support SPIR-V")
@@ -661,6 +670,8 @@ fn dummy_output_type<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, reg: InlineAsmRegCl
661670
| InlineAsmRegClass::X86(X86InlineAsmRegClass::zmm_reg) => cx.type_f32(),
662671
InlineAsmRegClass::X86(X86InlineAsmRegClass::x87_reg) => unimplemented!(),
663672
InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg) => cx.type_i16(),
673+
InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg0) => cx.type_i16(),
674+
InlineAsmRegClass::X86(X86InlineAsmRegClass::tmm_reg) => unimplemented!(),
664675
InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => cx.type_i32(),
665676
InlineAsmRegClass::SpirV(SpirVInlineAsmRegClass::reg) => {
666677
bug!("LLVM backend does not support SPIR-V")
@@ -671,8 +682,8 @@ fn dummy_output_type<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, reg: InlineAsmRegCl
671682
}
672683
}
673684

674-
impl<'gcc, 'tcx> AsmMethods for CodegenCx<'gcc, 'tcx> {
675-
fn codegen_global_asm(&self, template: &[InlineAsmTemplatePiece], operands: &[GlobalAsmOperandRef], options: InlineAsmOptions, _line_spans: &[Span]) {
685+
impl<'gcc, 'tcx> AsmMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
686+
fn codegen_global_asm(&self, template: &[InlineAsmTemplatePiece], operands: &[GlobalAsmOperandRef<'tcx>], options: InlineAsmOptions, _line_spans: &[Span]) {
676687
let asm_arch = self.tcx.sess.asm_arch.unwrap();
677688

678689
// Default to Intel syntax on x86
@@ -705,6 +716,22 @@ impl<'gcc, 'tcx> AsmMethods for CodegenCx<'gcc, 'tcx> {
705716
// here unlike normal inline assembly.
706717
template_str.push_str(string);
707718
}
719+
720+
GlobalAsmOperandRef::SymFn { instance } => {
721+
// TODO(@Amanieu): Additional mangling is needed on
722+
// some targets to add a leading underscore (Mach-O)
723+
// or byte count suffixes (x86 Windows).
724+
let name = self.tcx.symbol_name(instance).name;
725+
template_str.push_str(name);
726+
}
727+
728+
GlobalAsmOperandRef::SymStatic { def_id } => {
729+
// TODO(@Amanieu): Additional mangling is needed on
730+
// some targets to add a leading underscore (Mach-O).
731+
let instance = Instance::mono(self.tcx, def_id);
732+
let name = self.tcx.symbol_name(instance).name;
733+
template_str.push_str(name);
734+
}
708735
}
709736
}
710737
}
@@ -775,7 +802,8 @@ fn modifier_to_gcc(arch: InlineAsmArch, reg: InlineAsmRegClass, modifier: Option
775802
_ => unreachable!(),
776803
},
777804
InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg) => None,
778-
InlineAsmRegClass::X86(X86InlineAsmRegClass::x87_reg | X86InlineAsmRegClass::mmx_reg) => {
805+
InlineAsmRegClass::X86(X86InlineAsmRegClass::kreg0) => None,
806+
InlineAsmRegClass::X86(X86InlineAsmRegClass::x87_reg | X86InlineAsmRegClass::mmx_reg | X86InlineAsmRegClass::tmm_reg) => {
779807
unreachable!("clobber-only")
780808
}
781809
InlineAsmRegClass::Wasm(WasmInlineAsmRegClass::local) => unimplemented!(),

‎src/back/write.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ use rustc_target::spec::SplitDebuginfo;
1111
use crate::{GccCodegenBackend, GccContext};
1212

1313
pub(crate) unsafe fn codegen(cgcx: &CodegenContext<GccCodegenBackend>, _diag_handler: &Handler, module: ModuleCodegen<GccContext>, config: &ModuleConfig) -> Result<CompiledModule, FatalError> {
14-
let _timer = cgcx.prof.generic_activity_with_arg("LLVM_module_codegen", &module.name[..]);
14+
let _timer = cgcx.prof.generic_activity_with_arg("LLVM_module_codegen", &*module.name);
1515
{
1616
let context = &module.module_llvm.context;
1717

‎src/builder.rs

+13-29
Original file line numberDiff line numberDiff line change
@@ -62,24 +62,6 @@ enum ExtremumOperation {
6262
Min,
6363
}
6464

65-
trait EnumClone {
66-
fn clone(&self) -> Self;
67-
}
68-
69-
impl EnumClone for AtomicOrdering {
70-
fn clone(&self) -> Self {
71-
match *self {
72-
AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
73-
AtomicOrdering::Unordered => AtomicOrdering::Unordered,
74-
AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
75-
AtomicOrdering::Acquire => AtomicOrdering::Acquire,
76-
AtomicOrdering::Release => AtomicOrdering::Release,
77-
AtomicOrdering::AcquireRelease => AtomicOrdering::AcquireRelease,
78-
AtomicOrdering::SequentiallyConsistent => AtomicOrdering::SequentiallyConsistent,
79-
}
80-
}
81-
}
82-
8365
pub struct Builder<'a: 'gcc, 'gcc, 'tcx> {
8466
pub cx: &'a CodegenCx<'gcc, 'tcx>,
8567
pub block: Block<'gcc>,
@@ -104,9 +86,9 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
10486
match order {
10587
// TODO(antoyo): does this make sense?
10688
AtomicOrdering::AcquireRelease | AtomicOrdering::Release => AtomicOrdering::Acquire,
107-
_ => order.clone(),
89+
_ => order,
10890
};
109-
let previous_value = self.atomic_load(dst.get_type(), dst, load_ordering.clone(), Size::from_bytes(size));
91+
let previous_value = self.atomic_load(dst.get_type(), dst, load_ordering, Size::from_bytes(size));
11092
let previous_var = func.new_local(None, previous_value.get_type(), "previous_value");
11193
let return_value = func.new_local(None, previous_value.get_type(), "return_value");
11294
self.llbb().add_assignment(None, previous_var, previous_value);
@@ -510,8 +492,11 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
510492
}
511493

512494
fn exactudiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
513-
// TODO(antoyo): convert the arguments to unsigned?
514495
// TODO(antoyo): poison if not exact.
496+
let a_type = a.get_type().to_unsigned(self);
497+
let a = self.gcc_int_cast(a, a_type);
498+
let b_type = b.get_type().to_unsigned(self);
499+
let b = self.gcc_int_cast(b, b_type);
515500
a / b
516501
}
517502

@@ -520,7 +505,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
520505
}
521506

522507
fn exactsdiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
523-
// TODO(antoyo): posion if not exact.
508+
// TODO(antoyo): poison if not exact.
524509
// FIXME(antoyo): rustc_codegen_ssa::mir::intrinsic uses different types for a and b but they
525510
// should be the same.
526511
let typ = a.get_type().to_signed(self);
@@ -705,11 +690,11 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
705690
}
706691

707692
fn scalar_load_metadata<'a, 'gcc, 'tcx>(bx: &mut Builder<'a, 'gcc, 'tcx>, load: RValue<'gcc>, scalar: &abi::Scalar) {
708-
let vr = scalar.valid_range.clone();
709-
match scalar.value {
693+
let vr = scalar.valid_range(bx);
694+
match scalar.primitive() {
710695
abi::Int(..) => {
711696
if !scalar.is_always_valid(bx) {
712-
bx.range_metadata(load, scalar.valid_range);
697+
bx.range_metadata(load, vr);
713698
}
714699
}
715700
abi::Pointer if vr.start < vr.end && !vr.contains(0) => {
@@ -735,7 +720,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
735720
OperandValue::Immediate(self.to_immediate(load, place.layout))
736721
}
737722
else if let abi::Abi::ScalarPair(ref a, ref b) = place.layout.abi {
738-
let b_offset = a.value.size(self).align_to(b.value.align(self).abi);
723+
let b_offset = a.size(self).align_to(b.align(self).abi);
739724
let pair_type = place.layout.gcc_type(self, false);
740725

741726
let mut load = |i, scalar: &abi::Scalar, align| {
@@ -1275,7 +1260,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
12751260
}
12761261

12771262
fn do_not_inline(&mut self, _llret: RValue<'gcc>) {
1278-
// FIMXE(bjorn3): implement
1263+
// FIXME(bjorn3): implement
12791264
}
12801265

12811266
fn set_span(&mut self, _span: Span) {}
@@ -1574,9 +1559,8 @@ impl ToGccOrdering for AtomicOrdering {
15741559

15751560
let ordering =
15761561
match self {
1577-
AtomicOrdering::NotAtomic => __ATOMIC_RELAXED, // TODO(antoyo): check if that's the same.
15781562
AtomicOrdering::Unordered => __ATOMIC_RELAXED,
1579-
AtomicOrdering::Monotonic => __ATOMIC_RELAXED, // TODO(antoyo): check if that's the same.
1563+
AtomicOrdering::Relaxed => __ATOMIC_RELAXED, // TODO(antoyo): check if that's the same.
15801564
AtomicOrdering::Acquire => __ATOMIC_ACQUIRE,
15811565
AtomicOrdering::Release => __ATOMIC_RELEASE,
15821566
AtomicOrdering::AcquireRelease => __ATOMIC_ACQ_REL,

‎src/common.rs

+65-6
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,10 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
9191
self.const_uint(self.type_i1(), val as u64)
9292
}
9393

94+
fn const_i16(&self, i: i16) -> RValue<'gcc> {
95+
self.const_int(self.type_i16(), i as i64)
96+
}
97+
9498
fn const_i32(&self, i: i32) -> RValue<'gcc> {
9599
self.const_int(self.type_i32(), i as i64)
96100
}
@@ -154,14 +158,14 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
154158
}
155159

156160
fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) -> RValue<'gcc> {
157-
let bitsize = if layout.is_bool() { 1 } else { layout.value.size(self).bits() };
161+
let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
158162
match cv {
159163
Scalar::Int(ScalarInt::ZST) => {
160-
assert_eq!(0, layout.value.size(self).bytes());
164+
assert_eq!(0, layout.size(self).bytes());
161165
self.const_undef(self.type_ix(0))
162166
}
163167
Scalar::Int(int) => {
164-
let data = int.assert_bits(layout.value.size(self));
168+
let data = int.assert_bits(layout.size(self));
165169

166170
// FIXME(antoyo): there's some issues with using the u128 code that follows, so hard-code
167171
// the paths for floating-point values.
@@ -205,7 +209,7 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
205209
let base_addr = self.const_bitcast(base_addr, self.usize_type);
206210
let offset = self.context.new_rvalue_from_long(self.usize_type, offset.bytes() as i64);
207211
let ptr = self.const_bitcast(base_addr + offset, ptr_type);
208-
if layout.value != Pointer {
212+
if layout.primitive() != Pointer {
209213
self.const_bitcast(ptr.dereference(None).to_rvalue(), ty)
210214
}
211215
else {
@@ -275,6 +279,21 @@ impl<'gcc, 'tcx> SignType<'gcc, 'tcx> for Type<'gcc> {
275279
else if self.is_u128(cx) {
276280
cx.i128_type
277281
}
282+
else if self.is_uchar(cx) {
283+
cx.char_type
284+
}
285+
else if self.is_ushort(cx) {
286+
cx.short_type
287+
}
288+
else if self.is_uint(cx) {
289+
cx.int_type
290+
}
291+
else if self.is_ulong(cx) {
292+
cx.long_type
293+
}
294+
else if self.is_ulonglong(cx) {
295+
cx.longlong_type
296+
}
278297
else {
279298
self.clone()
280299
}
@@ -296,6 +315,21 @@ impl<'gcc, 'tcx> SignType<'gcc, 'tcx> for Type<'gcc> {
296315
else if self.is_i128(cx) {
297316
cx.u128_type
298317
}
318+
else if self.is_char(cx) {
319+
cx.uchar_type
320+
}
321+
else if self.is_short(cx) {
322+
cx.ushort_type
323+
}
324+
else if self.is_int(cx) {
325+
cx.uint_type
326+
}
327+
else if self.is_long(cx) {
328+
cx.ulong_type
329+
}
330+
else if self.is_longlong(cx) {
331+
cx.ulonglong_type
332+
}
299333
else {
300334
self.clone()
301335
}
@@ -308,6 +342,11 @@ pub trait TypeReflection<'gcc, 'tcx> {
308342
fn is_uint(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
309343
fn is_ulong(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
310344
fn is_ulonglong(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
345+
fn is_char(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
346+
fn is_short(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
347+
fn is_int(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
348+
fn is_long(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
349+
fn is_longlong(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
311350

312351
fn is_i8(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
313352
fn is_u8(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
@@ -328,11 +367,11 @@ pub trait TypeReflection<'gcc, 'tcx> {
328367

329368
impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
330369
fn is_uchar(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
331-
self.unqualified() == cx.u8_type
370+
self.unqualified() == cx.uchar_type
332371
}
333372

334373
fn is_ushort(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
335-
self.unqualified() == cx.u16_type
374+
self.unqualified() == cx.ushort_type
336375
}
337376

338377
fn is_uint(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
@@ -347,6 +386,26 @@ impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
347386
self.unqualified() == cx.ulonglong_type
348387
}
349388

389+
fn is_char(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
390+
self.unqualified() == cx.char_type
391+
}
392+
393+
fn is_short(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
394+
self.unqualified() == cx.short_type
395+
}
396+
397+
fn is_int(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
398+
self.unqualified() == cx.int_type
399+
}
400+
401+
fn is_long(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
402+
self.unqualified() == cx.long_type
403+
}
404+
405+
fn is_longlong(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
406+
self.unqualified() == cx.longlong_type
407+
}
408+
350409
fn is_i8(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
351410
self.unqualified() == cx.i8_type
352411
}

‎src/consts.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -329,7 +329,7 @@ pub fn const_alloc_to_gcc<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, alloc: ConstAl
329329
interpret::Pointer::new(alloc_id, Size::from_bytes(ptr_offset)),
330330
&cx.tcx,
331331
),
332-
abi::Scalar { value: Primitive::Pointer, valid_range: WrappingRange { start: 0, end: !0 } },
332+
abi::Scalar::Initialized { value: Primitive::Pointer, valid_range: WrappingRange::full(dl.pointer_size) },
333333
cx.type_i8p(),
334334
));
335335
next_offset = offset + pointer_size;

‎src/context.rs

+16-1
Original file line numberDiff line numberDiff line change
@@ -54,10 +54,15 @@ pub struct CodegenCx<'gcc, 'tcx> {
5454
pub u128_type: Type<'gcc>,
5555
pub usize_type: Type<'gcc>,
5656

57+
pub char_type: Type<'gcc>,
58+
pub uchar_type: Type<'gcc>,
59+
pub short_type: Type<'gcc>,
60+
pub ushort_type: Type<'gcc>,
5761
pub int_type: Type<'gcc>,
5862
pub uint_type: Type<'gcc>,
5963
pub long_type: Type<'gcc>,
6064
pub ulong_type: Type<'gcc>,
65+
pub longlong_type: Type<'gcc>,
6166
pub ulonglong_type: Type<'gcc>,
6267
pub sizet_type: Type<'gcc>,
6368

@@ -111,7 +116,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
111116
/// NOTE: a hack is used because the rustc API is not suitable to libgccjit and as such,
112117
/// `const_undef()` returns struct as pointer so that they can later be assigned a value.
113118
/// As such, this set remembers which of these pointers were returned by this function so that
114-
/// they can be deferenced later.
119+
/// they can be dereferenced later.
115120
/// FIXME(antoyo): fix the rustc API to avoid having this hack.
116121
pub structs_as_pointer: RefCell<FxHashSet<RValue<'gcc>>>,
117122
}
@@ -146,10 +151,15 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
146151
let float_type = context.new_type::<f32>();
147152
let double_type = context.new_type::<f64>();
148153

154+
let char_type = context.new_c_type(CType::Char);
155+
let uchar_type = context.new_c_type(CType::UChar);
156+
let short_type = context.new_c_type(CType::Short);
157+
let ushort_type = context.new_c_type(CType::UShort);
149158
let int_type = context.new_c_type(CType::Int);
150159
let uint_type = context.new_c_type(CType::UInt);
151160
let long_type = context.new_c_type(CType::Long);
152161
let ulong_type = context.new_c_type(CType::ULong);
162+
let longlong_type = context.new_c_type(CType::LongLong);
153163
let ulonglong_type = context.new_c_type(CType::ULongLong);
154164
let sizet_type = context.new_c_type(CType::SizeT);
155165

@@ -202,10 +212,15 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
202212
u32_type,
203213
u64_type,
204214
u128_type,
215+
char_type,
216+
uchar_type,
217+
short_type,
218+
ushort_type,
205219
int_type,
206220
uint_type,
207221
long_type,
208222
ulong_type,
223+
longlong_type,
209224
ulonglong_type,
210225
sizet_type,
211226

‎src/intrinsic/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -340,7 +340,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
340340
}
341341

342342
fn assume(&mut self, value: Self::Value) {
343-
// TODO(antoyo): switch to asumme when it exists.
343+
// TODO(antoyo): switch to assume when it exists.
344344
// Or use something like this:
345345
// #define __assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
346346
self.expect(value, true);

‎src/intrinsic/simd.rs

+1
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ use crate::intrinsic;
1818

1919
pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(bx: &mut Builder<'a, 'gcc, 'tcx>, name: Symbol, callee_ty: Ty<'tcx>, args: &[OperandRef<'tcx, RValue<'gcc>>], ret_ty: Ty<'tcx>, llret_ty: Type<'gcc>, span: Span) -> Result<RValue<'gcc>, ()> {
2020
// macros for error handling:
21+
#[allow(unused_macro_rules)]
2122
macro_rules! emit_error {
2223
($msg: tt) => {
2324
emit_error!($msg, )

‎src/lib.rs

+16-16
Original file line numberDiff line numberDiff line change
@@ -139,14 +139,12 @@ impl CodegenBackend for GccCodegenBackend {
139139
}
140140

141141
impl ExtraBackendMethods for GccCodegenBackend {
142-
fn new_metadata<'tcx>(&self, _tcx: TyCtxt<'tcx>, _mod_name: &str) -> Self::Module {
143-
GccContext {
142+
fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, module_name: &str, kind: AllocatorKind, has_alloc_error_handler: bool) -> Self::Module {
143+
let mut mods = GccContext {
144144
context: Context::default(),
145-
}
146-
}
147-
148-
fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, mods: &mut Self::Module, module_name: &str, kind: AllocatorKind, has_alloc_error_handler: bool) {
149-
unsafe { allocator::codegen(tcx, mods, module_name, kind, has_alloc_error_handler) }
145+
};
146+
unsafe { allocator::codegen(tcx, &mut mods, module_name, kind, has_alloc_error_handler); }
147+
mods
150148
}
151149

152150
fn compile_codegen_unit<'tcx>(&self, tcx: TyCtxt<'tcx>, cgu_name: Symbol) -> (ModuleCodegen<Self::Module>, u64) {
@@ -213,7 +211,7 @@ impl WriteBackendMethods for GccCodegenBackend {
213211
unimplemented!();
214212
}
215213
};
216-
Ok(LtoModuleCodegen::Fat { module: Some(module), _serialized_bitcode: vec![] })
214+
Ok(LtoModuleCodegen::Fat { module, _serialized_bitcode: vec![] })
217215
}
218216

219217
fn run_thin_lto(_cgcx: &CodegenContext<Self>, _modules: Vec<(String, Self::ThinBuffer)>, _cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError> {
@@ -229,7 +227,12 @@ impl WriteBackendMethods for GccCodegenBackend {
229227
Ok(())
230228
}
231229

232-
unsafe fn optimize_thin(_cgcx: &CodegenContext<Self>, _thin: &mut ThinModule<Self>) -> Result<ModuleCodegen<Self::Module>, FatalError> {
230+
fn optimize_fat(_cgcx: &CodegenContext<Self>, _module: &mut ModuleCodegen<Self::Module>) -> Result<(), FatalError> {
231+
// TODO(antoyo)
232+
Ok(())
233+
}
234+
235+
unsafe fn optimize_thin(_cgcx: &CodegenContext<Self>, _thin: ThinModule<Self>) -> Result<ModuleCodegen<Self::Module>, FatalError> {
233236
unimplemented!();
234237
}
235238

@@ -245,11 +248,6 @@ impl WriteBackendMethods for GccCodegenBackend {
245248
unimplemented!();
246249
}
247250

248-
fn run_lto_pass_manager(_cgcx: &CodegenContext<Self>, _module: &ModuleCodegen<Self::Module>, _config: &ModuleConfig, _thin: bool) -> Result<(), FatalError> {
249-
// TODO(antoyo)
250-
Ok(())
251-
}
252-
253251
fn run_link(cgcx: &CodegenContext<Self>, diag_handler: &Handler, modules: Vec<ModuleCodegen<Self::Module>>) -> Result<ModuleCodegen<Self::Module>, FatalError> {
254252
back::write::link(cgcx, diag_handler, modules)
255253
}
@@ -287,8 +285,10 @@ fn handle_native(name: &str) -> &str {
287285
}
288286

289287
pub fn target_cpu(sess: &Session) -> &str {
290-
let name = sess.opts.cg.target_cpu.as_ref().unwrap_or(&sess.target.cpu);
291-
handle_native(name)
288+
match sess.opts.cg.target_cpu {
289+
Some(ref name) => handle_native(name),
290+
None => handle_native(sess.target.cpu.as_ref()),
291+
}
292292
}
293293

294294
pub fn target_features(sess: &Session) -> Vec<Symbol> {

‎src/type_of.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -248,7 +248,7 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
248248
}
249249

250250
fn scalar_gcc_type_at<'gcc>(&self, cx: &CodegenCx<'gcc, 'tcx>, scalar: &abi::Scalar, offset: Size) -> Type<'gcc> {
251-
match scalar.value {
251+
match scalar.primitive() {
252252
Int(i, true) => cx.type_from_integer(i),
253253
Int(i, false) => cx.type_from_unsigned_integer(i),
254254
F32 => cx.type_f32(),
@@ -306,7 +306,7 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
306306
Size::ZERO
307307
}
308308
else {
309-
a.value.size(cx).align_to(b.value.align(cx).abi)
309+
a.size(cx).align_to(b.align(cx).abi)
310310
};
311311
self.scalar_gcc_type_at(cx, scalar, offset)
312312
}

0 commit comments

Comments
 (0)
Please sign in to comment.