Merge pull request #5577 from roc-lang/linux64

Update `roc build --target` to add more triples

.github/workflows/nightly_linux_x86_64.yml

@@ -7,7 +7,7 @@ name: Nightly Release Linux x86_64
 
 jobs:
   build:
-    name: Rust tests, build and package nightly release
+    name: build and package nightly release
     runs-on: [self-hosted, i7-6700K]
     timeout-minutes: 90
     steps:

crates/cli/src/lib.rs

@@ -20,6 +20,7 @@ use roc_load::{ExpectMetadata, Threading};
 use roc_mono::ir::OptLevel;
 use roc_packaging::cache::RocCacheDir;
 use roc_packaging::tarball::Compression;
+use roc_target::Target;
 use std::env;
 use std::ffi::{CString, OsStr, OsString};
 use std::io;
@@ -28,11 +29,8 @@ use std::os::raw::{c_char, c_int};
 use std::path::{Path, PathBuf};
 use std::process;
 use std::time::Instant;
-use strum::{EnumIter, IntoEnumIterator, IntoStaticStr};
-use target_lexicon::BinaryFormat;
-use target_lexicon::{
-    Architecture, Environment, OperatingSystem, Triple, Vendor, X86_32Architecture,
-};
+use strum::IntoEnumIterator;
+use target_lexicon::{Architecture, Triple};
 #[cfg(not(target_os = "linux"))]
 use tempfile::TempDir;
 
@@ -1269,83 +1267,3 @@ fn run_wasm<I: Iterator<Item = S>, S: AsRef<[u8]>>(wasm_path: &std::path::Path,
 fn run_wasm<I: Iterator<Item = S>, S: AsRef<[u8]>>(_wasm_path: &std::path::Path, _args: I) {
     println!("Running wasm files is not supported on this target.");
 }
-
-#[derive(Debug, Copy, Clone, EnumIter, IntoStaticStr, PartialEq, Eq, Default)]
-pub enum Target {
-    #[strum(serialize = "system")]
-    #[default]
-    System,
-    #[strum(serialize = "linux32")]
-    Linux32,
-    #[strum(serialize = "linux64")]
-    Linux64,
-    #[strum(serialize = "windows64")]
-    Windows64,
-    #[strum(serialize = "wasm32")]
-    Wasm32,
-}
-
-impl Target {
-    pub fn to_triple(self) -> Triple {
-        use Target::*;
-
-        match self {
-            System => Triple::host(),
-            Linux32 => Triple {
-                architecture: Architecture::X86_32(X86_32Architecture::I386),
-                vendor: Vendor::Unknown,
-                operating_system: OperatingSystem::Linux,
-                environment: Environment::Musl,
-                binary_format: BinaryFormat::Elf,
-            },
-            Linux64 => Triple {
-                architecture: Architecture::X86_64,
-                vendor: Vendor::Unknown,
-                operating_system: OperatingSystem::Linux,
-                environment: Environment::Musl,
-                binary_format: BinaryFormat::Elf,
-            },
-            Windows64 => Triple {
-                architecture: Architecture::X86_64,
-                vendor: Vendor::Unknown,
-                operating_system: OperatingSystem::Windows,
-                environment: Environment::Gnu,
-                binary_format: BinaryFormat::Coff,
-            },
-            Wasm32 => Triple {
-                architecture: Architecture::Wasm32,
-                vendor: Vendor::Unknown,
-                operating_system: OperatingSystem::Wasi,
-                environment: Environment::Unknown,
-                binary_format: BinaryFormat::Wasm,
-            },
-        }
-    }
-}
-
-impl From<&Target> for Triple {
-    fn from(target: &Target) -> Self {
-        target.to_triple()
-    }
-}
-
-impl std::fmt::Display for Target {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{}", Into::<&'static str>::into(self))
-    }
-}
-
-impl std::str::FromStr for Target {
-    type Err = String;
-
-    fn from_str(string: &str) -> Result<Self, Self::Err> {
-        match string {
-            "system" => Ok(Target::System),
-            "linux32" => Ok(Target::Linux32),
-            "linux64" => Ok(Target::Linux64),
-            "windows64" => Ok(Target::Windows64),
-            "wasm32" => Ok(Target::Wasm32),
-            _ => Err(format!("Roc does not know how to compile to {string}")),
-        }
-    }
-}

crates/cli/src/main.rs

@@ -2,17 +2,18 @@
 use roc_build::link::LinkType;
 use roc_build::program::{check_file, CodeGenBackend};
 use roc_cli::{
-    build_app, format, test, BuildConfig, FormatMode, Target, CMD_BUILD, CMD_CHECK, CMD_DEV,
-    CMD_DOCS, CMD_EDIT, CMD_FORMAT, CMD_GEN_STUB_LIB, CMD_GLUE, CMD_REPL, CMD_RUN, CMD_TEST,
-    CMD_VERSION, DIRECTORY_OR_FILES, FLAG_CHECK, FLAG_DEV, FLAG_LIB, FLAG_NO_LINK, FLAG_TARGET,
-    FLAG_TIME, GLUE_DIR, GLUE_SPEC, ROC_FILE,
+    build_app, format, test, BuildConfig, FormatMode, CMD_BUILD, CMD_CHECK, CMD_DEV, CMD_DOCS,
+    CMD_EDIT, CMD_FORMAT, CMD_GEN_STUB_LIB, CMD_GLUE, CMD_REPL, CMD_RUN, CMD_TEST, CMD_VERSION,
+    DIRECTORY_OR_FILES, FLAG_CHECK, FLAG_DEV, FLAG_LIB, FLAG_NO_LINK, FLAG_TARGET, FLAG_TIME,
+    GLUE_DIR, GLUE_SPEC, ROC_FILE,
 };
 use roc_docs::generate_docs_html;
 use roc_error_macros::user_error;
 use roc_gen_dev::AssemblyBackendMode;
 use roc_gen_llvm::llvm::build::LlvmBackendMode;
 use roc_load::{LoadingProblem, Threading};
 use roc_packaging::cache::{self, RocCacheDir};
+use roc_target::Target;
 use std::fs::{self, FileType};
 use std::io;
 use std::path::{Path, PathBuf};

crates/compiler/build/src/target.rs

@@ -149,7 +149,14 @@ pub fn target_machine(
 
     init_arch(target);
 
-    // workaround for issue:
+    // We used to have a problem that LLVM 12 would not compile our programs without a large code model.
+    // The reason was not totally clear to us, but one guess is a few special-cases in
+    //   llvm/lib/Target/AArch64/AArch64ISelLowering.cpp (instructions)
+    //   llvm/lib/Target/AArch64/AArch64Subtarget.cpp (GoT tables)
+    // Revisit when upgrading to LLVM 13.
+    //
+    // Most recently, we seem to only see this problem on macOS ARM64; removing this
+    // failed macOS CI here: https://github.com/roc-lang/roc/pull/5644
     #[cfg(all(target_arch = "aarch64", target_os = "macos"))]
     let code_model = CodeModel::Large;
 

crates/compiler/builtins/bitcode/bc/build.rs

@@ -35,6 +35,7 @@ fn main() {
 
     generate_bc_file(&bitcode_path, "ir-i386", "builtins-i386");
     generate_bc_file(&bitcode_path, "ir-x86_64", "builtins-x86_64");
+    generate_bc_file(&bitcode_path, "ir-aarch64", "builtins-aarch64");
     generate_bc_file(
         &bitcode_path,
         "ir-windows-x86_64",

crates/compiler/builtins/bitcode/build.zig

@@ -25,18 +25,19 @@ pub fn build(b: *Builder) void {
     const host_target = b.standardTargetOptions(.{
         .default_target = CrossTarget{
             .cpu_model = .baseline,
-            // TODO allow for native target for maximum speed
         },
     });
     const linux32_target = makeLinux32Target();
-    const linux64_target = makeLinux64Target();
+    const linux_x64_target = makeLinuxX64Target();
+    const linux_aarch64_target = makeLinuxAarch64Target();
     const windows64_target = makeWindows64Target();
     const wasm32_target = makeWasm32Target();
 
     // LLVM IR
     generateLlvmIrFile(b, mode, host_target, main_path, "ir", "builtins-host");
     generateLlvmIrFile(b, mode, linux32_target, main_path, "ir-i386", "builtins-i386");
-    generateLlvmIrFile(b, mode, linux64_target, main_path, "ir-x86_64", "builtins-x86_64");
+    generateLlvmIrFile(b, mode, linux_x64_target, main_path, "ir-x86_64", "builtins-x86_64");
+    generateLlvmIrFile(b, mode, linux_aarch64_target, main_path, "ir-aarch64", "builtins-aarch64");
     generateLlvmIrFile(b, mode, windows64_target, main_path, "ir-windows-x86_64", "builtins-windows-x86_64");
     generateLlvmIrFile(b, mode, wasm32_target, main_path, "ir-wasm32", "builtins-wasm32");
 
@@ -89,6 +90,7 @@ fn generateObjectFile(
     obj.strip = true;
     obj.target = target;
     obj.link_function_sections = true;
+    obj.force_pic = true;
     const obj_step = b.step(step_name, "Build object file for linking");
     obj_step.dependOn(&obj.step);
 }
@@ -103,7 +105,17 @@ fn makeLinux32Target() CrossTarget {
     return target;
 }
 
-fn makeLinux64Target() CrossTarget {
+fn makeLinuxAarch64Target() CrossTarget {
+    var target = CrossTarget.parse(.{}) catch unreachable;
+
+    target.cpu_arch = std.Target.Cpu.Arch.aarch64;
+    target.os_tag = std.Target.Os.Tag.linux;
+    target.abi = std.Target.Abi.musl;
+
+    return target;
+}
+
+fn makeLinuxX64Target() CrossTarget {
     var target = CrossTarget.parse(.{}) catch unreachable;
 
     target.cpu_arch = std.Target.Cpu.Arch.x86_64;

crates/compiler/gen_llvm/src/llvm/build.rs

@@ -51,7 +51,7 @@ use roc_std::RocDec;
 use roc_target::{PtrWidth, TargetInfo};
 use std::convert::TryInto;
 use std::path::Path;
-use target_lexicon::{Architecture, OperatingSystem, Triple};
+use target_lexicon::{Aarch64Architecture, Architecture, OperatingSystem, Triple};
 
 use super::convert::{struct_type_from_union_layout, RocUnion};
 use super::intrinsics::{
@@ -488,6 +488,13 @@ pub fn module_from_builtins<'ctx>(
             } => {
                 include_bytes!("../../../builtins/bitcode/builtins-x86_64.bc")
             }
+            Triple {
+                architecture: Architecture::Aarch64(Aarch64Architecture::Aarch64),
+                operating_system: OperatingSystem::Linux,
+                ..
+            } => {
+                include_bytes!("../../../builtins/bitcode/builtins-aarch64.bc")
+            }
             Triple {
                 architecture: Architecture::X86_64,
                 operating_system: OperatingSystem::Windows,