Merge pull request #22 from antoyo/fix-align-128bits

Fix alignment for 128-bit integers

Author: antoyo

gcc-test-backend/Cargo.lock

@@ -9,7 +9,7 @@ edition = "2018"
 #mini_core = { path = "mini_core" }
 #deflate = "0.7.19"
 #backtrace = "0.3.57"
-mylib = { path = "mylib" }
+#mylib = { path = "mylib" }
 
 [profile.dev]
 panic = "abort"

gcc-test-backend/Cargo.toml

@@ -1,4 +1,4 @@
-#![feature(const_option)]
+#![feature(const_option, core_intrinsics)]
 
 fn main() {
     /*test_float!(f64, f64, f64::INFINITY, f64::NEG_INFINITY, f64::NAN);
@@ -193,47 +193,104 @@ fn main() {
     assert_eq!(r.saturating_pow(3), -8 as i128);
     assert_eq!(r.saturating_pow(0), 1 as i128);*/
 
-    {
-        const A: u128 = 0b0101100;
-        const B: u128 = 0b0100001;
-        const C: u128 = 0b1111001;
+    /*let res = 10_i64.checked_div(2);
+    if res == Some(5) {
+        println!("1");
+    }*/
 
-        const _0: u128 = 0;
-        const _1: u128 = !0;
-
-        assert_eq!(A.reverse_bits().reverse_bits(), A);
-        assert_eq!(B.reverse_bits().reverse_bits(), B);
-        assert_eq!(C.reverse_bits().reverse_bits(), C);
-
-        // Swapping these should make no difference
-        assert_eq!(_0.reverse_bits(), _0);
-        assert_eq!(_1.reverse_bits(), _1);
+    fn equal(num1: &Option<i64>, num2: &Option<i64>) -> bool {
+        match (num1, num2) {
+            (Some(num1), Some(num2)) => num1 == num2,
+            (None, None) => true,
+            _ => false
+        }
     }
 
-    const _0: i128 = 0;
-    const _1: i128 = !0;
-
-    use std::i128::MAX;
+    fn equal2(num1: &Option<i128>, num2: &Option<i128>) -> bool {
+        match (num1, num2) {
+            (Some(num1), Some(num2)) => num1 == num2,
+            (None, None) => true,
+            _ => false
+        }
+    }
 
-    let a: i128 = 0b0101_1111;
-    assert_eq!(a.trailing_ones(), 5);
-    assert_eq!((!a).leading_ones(), i128::BITS - 7);
+    /*let res2 = Some(10_i64 / 2);
+    // NOTE: (local variable case) res2 is initialized as:
+    // first 8 bits: 1
+    // next 8 bits : 5
+    //
+    // (global variable case) Some(5) is initialized as:
+    // first 8 bits: 1
+    // next 8 bits : 5
+    if equal(&res2, &Some(5)) {
+        //println!("Equal: {}", res2 == Some(5));
+        std::process::exit(1);
+    }*/
+
+    // TODO: this seems to confirm that align(i128) == 16.
+    #[repr(C)]
+    struct int_option {
+        is_some: bool,
+        val: i128,
+    }
 
-    assert_eq!(a.reverse_bits().leading_ones(), 5);
+    fn equal3(int1: &int_option, int2: &int_option) -> bool {
+        int1.is_some == int2.is_some &&
+            int1.val == int2.val
+    }
 
-    assert_eq!(_1.leading_ones(), i128::BITS);
-    assert_eq!(_1.trailing_ones(), i128::BITS);
+    let res = int_option {
+        is_some: true,
+        val: 10 / 2,
+    };
+
+    let expected = int_option {
+        is_some: true,
+        val: 5,
+    };
+
+    /*if equal3(&expected, &res) {
+        std::process::exit(50);
+    }*/
+
+    // FIXME: &Option<i128> does not work while Option<i128> does.
+    let res2 = Some(10_i128 / 2);
+    // NOTE: (local variable case) res2 is initialized as:
+    // first 16 bits: 1 (garbage in the last 8 bits)
+    // next 8 bits  : 5
+    // next 8 bits  : 0
+    //
+    // FIXME: maybe there's an alignment problem (i.e. the i128 wants to be aligned on 128-bits?).
+    //
+    // (global variable case) Some(5) is initialized as:
+    // first 8 bits: 1
+    // next 8 bits : 5
+    // next 8 bits : 0
+    //
+    //let res1 = Some(5); // NOTE: It works when putting the value in a variable.
+    // NOTE: the case that doesn't work uses a global variable, which might mean we don't
+    // initialize them correctly.
+    if equal2(&Some(5), &res2) {
+        //println!("Equal: {}", res2 == Some(5));
+        std::process::exit(42);
+    }
 
-    assert_eq!((_1 << 1).trailing_ones(), 0);
-    assert_eq!(MAX.leading_ones(), 0);
+    /*let res = 10_i128.checked_div(2);
+    if res == Some(5) {
+        println!("2");
+    }
+    if let Some(val) = res {
+        println!("Val: {}", val);
+    }*/
 
-    assert_eq!((_1 << 1).leading_ones(), i128::BITS - 1);
-    assert_eq!(MAX.trailing_ones(), i128::BITS - 1);
+    /*let res = 5_i128.checked_div(0);
+    if let Some(val) = res {
+        println!("Val: {}", val);
+    }
 
-    assert_eq!(_0.leading_ones(), 0);
-    assert_eq!(_0.trailing_ones(), 0);
+    assert!((10 as i128).checked_div(2) == Some(5));
+    assert!((5 as i128).checked_div(0) == None);*/
 
-    let x: i128 = 0b0010_1100;
-    assert_eq!(x.leading_ones(), 0);
-    assert_eq!(x.trailing_ones(), 0);
+    /*assert_eq!((10 as i128).checked_div(2), Some(5));
+    assert_eq!((5 as i128).checked_div(0), None);*/
 }

gcc-test-backend/src/main.rs

@@ -1,3 +1,4 @@
+use std::env;
 use std::sync::Once;
 use std::time::Instant;
 
@@ -75,7 +76,9 @@ pub fn compile_codegen_unit<'tcx>(tcx: TyCtxt<'tcx>, cgu_name: Symbol) -> (Modul
         // TODO: only set on x86 platforms.
         context.add_command_line_option("-masm=intel");
         //context.set_dump_code_on_compile(true);
-        //context.set_dump_initial_gimple(true);
+        if env::var("CG_GCCJIT_DUMP_GIMPLE").as_deref() == Ok("1") {
+            context.set_dump_initial_gimple(true);
+        }
         context.set_debug_info(true);
         //context.set_dump_everything(true);
         //context.set_keep_intermediates(true);

src/base.rs

@@ -874,7 +874,15 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
     }
 
     fn alloca(&mut self, ty: Type<'gcc>, align: Align) -> RValue<'gcc> {
-        let aligned_type = ty.get_aligned(align.bytes());
+        // FIXME: this check that we don't call get_aligned() a second time on a time.
+        // Ideally, we shouldn't need to do this check.
+        let aligned_type =
+            if ty == self.cx.u128_type || ty == self.cx.i128_type {
+                ty
+            }
+            else {
+                ty.get_aligned(align.bytes())
+            };
         // TODO: It might be better to return a LValue, but fixing the rustc API is non-trivial.
         self.stack_var_count.set(self.stack_var_count.get() + 1);
         self.current_func().new_local(None, aligned_type, &format!("stack_var_{}", self.stack_var_count.get())).get_address(None)

src/builder.rs

@@ -1,7 +1,7 @@
 use std::convert::TryFrom;
 use std::convert::TryInto;
 
-use gccjit::{Block, RValue, Type, ToRValue};
+use gccjit::{Block, CType, RValue, Type, ToRValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{
     BaseTypeMethods,
@@ -425,11 +425,11 @@ impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
     }
 
     fn is_i128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.unqualified() == cx.i128_type
+        self.unqualified() == cx.context.new_c_type(CType::Int128t)
     }
 
     fn is_u128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.unqualified() == cx.u128_type
+        self.unqualified() == cx.context.new_c_type(CType::UInt128t)
     }
 
     fn is_f32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {

src/common.rs

@@ -145,12 +145,12 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let i16_type = context.new_type::<i16>();
         let i32_type = context.new_type::<i32>();
         let i64_type = context.new_c_type(CType::LongLong);
-        let i128_type = context.new_c_type(CType::Int128t);
+        let i128_type = context.new_c_type(CType::Int128t).get_aligned(8); // TODO: should this be hard-coded?
         let u8_type = context.new_type::<u8>();
         let u16_type = context.new_type::<u16>();
         let u32_type = context.new_type::<u32>();
         let u64_type = context.new_c_type(CType::ULongLong);
-        let u128_type = context.new_c_type(CType::UInt128t);
+        let u128_type = context.new_c_type(CType::UInt128t).get_aligned(8); // TODO: should this be hard-coded?
 
         let tls_model = to_gcc_tls_mode(tcx.sess.tls_model());