WIP: fix endianness of non-native 128-bit integers

.github/workflows/m68k.yml

@@ -15,6 +15,8 @@ permissions:
 env:
   # Enable backtraces for easier debugging
   RUST_BACKTRACE: 1
+  # TODO: remove when confish.sh is removed.
+  OVERWRITE_TARGET_TRIPLE: m68k-unknown-linux-gnu
 
 jobs:
   build:
@@ -122,6 +124,7 @@ jobs:
         }
         EOF
         mkdir vm
+        pwd # TODO: remove
         sudo mount debian-m68k.img vm
         m68k-unknown-linux-gnu-gcc main.c -o main
         sudo cp main vm/home/main
@@ -140,20 +143,16 @@ jobs:
 
     - name: Build
       run: |
-        ./y.sh prepare --only-libcore
-        # TODO: move into prepare command under a flag --cross-patches?
-        pushd build_sysroot/sysroot_src
-        git am ../../cross_patches/*.patch
-        popd
-        ./build.sh
-        cargo test
+        ./y.sh prepare --only-libcore --cross
+        ./y.sh build --target-triple m68k-unknown-linux-gnu
+        CG_GCC_TEST_TARGET=m68k-unknown-linux-gnu cargo test
         ./clean_all.sh
 
     - name: Prepare dependencies
       run: |
         git config --global user.email "[email protected]"
         git config --global user.name "User"
-        ./y.sh prepare
+        ./y.sh prepare --cross
 
     # Compile is a separate step, as the actions-rs/cargo action supports error annotations
     - name: Compile

build_sysroot/build_sysroot.sh

@@ -23,7 +23,9 @@ if [[ "$1" == "--release" ]]; then
 else
     sysroot_channel='debug'
     # TODO: add flags to simplify the case for cross-compilation.
-    AR="m68k-unknown-linux-gnu-ar" CC="m68k-unknown-linux-gnu-gcc" cargo build --target $TARGET_TRIPLE
+    # TODO: or remove them completely if not needed.
+    #AR="m68k-unknown-linux-gnu-ar" CC="m68k-unknown-linux-gnu-gcc"
+    cargo build --target $TARGET_TRIPLE
 fi
 
 # Copy files to sysroot

build_system/src/build.rs

@@ -11,7 +11,7 @@ use std::path::Path;
 struct BuildArg {
     codegen_release_channel: bool,
     sysroot_release_channel: bool,
-    features: Vec<String>,
+    flags: Vec<String>,
     gcc_path: String,
 }
 
@@ -30,12 +30,12 @@ impl BuildArg {
                 "--release" => build_arg.codegen_release_channel = true,
                 "--release-sysroot" => build_arg.sysroot_release_channel = true,
                 "--no-default-features" => {
-                    build_arg.features.push("--no-default-features".to_string());
+                    build_arg.flags.push("--no-default-features".to_string());
                 }
                 "--features" => {
                     if let Some(arg) = args.next() {
-                        build_arg.features.push("--features".to_string());
-                        build_arg.features.push(arg.as_str().into());
+                        build_arg.flags.push("--features".to_string());
+                        build_arg.flags.push(arg.as_str().into());
                     } else {
                         return Err(
                             "Expected a value after `--features`, found nothing".to_string()
@@ -46,6 +46,15 @@ impl BuildArg {
                     Self::usage();
                     return Ok(None);
                 }
+                "--target-triple" => {
+                    if args.next().is_some() {
+                        // Handled in config.rs.
+                    } else {
+                        return Err(
+                            "Expected a value after `--target-triple`, found nothing".to_string()
+                        );
+                    }
+                }
                 arg => return Err(format!("Unknown argument `{}`", arg)),
             }
         }
@@ -61,6 +70,7 @@ impl BuildArg {
     --release-sysroot      : Build sysroot in release mode
     --no-default-features  : Add `--no-default-features` flag
     --features [arg]       : Add a new feature [arg]
+    --target-triple [arg]  : Set the target triple to [arg]
     --help                 : Show this help
 "#
         )
@@ -147,8 +157,6 @@ fn build_sysroot(
                 &"build",
                 &"--target",
                 &target_triple,
-                &"--features",
-                &"compiler_builtins/c",
             ],
             None,
             Some(env),
@@ -196,9 +204,9 @@ fn build_codegen(args: &BuildArg) -> Result<(), String> {
     } else {
         env.insert("CHANNEL".to_string(), "debug".to_string());
     }
-    let ref_features = args.features.iter().map(|s| s.as_str()).collect::<Vec<_>>();
-    for feature in &ref_features {
-        command.push(feature);
+    let flags = args.flags.iter().map(|s| s.as_str()).collect::<Vec<_>>();
+    for flag in &flags {
+        command.push(flag);
     }
     run_command_with_output_and_env(&command, None, Some(&env))?;
 

build_system/src/config.rs

@@ -30,15 +30,32 @@ pub fn set_config(
     };
     let host_triple = get_rustc_host_triple()?;
     let mut linker = None;
-    let mut target_triple = host_triple.as_str();
+    let mut target_triple = host_triple.clone();
     let mut run_wrapper = None;
-    // FIXME: handle this with a command line flag?
-    // let mut target_triple = "m68k-unknown-linux-gnu";
+
+    // We skip binary name and the command.
+    let mut args = std::env::args().skip(2);
+
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "--target-triple" => {
+                if let Some(arg) = args.next() {
+                    target_triple = arg;
+                } else {
+                    return Err(
+                        "Expected a value after `--target-triple`, found nothing".to_string()
+                    );
+                }
+            },
+            _ => (),
+        }
+    }
 
     if host_triple != target_triple {
         if target_triple == "m68k-unknown-linux-gnu" {
-            target_triple = "mips-unknown-linux-gnu";
-            linker = Some("-Clinker=m68k-linux-gcc");
+            //target_triple = "mips-unknown-linux-gnu";
+            // TODO: only add "-gcc" to the target triple instead of having these conditions?
+            linker = Some("-Clinker=m68k-unknown-linux-gnu-gcc");
         } else if target_triple == "aarch64-unknown-linux-gnu" {
             // We are cross-compiling for aarch64. Use the correct linker and run tests in qemu.
             linker = Some("-Clinker=aarch64-linux-gnu-gcc");

config.sh

@@ -20,15 +20,13 @@ else
 fi
 
 HOST_TRIPLE=$(rustc -vV | grep host | cut -d: -f2 | tr -d " ")
-#TARGET_TRIPLE=$HOST_TRIPLE
-TARGET_TRIPLE="m68k-unknown-linux-gnu"
+# TODO: remove $OVERWRITE_TARGET_TRIPLE when config.sh is removed.
+TARGET_TRIPLE="${OVERWRITE_TARGET_TRIPLE:-$HOST_TRIPLE}"
 
 linker=''
 RUN_WRAPPER=''
 if [[ "$HOST_TRIPLE" != "$TARGET_TRIPLE" ]]; then
    if [[ "$TARGET_TRIPLE" == "m68k-unknown-linux-gnu" ]]; then
-       #TARGET_TRIPLE="mips-unknown-linux-gnu"
-       # TODO: figure a better way for the user to do that automatically for any target.
        linker='-Clinker=m68k-unknown-linux-gnu-gcc'
    elif [[ "$TARGET_TRIPLE" == "aarch64-unknown-linux-gnu" ]]; then
       # We are cross-compiling for aarch64. Use the correct linker and run tests in qemu.
@@ -61,5 +59,6 @@ export DYLD_LIBRARY_PATH=$LD_LIBRARY_PATH
 # NOTE: To avoid the -fno-inline errors, use /opt/gcc/bin/gcc instead of cc.
 # To do so, add a symlink for cc to /opt/gcc/bin/gcc in our PATH.
 # Another option would be to add the following Rust flag: -Clinker=/opt/gcc/bin/gcc
+# TODO: Revert to /opt/gcc/bin
+# TODO: seems like this is necessary to build locally.
 export PATH="/opt/m68k-unknown-linux-gnu/bin:$PATH"
-#export TARGET=$TARGET_TRIPLE

src/base.rs

@@ -98,8 +98,9 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol, target_info: Lock
             .map(|string| &string[1..])
             .collect();
 
-        // TODO(antoyo): only set on x86 platforms.
-        //context.add_command_line_option("-masm=intel");
+        if tcx.sess.target.arch == "x86" || tcx.sess.target.arch == "x86_64" {
+            context.add_command_line_option("-masm=intel");
+        }
 
         if !disabled_features.contains("avx") && tcx.sess.target.arch == "x86_64" {
             // NOTE: we always enable AVX because the equivalent of llvm.x86.sse2.cmp.pd in GCC for

src/context.rs

@@ -20,6 +20,7 @@ use rustc_target::abi::{call::FnAbi, HasDataLayout, PointeeInfo, Size, TargetDat
 use rustc_target::spec::{HasTargetSpec, Target, TlsModel};
 
 use crate::callee::get_fn;
+use crate::common::SignType;
 
 #[derive(Clone)]
 pub struct FuncSig<'gcc> {
@@ -165,8 +166,15 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
                 (i128_type, u128_type)
             }
             else {
-                let i128_type = context.new_array_type(None, i64_type, 2);
-                let u128_type = context.new_array_type(None, u64_type, 2);
+                let layout = tcx.layout_of(ParamEnv::reveal_all().and(tcx.types.i128)).unwrap();
+                let i128_align = layout.align.abi.bytes();
+                let layout = tcx.layout_of(ParamEnv::reveal_all().and(tcx.types.u128)).unwrap();
+                let u128_align = layout.align.abi.bytes();
+
+                // TODO(antoyo): re-enable the alignment when libgccjit fixed the issue in
+                // gcc_jit_context_new_array_constructor (it should not use reinterpret_cast).
+                let i128_type = context.new_array_type(None, i64_type, 2)/*.get_aligned(i128_align)*/;
+                let u128_type = context.new_array_type(None, u64_type, 2)/*.get_aligned(u128_align)*/;
                 (i128_type, u128_type)
             };
 
@@ -187,8 +195,8 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let ulonglong_type = context.new_c_type(CType::ULongLong);
         let sizet_type = context.new_c_type(CType::SizeT);
 
-        let isize_type = context.new_c_type(CType::Int);
-        let usize_type = context.new_c_type(CType::UInt);
+        let usize_type = sizet_type;
+        let isize_type = usize_type;
         let bool_type = context.new_type::<bool>();
 
         // TODO(antoyo): only have those assertions on x86_64.
@@ -212,7 +220,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             functions.insert(builtin.to_string(), context.get_builtin_function(builtin));
         }
 
-        Self {
+        let mut cx = Self {
             check_overflow,
             codegen_unit,
             context,
@@ -274,7 +282,10 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             pointee_infos: Default::default(),
             structs_as_pointer: Default::default(),
             cleanup_blocks: Default::default(),
-        }
+        };
+        // TODO(antoyo): instead of doing this, add SsizeT to libgccjit.
+        cx.isize_type = usize_type.to_signed(&cx);
+        cx
     }
 
     pub fn rvalue_as_function(&self, value: RValue<'gcc>) -> Function<'gcc> {