Merge pull request rust-lang#151 from willtunnels/build_malloc-fix

Build malloc fix

Author: TheDan64

src/builder.rs

@@ -12,7 +12,7 @@ use crate::basic_block::BasicBlock;
 use crate::values::{AggregateValue, AggregateValueEnum, AsValueRef, BasicValue, BasicValueEnum, PhiValue, FunctionValue, IntValue, PointerValue, VectorValue, InstructionValue, GlobalValue, IntMathValue, FloatMathValue, PointerMathValue, InstructionOpcode, CallSiteValue};
 #[llvm_versions(3.9..=latest)]
 use crate::values::StructValue;
-use crate::types::{AsTypeRef, BasicType, IntMathType, FloatMathType, PointerType, PointerMathType};
+use crate::types::{AsTypeRef, BasicType, BasicTypeEnum, IntMathType, FloatMathType, PointerType, PointerMathType};
 
 use std::ffi::CString;
 use std::marker::PhantomData;
@@ -348,25 +348,56 @@ impl<'ctx> Builder<'ctx> {
     }
 
     // TODOC: Heap allocation
-    pub fn build_malloc<T: BasicType<'ctx>>(&self, ty: T, name: &str) -> PointerValue<'ctx> {
+    pub fn build_malloc<T: BasicType<'ctx>>(&self, ty: T, name: &str) -> Result<PointerValue<'ctx>, &'static str> {
+        // LLVMBulidMalloc segfaults if ty is unsized
+        let is_sized = match ty.as_basic_type_enum() {
+            BasicTypeEnum::ArrayType(ty) => ty.is_sized(),
+            BasicTypeEnum::FloatType(ty) => ty.is_sized(),
+            BasicTypeEnum::IntType(ty) => ty.is_sized(),
+            BasicTypeEnum::PointerType(ty) => ty.is_sized(),
+            BasicTypeEnum::StructType(ty) => ty.is_sized(),
+            BasicTypeEnum::VectorType(ty) => ty.is_sized(),
+        };
+        if !is_sized {
+            return Err("Cannot build malloc call for an unsized type");
+        }
+
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
         let value = unsafe {
             LLVMBuildMalloc(self.builder, ty.as_type_ref(), c_string.as_ptr())
         };
 
-        PointerValue::new(value)
+        Ok(PointerValue::new(value))
     }
 
     // TODOC: Heap allocation
-    pub fn build_array_malloc<T: BasicType<'ctx>>(&self, ty: T, size: IntValue<'ctx>, name: &str) -> PointerValue<'ctx> {
+    pub fn build_array_malloc<T: BasicType<'ctx>>(
+        &self,
+        ty: T,
+        size: IntValue<'ctx>,
+        name: &str
+    ) -> Result<PointerValue<'ctx>, &'static str> {
+        // LLVMBulidArrayMalloc segfaults if ty is unsized
+        let is_sized = match ty.as_basic_type_enum() {
+            BasicTypeEnum::ArrayType(ty) => ty.is_sized(),
+            BasicTypeEnum::FloatType(ty) => ty.is_sized(),
+            BasicTypeEnum::IntType(ty) => ty.is_sized(),
+            BasicTypeEnum::PointerType(ty) => ty.is_sized(),
+            BasicTypeEnum::StructType(ty) => ty.is_sized(),
+            BasicTypeEnum::VectorType(ty) => ty.is_sized(),
+        };
+        if !is_sized {
+            return Err("Cannot build array malloc call for an unsized type");
+        }
+
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
         let value = unsafe {
             LLVMBuildArrayMalloc(self.builder, ty.as_type_ref(), size.as_value_ref(), c_string.as_ptr())
         };
 
-        PointerValue::new(value)
+        Ok(PointerValue::new(value))
     }
 
     // SubType: <P>(&self, ptr: PointerValue<P>) -> InstructionValue {

tests/all/test_values.rs

@@ -903,6 +903,7 @@ fn test_allocations() {
     let module = context.create_module("my_mod");
     let void_type = context.void_type();
     let i32_type = context.i32_type();
+    let unsized_type = context.opaque_struct_type("my_struct");
     let i32_three = i32_type.const_int(3, false);
     let fn_type = void_type.fn_type(&[], false);
     let fn_value = module.add_function("my_func", fn_type, None);
@@ -927,11 +928,21 @@ fn test_allocations() {
 
     let heap_ptr = builder.build_malloc(i32_type, "heap_ptr");
 
-    assert_eq!(*heap_ptr.get_type().print_to_string(), *CString::new("i32*").unwrap());
+    assert!(heap_ptr.is_ok());
+    assert_eq!(*heap_ptr.unwrap().get_type().print_to_string(), *CString::new("i32*").unwrap());
 
     let heap_array = builder.build_array_malloc(i32_type, i32_three, "heap_array");
 
-    assert_eq!(*heap_array.get_type().print_to_string(), *CString::new("i32*").unwrap());
+    assert!(heap_array.is_ok());
+    assert_eq!(*heap_array.unwrap().get_type().print_to_string(), *CString::new("i32*").unwrap());
+
+    let bad_malloc_res = builder.build_malloc(unsized_type, "");
+
+    assert!(bad_malloc_res.is_err());
+
+    let bad_array_malloc_res = builder.build_array_malloc(unsized_type, i32_three, "");
+
+    assert!(bad_array_malloc_res.is_err());
 }
 
 #[test]