Use more of the new reflection API

Author: antoyo

gcc_path

@@ -1 +1 @@
-/tmp/gcc-build/build/gcc
+/home/bouanto/Ordinateur/Programmation/Projets/gcc-build/build/gcc

src/abi.rs

@@ -162,10 +162,6 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     fn ptr_to_gcc_type(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc> {
         let (return_type, params, variadic) = self.gcc_type(cx);
         let pointer_type = cx.context.new_function_pointer_type(None, return_type, &params, variadic);
-        cx.function_type_param_return_value.borrow_mut().insert(pointer_type, FuncSig {
-            params,
-            return_type,
-        });
         pointer_type
     }
 

src/builder.rs

@@ -154,12 +154,9 @@ impl<'gcc, 'tcx> Builder<'_, 'gcc, 'tcx> {
 
         let mut all_args_match = true;
         let mut param_types = vec![];
-        let func_types = self.cx.function_type_param_return_value.borrow();
-        let ptr: *mut usize = unsafe { std::mem::transmute(func.get_type()) };
-        let func_sig = func_types.get(&func.get_type())
-            .unwrap_or_else(|| panic!("No function_type_param_return_value for {:?}", func.get_type()));
-        for (index, arg) in args.iter().enumerate().take(func_sig.params.len()) {
-            let param = func_sig.params[index];
+        let gcc_func: Function<'gcc> = self.cx.rvalue_as_function(func);
+        for (index, arg) in args.iter().enumerate().take(gcc_func.get_param_count()) {
+            let param = gcc_func.get_param(index as i32).to_rvalue().get_type();
             if param != arg.get_type() {
                 all_args_match = false;
             }
@@ -265,9 +262,8 @@ impl<'gcc, 'tcx> Builder<'_, 'gcc, 'tcx> {
 
         // gccjit requires to use the result of functions, even when it's not used.
         // That's why we assign the result to a local or call add_eval().
-        let return_type = self.function_type_param_return_value.borrow().get(&func.get_type())
-            .map(|func_sig| func_sig.return_type)
-            .unwrap_or_else(|| panic!("No return type for {:?}", func));
+        let gcc_func: Function<'gcc> = self.cx.rvalue_as_function(func);
+        let return_type = gcc_func.get_return_type();
         let current_block = self.current_block.borrow().expect("block");
         let void_type = self.context.new_type::<()>();
         let current_func = current_block.get_function();
@@ -764,10 +760,6 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         else if let Some(fields) = type_fields {
             self.fields.borrow_mut().insert(aligned_type, fields);
         }
-        else if self.function_type_param_return_value.borrow().contains_key(&ty) {
-            let func_sig = self.function_type_param_return_value.borrow().get(&ty).expect("function sig").clone();
-            self.function_type_param_return_value.borrow_mut().insert(aligned_type, func_sig);
-        }
 
         // TODO: It might be better to return a LValue, but fixing the rustc API is non-trivial.
         self.current_func().new_local(None, aligned_type, "stack_var").get_address(None)

src/common.rs

@@ -336,70 +336,70 @@ pub trait TypeReflection<'gcc, 'tcx>  {
 
 impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
     fn is_uchar(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u8_type
+        self.unqualified() == cx.u8_type
     }
 
     fn is_ushort(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u16_type
+        self.unqualified() == cx.u16_type
     }
 
     fn is_uint(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.uint_type
+        self.unqualified() == cx.uint_type
     }
 
     fn is_ulong(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.ulong_type
+        self.unqualified() == cx.ulong_type
     }
 
     fn is_ulonglong(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.ulonglong_type
+        self.unqualified() == cx.ulonglong_type
     }
 
     fn is_i8(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.i8_type
+        self.unqualified() == cx.i8_type
     }
 
     fn is_u8(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u8_type
+        self.unqualified() == cx.u8_type
     }
 
     fn is_i16(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.i16_type
+        self.unqualified() == cx.i16_type
     }
 
     fn is_u16(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u16_type
+        self.unqualified() == cx.u16_type
     }
 
     fn is_i32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.i32_type
+        self.unqualified() == cx.i32_type
     }
 
     fn is_u32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u32_type
+        self.unqualified() == cx.u32_type
     }
 
     fn is_i64(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.i64_type
+        self.unqualified() == cx.i64_type
     }
 
     fn is_u64(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u64_type
+        self.unqualified() == cx.u64_type
     }
 
     fn is_i128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.i128_type
+        self.unqualified() == cx.i128_type
     }
 
     fn is_u128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.u128_type
+        self.unqualified() == cx.u128_type
     }
 
     fn is_f32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.context.new_type::<f32>()
+        self.unqualified() == cx.context.new_type::<f32>()
     }
 
     fn is_f64(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
-        self.get_original() == cx.context.new_type::<f64>()
+        self.unqualified() == cx.context.new_type::<f64>()
     }
 }

src/context.rs

@@ -49,7 +49,6 @@ pub struct CodegenCx<'gcc, 'tcx> {
     // TODO: First set it to a dummy block to avoid using Option?
     pub current_block: RefCell<Option<Block<'gcc>>>,
     pub current_func: RefCell<Option<Function<'gcc>>>,
-    pub function_type_param_return_value: RefCell<FxHashMap<Type<'gcc>, FuncSig<'gcc>>>,
     pub normal_function_addresses: RefCell<FxHashSet<RValue<'gcc>>>,
 
     /// The function where globals are initialized.
@@ -177,7 +176,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             context,
             current_block: RefCell::new(None),
             current_func: RefCell::new(None),
-            function_type_param_return_value: Default::default(),
             normal_function_addresses: Default::default(),
             functions: RefCell::new(functions),
             global_init_func,
@@ -238,7 +236,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
     pub fn rvalue_as_function(&self, value: RValue<'gcc>) -> Function<'gcc> {
         let function: Function<'gcc> = unsafe { std::mem::transmute(value) };
         debug_assert!(self.functions.borrow().values().find(|value| **value == function).is_some(),
-            "{:?} is not a function", value);
+            "{:?} ({:?}) is not a function", value, value.get_type());
         function
     }
 
@@ -291,10 +289,6 @@ impl<'gcc, 'tcx> MiscMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         let pointer_type = ptr.get_type();
 
         self.normal_function_addresses.borrow_mut().insert(ptr);
-        self.function_type_param_return_value.borrow_mut().insert(pointer_type, FuncSig {
-            params,
-            return_type,
-        });
 
         ptr
     }

src/intrinsic.rs

@@ -1246,7 +1246,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
     }
 
     fn int_width(&self, typ: Type<'gcc>) -> i64 {
-        typ.get_size() as i64 * 8
+        self.cx.int_width(typ) as i64
     }
 
     fn overflow_intrinsic_call(&mut self, intrinsic: &str, lhs: RValue<'gcc>, rhs: RValue<'gcc>, result: &PlaceRef<'tcx, RValue<'gcc>>) {

src/type_.rs

@@ -105,13 +105,7 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     }
 
     fn type_func(&self, params: &[Type<'gcc>], return_type: Type<'gcc>) -> Type<'gcc> {
-        let pointer_type = self.context.new_function_pointer_type(None, return_type, params, false);
-        // TODO: check if necessary.
-        /*self.function_type_param_return_value.borrow_mut().insert(pointer_type, crate::context::FuncSig {
-            params: params.to_vec(),
-            return_type,
-        });*/
-        pointer_type
+        self.context.new_function_pointer_type(None, return_type, params, false)
     }
 
     fn type_struct(&self, fields: &[Type<'gcc>], packed: bool) -> Type<'gcc> {
@@ -185,7 +179,24 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     }
 
     fn int_width(&self, typ: Type<'gcc>) -> u64 {
-        typ.get_size() as u64 * 8
+        if typ.is_i8(self) || typ.is_u8(self) {
+            8
+        }
+        else if typ.is_i16(self) || typ.is_u16(self) {
+            16
+        }
+        else if typ.is_i32(self) || typ.is_u32(self) {
+            32
+        }
+        else if typ.is_i64(self) || typ.is_u64(self) {
+            64
+        }
+        else if typ.is_i128(self) || typ.is_u128(self) {
+            128
+        }
+        else {
+            panic!("Cannot get width of int type {:?}", typ);
+        }
     }
 
     fn val_ty(&self, value: RValue<'gcc>) -> Type<'gcc> {

src/type_of.rs

@@ -177,10 +177,6 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
                         // TODO: don't compute the params and return value twice.
                         let (return_type, params, _) = fn_abi.gcc_type(cx);
                         let fn_ptr_type = cx.fn_ptr_backend_type(&fn_abi);
-                        cx.function_type_param_return_value.borrow_mut().insert(fn_ptr_type, FuncSig {
-                            params,
-                            return_type,
-                        });
                         fn_ptr_type
                     },
                     _ => self.scalar_gcc_type_at(cx, scalar, Size::ZERO),