Implement integer cast for unsupported integer types

Author: antoyo

src/builder.rs

@@ -1053,8 +1053,35 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
             self.cx.context.new_cast(None, value, dest_typ)
         }
         else {
-            // FIXME: that's not working since we can cast from u8 to struct u128.
-            self.cx.context.new_bitcast(None, value, dest_typ)
+            let value_type = value.get_type();
+            let src_size = self.cx.int_type_size(value_type);
+            let src_element_size = self.cx.int_type_element_size(value_type);
+            let dest_size = self.cx.int_type_size(dest_typ);
+            let factor = (dest_size / src_size) as usize;
+            let array_type = self.context.new_array_type(None, value_type, factor as i32);
+
+            if src_size < dest_size {
+                // TODO: initialize to -1 if negative.
+                let mut values = vec![self.context.new_rvalue_zero(value_type); factor];
+                // TODO: take endianness into account.
+                values[factor - 1] = value;
+                let array_value = self.context.new_rvalue_from_array(None, array_type, &values);
+                self.cx.context.new_bitcast(None, array_value, dest_typ)
+            }
+            else {
+                let mut current_size = 0;
+                // TODO: take endianness into account.
+                let mut current_index = src_size / src_element_size - 1;
+                let mut values = vec![];
+                while current_size < dest_size {
+                    values.push(self.context.new_array_access(None, value, self.context.new_rvalue_from_int(self.int_type, current_index as i32)).to_rvalue());
+                    current_size += src_element_size;
+                    current_index -= 1;
+                }
+                let array_value = self.context.new_rvalue_from_array(None, array_type, &values);
+                // FIXME: that's not working since we can cast from u8 to struct u128.
+                self.cx.context.new_bitcast(None, array_value, dest_typ)
+            }
         }
     }
 

src/context.rs

@@ -38,6 +38,7 @@ pub struct FuncSig<'gcc> {
 
 pub struct IntType<'gcc> {
     bits: u8,
+    element_size: u8,
     typ: Type<'gcc>,
     signed: bool,
 }
@@ -79,6 +80,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
     pub sizet_type: Type<'gcc>,
 
     pub native_int_types: Vec<IntType<'gcc>>,
+    pub non_native_int_types: Vec<IntType<'gcc>>,
 
     pub float_type: Type<'gcc>,
     pub double_type: Type<'gcc>,
@@ -141,9 +143,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let u32_type = context.new_c_type(CType::UInt32t);
         let u64_type = context.new_c_type(CType::UInt64t);
 
-        let field1 = context.new_field(None, u64_type, "high");
-        let field2 = context.new_field(None, u64_type, "low");
-        let u128_type = context.new_struct_type(None, "u128", &[field1, field2]).as_type();
+        let u128_type = context.new_array_type(None, u64_type, 2);
         //let u128_type = context.new_c_type(CType::UInt128t).get_aligned(8); // TODO(antoyo): should the alignment be hard-coded?
 
         let tls_model = to_gcc_tls_mode(tcx.sess.tls_model());
@@ -158,52 +158,87 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let ulonglong_type = context.new_c_type(CType::ULongLong);
         let sizet_type = context.new_c_type(CType::SizeT);
 
+        let mut non_native_int_types = vec![];
+
+        non_native_int_types.push(IntType {
+            bits: 128,
+            element_size: 64,
+            signed: false,
+            typ: u128_type,
+        });
+
         let mut native_int_types = vec![];
 
         native_int_types.push(IntType {
             bits: 64,
+            element_size: 64,
             signed: false,
             typ: u64_type,
         });
         native_int_types.push(IntType {
             bits: 64,
+            element_size: 64,
             signed: true,
             typ: i64_type,
         });
 
         native_int_types.push(IntType {
             bits: 32,
+            element_size: 32,
             signed: false,
             typ: u32_type,
         });
         native_int_types.push(IntType {
             bits: 32,
+            element_size: 32,
             signed: true,
             typ: i32_type,
         });
 
         native_int_types.push(IntType {
             bits: 16,
+            element_size: 16,
             signed: false,
             typ: u16_type,
         });
         native_int_types.push(IntType {
             bits: 16,
+            element_size: 16,
             signed: true,
             typ: i16_type,
         });
 
         native_int_types.push(IntType {
             bits: 8,
+            element_size: 8,
             signed: false,
             typ: u8_type,
         });
         native_int_types.push(IntType {
             bits: 8,
+            element_size: 8,
             signed: true,
             typ: i8_type,
         });
 
+        let mut new_native_int_types = vec![];
+        let int_types = [isize_type, usize_type, int_type, uint_type, long_type, ulong_type, ulonglong_type, sizet_type];
+        for int_type in int_types {
+            for native_int_type in &native_int_types {
+                if int_type.is_compatible_with(native_int_type.typ) {
+                    new_native_int_types.push(IntType {
+                        bits: native_int_type.bits,
+                        element_size: native_int_type.element_size,
+                        signed: native_int_type.signed,
+                        typ: int_type,
+                    });
+                    break;
+                }
+            }
+        }
+
+        native_int_types.extend(new_native_int_types);
+
         // TODO(antoyo): only have those assertions on x86_64.
         assert_eq!(isize_type.get_size(), i64_type.get_size());
         assert_eq!(usize_type.get_size(), u64_type.get_size());
@@ -257,6 +292,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             sizet_type,
 
             native_int_types,
+            non_native_int_types,
 
             float_type,
             double_type,
@@ -290,13 +326,43 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
 
     pub fn supports_native_int_type(&self, typ: Type<'gcc>) -> bool {
         for native_type in &self.native_int_types {
-            if native_type.typ == typ {
+            if native_type.typ.is_compatible_with(typ) {
                 return true;
             }
         }
         false
     }
 
+    pub fn int_type_size(&self, typ: Type<'gcc>) -> u8 {
+        for native_type in &self.native_int_types {
+            if native_type.typ.is_compatible_with(typ) {
+                return native_type.bits;
+            }
+        }
+        for non_native_type in &self.non_native_int_types {
+            if non_native_type.typ.is_compatible_with(typ) {
+                return non_native_type.bits;
+            }
+        }
+
+        panic!("{:?} not an integer type", typ);
+    }
+
+    pub fn int_type_element_size(&self, typ: Type<'gcc>) -> u8 {
+        for native_type in &self.native_int_types {
+            if native_type.typ.is_compatible_with(typ) {
+                return native_type.bits;
+            }
+        }
+        for non_native_type in &self.non_native_int_types {
+            if non_native_type.typ.is_compatible_with(typ) {
+                return non_native_type.bits;
+            }
+        }
+
+        panic!("{:?} not an integer type", typ);
+    }
+
     pub fn sess(&self) -> &Session {
         &self.tcx.sess
     }