Merge remote-tracking branch 'origin/trunk' into specialize-lowlevel

compiler/gen_dev/src/lib.rs

@@ -1,4 +1,4 @@
-#![warn(clippy::all, clippy::dbg_macro)]
+#![warn(clippy::dbg_macro)]
 // See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check.
 #![allow(clippy::large_enum_variant, clippy::upper_case_acronyms)]
 
@@ -214,7 +214,7 @@ where
                         }
                     }
 
-                    CallType::LowLevel { op: lowlevel } => {
+                    CallType::LowLevel { op: lowlevel, .. } => {
                         self.build_run_low_level(sym, lowlevel, arguments, layout)
                     }
                     x => Err(format!("the call type, {:?}, is not yet implemented", x)),

compiler/gen_dev/src/object_builder.rs

@@ -13,7 +13,9 @@ use roc_mono::ir::Proc;
 use roc_mono::layout::Layout;
 use target_lexicon::{Architecture as TargetArch, BinaryFormat as TargetBF, Triple};
 
-const VERSION: &str = env!("CARGO_PKG_VERSION");
+// This is used by some code below which is currently commented out.
+// See that code for more details!
+// const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 /// build_module is the high level builder/delegator.
 /// It takes the request to build a module and output the object file for the module.
@@ -41,6 +43,28 @@ pub fn build_module<'a>(
                 Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little),
             )
         }
+        Triple {
+            architecture: TargetArch::X86_64,
+            binary_format: TargetBF::Macho,
+            ..
+        } => {
+            let backend: Backend64Bit<
+                x86_64::X86_64GeneralReg,
+                x86_64::X86_64FloatReg,
+                x86_64::X86_64Assembler,
+                x86_64::X86_64SystemV,
+            > = Backend::new(env, target)?;
+            build_object(
+                env,
+                procedures,
+                backend,
+                Object::new(
+                    BinaryFormat::MachO,
+                    Architecture::X86_64,
+                    Endianness::Little,
+                ),
+            )
+        }
         Triple {
             architecture: TargetArch::Aarch64(_),
             binary_format: TargetBF::Elf,
@@ -72,12 +96,16 @@ fn build_object<'a, B: Backend<'a>>(
     mut output: Object,
 ) -> Result<Object, String> {
     let data_section = output.section_id(StandardSection::Data);
-    let comment = output.add_section(vec![], b"comment".to_vec(), SectionKind::OtherString);
+
+    /*
+    // Commented out because we couldn't figure out how to get it to work on mac - see https://github.com/rtfeldman/roc/pull/1323
+    let comment = output.add_section(vec![], b".comment".to_vec(), SectionKind::OtherString);
     output.append_section_data(
         comment,
         format!("\0roc dev backend version {} \0", VERSION).as_bytes(),
         1,
     );
+    */
 
     // Setup layout_ids for procedure calls.
     let mut layout_ids = roc_mono::layout::LayoutIds::default();
@@ -89,7 +117,7 @@ fn build_object<'a, B: Backend<'a>>(
 
         let section_id = output.add_section(
             output.segment_name(StandardSegment::Text).to_vec(),
-            format!(".text.{}", fn_name).as_bytes().to_vec(),
+            format!(".text.{:x}", sym.as_u64()).as_bytes().to_vec(),
             SectionKind::Text,
         );
 
@@ -182,7 +210,7 @@ fn build_object<'a, B: Backend<'a>>(
                             offset: offset + proc_offset,
                             size: 32,
                             kind: RelocationKind::PltRelative,
-                            encoding: RelocationEncoding::Generic,
+                            encoding: RelocationEncoding::X86Branch,
                             symbol: sym_id,
                             addend: -4,
                         }