Use new reflection API

Author: antoyo

Cargo.toml

@@ -14,8 +14,7 @@ harness = false
 
 [dependencies]
 #gccjit = "1.0.0"
-#gccjit = { git = "https://github.com/antoyo/gccjit.rs", branch = "feature/rustc" }
-gccjit = { path = "/home/bouanto/Ordinateur/Programmation/Rust/Projets/gccjit.rs" }
+gccjit = { git = "https://github.com/antoyo/gccjit.rs", branch = "feature/rustc" }
 
 target-lexicon = "0.10.0"
 

gcc-test-backend/Cargo.lock

@@ -7,7 +7,7 @@ edition = "2018"
 [dependencies]
 #depth1 = { path = "depth1" }
 #mini_core = { path = "mini_core" }
-deflate = "0.7.19"
+#deflate = "0.7.19"
 
 [profile.dev]
 panic = "abort"

gcc-test-backend/Cargo.toml

@@ -128,13 +128,14 @@ fn main() {
 
     println!("{}", leaves.capacity());*/
 
+    println!("Hello, world!");
 
-    let mut leaves: Vec<Node> = Vec::with_capacity(286);
+    /*let mut leaves: Vec<Node> = Vec::with_capacity(286);
     let frequencies/*: &[i32]*/ = &[526, 124, 128, 125, 107, 92, 84, 75, 88, 53, 63, 43, 54, 68, 56, 60, 38, 53, 37, 23, 36, 32, 21, 25, 20, 21, 27, 26, 16, 15, 20, 24, 22, 14, 12, 19, 19, 10, 15, 11, 13, 4, 15, 7, 6, 10, 10, 2, 1, 3, 3, 2, 2, 3, 2, 1, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 3, 0, 1, 2, 3, 0, 2, 1, 4, 0, 1, 1, 1, 2, 2, 2, 3, 1, 1, 0, 0, 3, 0, 1, 0, 2, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 2, 1, 0, 2, 0, 0, 1, 0, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 2, 0, 0, 1, 1, 0, 2, 0, 1, 1, 0, 0, 1, 2, 0, 2, 1, 1, 2, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 2, 0, 0, 0, 2, 1, 2, 0, 2, 0, 0, 1, 0, 0, 0, 2, 1, 0, 0, 1, 0, 0, 2, 0, 2, 0, 4, 6, 3, 4, 8, 7, 2, 7, 6, 8, 5, 8, 8, 17, 11, 16, 10, 8, 7, 13, 9, 14, 18, 12, 10, 19, 12, 11, 17, 15, 13, 17, 14, 17, 23, 31, 44, 27, 25, 30, 18, 17, 20, 25, 72, 52, 55, 69, 87, 75, 1, 7754, 5054, 3016, 2120, 1790, 1263, 606, 602, 958, 783, 481, 333, 510, 392, 211, 177, 169, 89, 58, 70, 110, 56, 37, 52, 63, 38, 48, 13, 1373];
     let len = 10;
     unsafe {
         println!("&{:?}[10] = {:?}", frequencies.as_ptr(), frequencies.as_ptr().add(len));
-    }
+    }*/
     /*leaves.extend(frequencies.iter().enumerate().filter_map(
             |(n, f)| if *f > 0 {
                 Some(Node {

gcc-test-backend/src/main.rs

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

gcc_path

@@ -73,7 +73,7 @@ pub fn compile_codegen_unit<'tcx>(tcx: TyCtxt<'tcx>, cgu_name: Symbol) -> (Modul
         //let llvm_module = ModuleLlvm::new(tcx, &cgu_name.as_str());
         let context = Context::default();
         //context.set_dump_code_on_compile(true);
-        //context.set_dump_initial_gimple(true);
+        context.set_dump_initial_gimple(true);
         context.set_debug_info(true);
         //context.set_dump_everything(true);
         //context.set_keep_intermediates(true);

src/base.rs

@@ -131,7 +131,7 @@ impl<'gcc, 'tcx> Builder<'_, 'gcc, 'tcx> {
         Cow::Owned(casted_args)
     }
 
-    fn check_ptr_call<'b>(&mut self, typ: &str, func: RValue<'gcc>, args: &'b [RValue<'gcc>]) -> Cow<'b, [RValue<'gcc>]> {
+    fn check_ptr_call<'b>(&mut self, typ: &str, func_ptr: RValue<'gcc>, args: &'b [RValue<'gcc>]) -> Cow<'b, [RValue<'gcc>]> {
         //let mut fn_ty = self.cx.val_ty(func);
         // Strip off pointers
         /*while self.cx.type_kind(fn_ty) == TypeKind::Pointer {
@@ -154,9 +154,9 @@ impl<'gcc, 'tcx> Builder<'_, 'gcc, 'tcx> {
 
         let mut all_args_match = true;
         let mut param_types = vec![];
-        let gcc_func: Function<'gcc> = self.cx.rvalue_as_function(func);
+        let gcc_func = func_ptr.get_type().is_function_ptr_type().expect("function ptr");
         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();
+            let param = gcc_func.get_param_type(index);
             if param != arg.get_type() {
                 all_args_match = false;
             }
@@ -253,16 +253,16 @@ impl<'gcc, 'tcx> Builder<'_, 'gcc, 'tcx> {
         }
     }
 
-    fn function_ptr_call(&mut self, mut func: RValue<'gcc>, args: &[RValue<'gcc>], funclet: Option<&Funclet>) -> RValue<'gcc> {
+    fn function_ptr_call(&mut self, mut func_ptr: RValue<'gcc>, args: &[RValue<'gcc>], funclet: Option<&Funclet>) -> RValue<'gcc> {
         //debug!("func ptr call {:?} with args ({:?})", func, args);
 
-        let args = self.check_ptr_call("call", func, args);
+        let args = self.check_ptr_call("call", func_ptr, args);
         //let bundle = funclet.map(|funclet| funclet.bundle());
         //let bundle = bundle.as_ref().map(|b| &*b.raw);
 
         // 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 gcc_func: Function<'gcc> = self.cx.rvalue_as_function(func);
+        let gcc_func = func_ptr.get_type().is_function_ptr_type().expect("function ptr");
         let return_type = gcc_func.get_return_type();
         let current_block = self.current_block.borrow().expect("block");
         let void_type = self.context.new_type::<()>();
@@ -271,11 +271,11 @@ impl<'gcc, 'tcx> Builder<'_, 'gcc, 'tcx> {
         if return_type != void_type {
             unsafe { RETURN_VALUE_COUNT += 1 };
             let result = current_func.new_local(None, return_type, &format!("returnValue{}", unsafe { RETURN_VALUE_COUNT }));
-            current_block.add_assignment(None, result, self.cx.context.new_call_through_ptr(None, func, &args));
+            current_block.add_assignment(None, result, self.cx.context.new_call_through_ptr(None, func_ptr, &args));
             result.to_rvalue()
         }
         else {
-            current_block.add_eval(None, self.cx.context.new_call_through_ptr(None, func, &args));
+            current_block.add_eval(None, self.cx.context.new_call_through_ptr(None, func_ptr, &args));
             // Return dummy value when not having return value.
             self.context.new_rvalue_from_long(self.isize_type, 0)
         }
@@ -751,16 +751,6 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
 
     fn alloca(&mut self, ty: Type<'gcc>, align: Align) -> RValue<'gcc> {
         let aligned_type = ty.get_aligned(align.bytes());
-        let type_fields = self.fields.borrow().get(&ty).cloned();
-        // TODO: remove these conditions when libgccjit has a reflection API.
-        if self.vector_types.borrow().contains_key(&ty) {
-            let value = self.vector_types.borrow().get(&ty).expect("vector type").clone();
-            self.vector_types.borrow_mut().insert(aligned_type, value);
-        }
-        else if let Some(fields) = type_fields {
-            self.fields.borrow_mut().insert(aligned_type, fields);
-        }
-
         // 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)
     }
@@ -1027,7 +1017,9 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
             let element = self.context.new_array_access(None, value, index);
             element.get_address(None)
         }
-        else if let Some(&(count, element_type)) = self.vector_types.borrow().get(&value_type) {
+        else if let Some(vector_type) = value_type.is_vector() {
+            let count = vector_type.get_num_units();
+            let element_type = vector_type.get_element_type();
             let indexes = vec![self.context.new_rvalue_from_long(element_type, i64::try_from(idx).expect("i64::try_from")); count as usize];
             let indexes = self.context.new_rvalue_from_vector(None, value_type, &indexes);
             let variable = self.current_func.borrow().expect("func")
@@ -1036,11 +1028,11 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
                 .add_assignment(None, variable, value + indexes);
             variable.get_address(None)
         }
+        else if let Some(struct_type) = value_type.is_struct() {
+            ptr.dereference_field(None, struct_type.get_field(idx as i32)).get_address(None)
+        }
         else {
-            let fields = self.fields.borrow();
-            let fields = &fields.get(&value_type)
-                .unwrap_or_else(|| panic!("Structure {:?} ({:?}) not in fields", value, value.get_type()));
-            ptr.dereference_field(None, fields[idx as usize]).get_address(None)
+            panic!("Unexpected type {:?}", value_type);
         }
     }
 
@@ -1241,14 +1233,14 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
             let element = self.context.new_array_access(None, aggregate_value, index);
             element.get_address(None)
         }
-        else if let Some(&(count, element_type)) = self.vector_types.borrow().get(&value_type) {
+        else if value_type.is_vector().is_some() {
             panic!();
         }
+        else if let Some(struct_type) = value_type.is_struct() {
+            aggregate_value.access_field(None, struct_type.get_field(idx as i32)).to_rvalue()
+        }
         else {
-            let fields = self.fields.borrow();
-            let fields = &fields.get(&value_type)
-                .unwrap_or_else(|| panic!("Structure {:?} not in fields", aggregate_value.get_type()));
-            aggregate_value.access_field(None, fields[idx as usize]).to_rvalue()
+            panic!("Unexpected type {:?}", value_type);
         }
         /*assert_eq!(idx as c_uint as u64, idx);
         unsafe { llvm::LLVMBuildExtractValue(self.llbuilder, agg_val, idx as c_uint, UNNAMED) }*/
@@ -1264,14 +1256,14 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
                 let index = self.context.new_rvalue_from_long(self.u64_type, i64::try_from(idx).expect("i64::try_from"));
                 self.context.new_array_access(None, aggregate_value, index)
             }
-            else if let Some(&(count, element_type)) = self.vector_types.borrow().get(&value_type) {
+            else if value_type.is_vector().is_some() {
                 panic!();
             }
+            else if let Some(struct_type) = value_type.is_struct() {
+                aggregate_value.access_field(None, struct_type.get_field(idx as i32))
+            }
             else {
-                let fields = self.fields.borrow();
-                let fields = &fields.get(&value_type)
-                    .unwrap_or_else(|| panic!("Structure {:?} not in fields", aggregate_value.get_type()));
-                aggregate_value.access_field(None, fields[idx as usize])
+                panic!("Unexpected type {:?}", value_type);
             };
         self.llbb().add_assignment(None, lvalue, value);
 

src/builder.rs

@@ -187,9 +187,10 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         let name = fields.iter().map(|typ| format!("{:?}", typ)).collect::<Vec<_>>().join("_");
         let typ = self.type_struct(&fields, packed);
         let structure = self.global_init_func.new_local(None, typ, &name);
-        let fields = &self.fields.borrow()[&typ];
-        for (value, field) in values.iter().zip(fields.iter()) {
-            let field_lvalue = structure.access_field(None, *field);
+        let struct_type = typ.is_struct().expect("struct type");
+        for (index, value) in values.iter().enumerate() {
+            let field = struct_type.get_field(index as i32);
+            let field_lvalue = structure.access_field(None, field);
             self.global_init_block.add_assignment(None, field_lvalue, *value);
         }
         self.lvalue_to_rvalue(structure)

src/common.rs

@@ -83,8 +83,6 @@ pub struct CodegenCx<'gcc, 'tcx> {
     pub types: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), Type<'gcc>>>,
     pub tcx: TyCtxt<'tcx>,
 
-    pub fields: RefCell<FxHashMap<Type<'gcc>, Vec<Field<'gcc>>>>,
-    pub vector_types: RefCell<FxHashMap<Type<'gcc>, (u64, Type<'gcc>)>>,
     pub struct_types: RefCell<FxHashMap<Vec<Type<'gcc>>, Type<'gcc>>>,
 
     pub types_with_fields_to_set: RefCell<FxHashMap<Type<'gcc>, (Struct<'gcc>, TyAndLayout<'tcx>)>>,
@@ -212,8 +210,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             scalar_types: Default::default(),
             types: Default::default(),
             tcx,
-            fields: Default::default(),
-            vector_types: Default::default(),
             struct_types: Default::default(),
             types_with_fields_to_set: Default::default(),
             local_gen_sym_counter: Cell::new(0),

src/context.rs

@@ -120,16 +120,15 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         let name = types.iter().map(|typ| format!("{:?}", typ)).collect::<Vec<_>>().join("_");
         //let typ = self.context.new_struct_type(None, format!("struct{}", name), &fields).as_type();
         let typ = self.context.new_struct_type(None, "struct", &fields).as_type();
-        self.fields.borrow_mut().insert(typ, fields);
         self.struct_types.borrow_mut().insert(types, typ);
         typ
     }
 
     fn type_kind(&self, typ: Type<'gcc>) -> TypeKind {
-        if typ.is_int() {
+        if typ.is_integral() {
             TypeKind::Integer
         }
-        else if typ.is_vector() {
+        else if typ.is_vector().is_some() {
             TypeKind::Vector
         }
         else {
@@ -219,17 +218,14 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             .map(|field| self.context.new_field(None, *field, "field"))
             .collect();
         typ.set_fields(None, &fields);
-        self.fields.borrow_mut().insert(typ.as_type(), fields);
     }
 
     fn type_struct(&self, fields: &[Type<'gcc>], packed: bool) -> Type<'gcc> {
         // TODO: use packed.
         let fields: Vec<_> = fields.iter()
             .map(|field| self.context.new_field(None, *field, "field"))
             .collect();
-        let typ = self.context.new_struct_type(None, "unnamedStruct", &fields).as_type();
-        self.fields.borrow_mut().insert(typ, fields);
-        typ
+        return self.context.new_struct_type(None, "unnamedStruct", &fields).as_type();
     }
 
     pub fn type_named_struct(&self, name: &str) -> Struct<'gcc> {

src/type_.rs

@@ -44,9 +44,7 @@ pub fn uncached_gcc_type<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, layout: TyAndLa
         Abi::Scalar(_) => bug!("handled elsewhere"),
         Abi::Vector { ref element, count } => {
             let element = layout.scalar_gcc_type_at(cx, element, Size::ZERO);
-            let vector_type = cx.context.new_vector_type(element, count);
-            cx.vector_types.borrow_mut().insert(vector_type, (count, element));
-            return vector_type
+            return cx.context.new_vector_type(element, count);
         },
         Abi::ScalarPair(..) => {
             return cx.type_struct(