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

compiler/gen/src/llvm/build.rs

@@ -88,11 +88,25 @@ fn add_intrinsics<'ctx>(ctx: &'ctx Context, module: &Module<'ctx>) {
         LLVM_FABS_F64,
         f64_type.fn_type(&[f64_type.into()], false),
     );
+
+    add_intrinsic(
+        module,
+        LLVM_SIN_F64,
+        f64_type.fn_type(&[f64_type.into()], false),
+    );
+
+    add_intrinsic(
+        module,
+        LLVM_COS_F64,
+        f64_type.fn_type(&[f64_type.into()], false),
+    );
 }
 
 static LLVM_SQRT_F64: &str = "llvm.sqrt.f64";
 static LLVM_LROUND_I64_F64: &str = "llvm.lround.i64.f64";
 static LLVM_FABS_F64: &str = "llvm.fabs.f64";
+static LLVM_SIN_F64: &str = "llvm.sin.f64";
+static LLVM_COS_F64: &str = "llvm.cos.f64";
 
 fn add_intrinsic<'ctx>(
     module: &Module<'ctx>,
@@ -422,7 +436,7 @@ pub fn build_expr<'a, 'ctx, 'env>(
             if elems.is_empty() {
                 let struct_type = collection(ctx, env.ptr_bytes);
 
-                // THe pointer should be null (aka zero) and the length should be zero,
+                // The pointer should be null (aka zero) and the length should be zero,
                 // so the whole struct should be a const_zero
                 BasicValueEnum::StructValue(struct_type.const_zero())
             } else {
@@ -1203,6 +1217,8 @@ fn call_with_args<'a, 'ctx, 'env>(
 
             BasicValueEnum::IntValue(bool_val)
         }
+        Symbol::FLOAT_SIN => call_intrinsic(LLVM_SIN_F64, env, args),
+        Symbol::FLOAT_COS => call_intrinsic(LLVM_COS_F64, env, args),
         Symbol::NUM_MUL => {
             debug_assert!(args.len() == 2);
 
@@ -1396,6 +1412,74 @@ fn call_with_args<'a, 'ctx, 'env>(
         Symbol::FLOAT_ROUND => call_intrinsic(LLVM_LROUND_I64_F64, env, args),
         Symbol::LIST_SET => list_set(parent, args, env, InPlace::Clone),
         Symbol::LIST_SET_IN_PLACE => list_set(parent, args, env, InPlace::InPlace),
+        Symbol::LIST_SINGLE => {
+            // List.single : a -> List a
+            debug_assert!(args.len() == 1);
+
+            let (elem, elem_layout) = args[0];
+
+            let builder = env.builder;
+            let ctx = env.context;
+
+            let elem_type = basic_type_from_layout(env.arena, ctx, elem_layout, env.ptr_bytes);
+            let elem_bytes = elem_layout.stack_size(env.ptr_bytes) as u64;
+
+            let ptr = {
+                let bytes_len = elem_bytes;
+                let len_type = env.ptr_int();
+                let len = len_type.const_int(bytes_len, false);
+
+                env.builder
+                    .build_array_malloc(elem_type, len, "create_list_ptr")
+                    .unwrap()
+
+                // TODO check if malloc returned null; if so, runtime error for OOM!
+            };
+
+            // Put the element into the list
+            let elem_ptr = unsafe {
+                builder.build_in_bounds_gep(
+                    ptr,
+                    &[ctx.i32_type().const_int(
+                        // 0 as in 0 index of our new list
+                        0 as u64, false,
+                    )],
+                    "index",
+                )
+            };
+
+            builder.build_store(elem_ptr, elem);
+
+            let ptr_bytes = env.ptr_bytes;
+            let int_type = ptr_int(ctx, ptr_bytes);
+            let ptr_as_int = builder.build_ptr_to_int(ptr, int_type, "list_cast_ptr");
+            let struct_type = collection(ctx, ptr_bytes);
+            let len = BasicValueEnum::IntValue(env.ptr_int().const_int(1, false));
+
+            let mut struct_val;
+
+            // Store the pointer
+            struct_val = builder
+                .build_insert_value(
+                    struct_type.get_undef(),
+                    ptr_as_int,
+                    Builtin::WRAPPER_PTR,
+                    "insert_ptr",
+                )
+                .unwrap();
+
+            // Store the length
+            struct_val = builder
+                .build_insert_value(struct_val, len, Builtin::WRAPPER_LEN, "insert_len")
+                .unwrap();
+
+            //
+            builder.build_bitcast(
+                struct_val.into_struct_value(),
+                collection(ctx, ptr_bytes),
+                "cast_collection",
+            )
+        }
         Symbol::INT_DIV_UNSAFE => {
             debug_assert!(args.len() == 2);