First pass at test_emit

compiler/gen/tests/gen_tags.rs

@@ -27,6 +27,10 @@ mod gen_tags {
     use roc_mono::layout::Layout;
     use roc_types::subs::Subs;
 
+    use inkwell::targets::{
+        CodeModel, FileType, InitializationConfig, RelocMode, Target, TargetMachine, TargetTriple,
+    };
+
     #[test]
     fn applied_tag_nothing() {
         assert_evals_to!(
@@ -621,4 +625,179 @@ mod gen_tags {
             i64
         );
     }
+
+    #[test]
+    fn test_emit() {
+        let src = "42";
+
+        // Build the expr
+        let arena = Bump::new();
+        let (loc_expr, _output, _problems, subs, var, constraint, home, interns) = uniq_expr(src);
+
+        let mut unify_problems = Vec::new();
+        let (content, mut subs) = infer_expr(subs, &mut unify_problems, &constraint, var);
+
+        let context = Context::create();
+        let module = context.create_module("app");
+        let builder = context.create_builder();
+        let fpm = PassManager::create(&module);
+
+        roc_gen::llvm::build::add_passes(&fpm);
+
+        fpm.initialize();
+
+        // Compute main_fn_type before moving subs to Env
+        let layout = Layout::from_content(&arena, content, &subs, crate::helpers::eval::POINTER_SIZE)
+    .unwrap_or_else(|err| panic!("Code gen error in test: could not convert to layout. Err was {:?} and Subs were {:?}", err, subs));
+
+        let execution_engine = module
+            .create_jit_execution_engine(OptimizationLevel::None)
+            .expect("Error creating JIT execution engine for test");
+
+        let ptr_bytes = execution_engine
+            .get_target_data()
+            .get_pointer_byte_size(None);
+        let main_fn_type =
+            basic_type_from_layout(&arena, &context, &layout, ptr_bytes).fn_type(&[], false);
+        let main_fn_name = "$Test.main";
+
+        // Compile and add all the Procs before adding main
+        let mut env = roc_gen::llvm::build::Env {
+            arena: &arena,
+            builder: &builder,
+            context: &context,
+            interns,
+            module: arena.alloc(module),
+            ptr_bytes,
+        };
+        let mut procs = Procs::default();
+        let mut ident_ids = env.interns.all_ident_ids.remove(&home).unwrap();
+
+        // Populate Procs and get the low-level Expr from the canonical Expr
+        let main_body = Expr::new(
+            &arena,
+            &mut subs,
+            loc_expr.value,
+            &mut procs,
+            home,
+            &mut ident_ids,
+            crate::helpers::eval::POINTER_SIZE,
+        );
+
+        // Put this module's ident_ids back in the interns, so we can use them in Env.
+        env.interns.all_ident_ids.insert(home, ident_ids);
+
+        let mut headers = Vec::with_capacity(procs.len());
+
+        // Add all the Proc headers to the module.
+        // We have to do this in a separate pass first,
+        // because their bodies may reference each other.
+        for (symbol, opt_proc) in procs.as_map().into_iter() {
+            if let Some(proc) = opt_proc {
+                let (fn_val, arg_basic_types) = build_proc_header(&env, symbol, &proc);
+
+                headers.push((proc, fn_val, arg_basic_types));
+            }
+        }
+
+        // Build each proc using its header info.
+        for (proc, fn_val, arg_basic_types) in headers {
+            // NOTE: This is here to be uncommented in case verification fails.
+            // (This approach means we don't have to defensively clone name here.)
+            //
+            // println!("\n\nBuilding and then verifying function {}\n\n", name);
+            build_proc(&env, proc, &procs, fn_val, arg_basic_types);
+
+            if fn_val.verify(true) {
+                fpm.run_on(&fn_val);
+            } else {
+                // NOTE: If this fails, uncomment the above println to debug.
+                panic!("Non-main function failed LLVM verification. Uncomment the above println to debug!");
+            }
+        }
+
+        // Add main to the module.
+        let main_fn = env.module.add_function(main_fn_name, main_fn_type, None);
+
+        main_fn.set_call_conventions(crate::helpers::eval::MAIN_CALLING_CONVENTION);
+
+        // Add main's body
+        let basic_block = context.append_basic_block(main_fn, "entry");
+
+        builder.position_at_end(basic_block);
+
+        let ret = roc_gen::llvm::build::build_expr(
+            &env,
+            &ImMap::default(),
+            main_fn,
+            &main_body,
+            &mut Procs::default(),
+        );
+
+        builder.build_return(Some(&ret));
+
+        // Uncomment this to see the module's un-optimized LLVM instruction output:
+        // env.module.print_to_stderr();
+
+        if main_fn.verify(true) {
+            fpm.run_on(&main_fn);
+        } else {
+            panic!("Function {} failed LLVM verification.", main_fn_name);
+        }
+
+        // Verify the module
+        if let Err(errors) = env.module.verify() {
+            panic!("Errors defining module: {:?}", errors);
+        }
+
+        // Uncomment this to see the module's optimized LLVM instruction output:
+        // env.module.print_to_stderr();
+
+        // Emit
+        Target::initialize_x86(&InitializationConfig::default());
+
+        let opt = OptimizationLevel::Default;
+        let reloc = RelocMode::Default;
+        let model = CodeModel::Default;
+        let target = Target::from_name("x86-64").unwrap();
+        let target_machine = target
+            .create_target_machine(
+                &TargetTriple::create("x86_64-pc-linux-gnu"),
+                "x86-64",
+                "+avx2",
+                opt,
+                reloc,
+                model,
+            )
+            .unwrap();
+
+        let buffer = target_machine
+            .write_to_memory_buffer(&env.module, FileType::Assembly)
+            .unwrap();
+        let buffer_str = std::str::from_utf8(buffer.as_slice()).unwrap();
+
+        assert_eq!(
+            buffer_str.trim(),
+            indoc!(
+                r#"
+.text
+	.file	"app"
+	.globl	$Test.main
+	.p2align	4, 0x90
+	.type	$Test.main,@function
+$Test.main:
+	.cfi_startproc
+	movl	$42, %eax
+	retq
+.Lfunc_end0:
+	.size	$Test.main, .Lfunc_end0-($Test.main)
+	.cfi_endproc
+
+
+	.section	".note.GNU-stack","",@progbits
+                "#
+            )
+            .trim()
+        );
+    }
 }