what am I doing here?

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/abi.rs

@@ -189,7 +189,7 @@ trait ArgAbiExt<'ll, 'tcx> {
     );
 }
 
-impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
+impl<'ll: 'tcx, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
     /// Gets the LLVM type for a place of the original Rust type of
     /// this argument/return, i.e., the result of `type_of::type_of`.
     fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
@@ -287,7 +287,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
     }
 }
 
-impl<'ll, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     fn store_fn_arg(
         &mut self,
         arg_abi: &ArgAbi<'tcx, Ty<'tcx>>,
@@ -326,7 +326,7 @@ pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> {
     fn apply_attrs_callsite(&self, bx: &mut Builder<'_, 'll, 'tcx>, callsite: &'ll Value);
 }
 
-impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
+impl<'ll: 'tcx, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     fn llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
         // Ignore "extra" args from the call site for C variadic functions.
         // Only the "fixed" args are part of the LLVM function signature.

compiler/rustc_codegen_llvm/src/asm.rs

@@ -22,7 +22,7 @@ use crate::type_of::LayoutLlvmExt;
 use crate::value::Value;
 use crate::{attributes, llvm};
 
-impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     fn codegen_inline_asm(
         &mut self,
         template: &[InlineAsmTemplatePiece],
@@ -452,8 +452,8 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
     }
 }
 
-pub(crate) fn inline_asm_call<'ll>(
-    bx: &mut Builder<'_, 'll, '_>,
+pub(crate) fn inline_asm_call<'ll: 'tcx, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
     asm: &str,
     cons: &str,
     inputs: &[&'ll Value],
@@ -896,8 +896,8 @@ fn llvm_asm_scalar_type<'ll>(cx: &CodegenCx<'ll, '_>, scalar: Scalar) -> &'ll Ty
     }
 }
 
-fn any_target_feature_enabled(
-    cx: &CodegenCx<'_, '_>,
+fn any_target_feature_enabled<'ll: 'tcx, 'tcx>(
+    cx: &CodegenCx<'ll, 'tcx>,
     instance: Instance<'_>,
     features: &[Symbol],
 ) -> bool {
@@ -906,7 +906,7 @@ fn any_target_feature_enabled(
 }
 
 /// Fix up an input value to work around LLVM bugs.
-fn llvm_fixup_input<'ll, 'tcx>(
+fn llvm_fixup_input<'ll: 'tcx, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     mut value: &'ll Value,
     reg: InlineAsmRegClass,
@@ -1072,7 +1072,7 @@ fn llvm_fixup_input<'ll, 'tcx>(
 }
 
 /// Fix up an output value to work around LLVM bugs.
-fn llvm_fixup_output<'ll, 'tcx>(
+fn llvm_fixup_output<'ll: 'tcx, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     mut value: &'ll Value,
     reg: InlineAsmRegClass,
@@ -1219,7 +1219,7 @@ fn llvm_fixup_output<'ll, 'tcx>(
 }
 
 /// Output type to use for llvm_fixup_output.
-fn llvm_fixup_output_type<'ll, 'tcx>(
+fn llvm_fixup_output_type<'ll: 'tcx, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     reg: InlineAsmRegClass,
     layout: &TyAndLayout<'tcx>,

compiler/rustc_codegen_llvm/src/base.rs

@@ -73,7 +73,7 @@ pub(crate) fn compile_codegen_unit(
     // the time we needed for codegenning it.
     let cost = time_to_codegen.as_nanos() as u64;
 
-    fn module_codegen(tcx: TyCtxt<'_>, cgu_name: Symbol) -> ModuleCodegen<ModuleLlvm> {
+    fn module_codegen<'ll: 'tcx, 'tcx>(tcx: TyCtxt<'tcx>, cgu_name: Symbol) -> ModuleCodegen<ModuleLlvm> {
         let cgu = tcx.codegen_unit(cgu_name);
         let _prof_timer =
             tcx.prof.generic_activity_with_arg_recorder("codegen_module", |recorder| {
@@ -86,7 +86,7 @@ pub(crate) fn compile_codegen_unit(
             let cx = CodegenCx::new(tcx, cgu, &llvm_module);
             let mono_items = cx.codegen_unit.items_in_deterministic_order(cx.tcx);
             for &(mono_item, data) in &mono_items {
-                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, data.linkage, data.visibility);
+                mono_item.predefine::<Builder<'_, 'll, 'tcx>>(&cx, data.linkage, data.visibility);
             }
 
             // ... and now that we have everything pre-defined, fill out those definitions.

compiler/rustc_codegen_llvm/src/builder.rs

@@ -66,7 +66,7 @@ pub(crate) struct GenericBuilder<'a, 'll, CX: Borrow<SimpleCx<'ll>>> {
     pub cx: &'a CX,
 }
 
-pub(crate) type Builder<'a, 'll, 'tcx> = GenericBuilder<'a, 'll, CodegenCx<'ll, 'tcx>>;
+pub(crate) type Builder<'a, 'll: 'tcx, 'tcx> = GenericBuilder<'a, 'll, CodegenCx<'ll, 'tcx>>;
 
 impl<'a, 'll, CX: Borrow<SimpleCx<'ll>>> Drop for GenericBuilder<'a, 'll, CX> {
     fn drop(&mut self) {
@@ -189,7 +189,7 @@ impl<'a, 'll> SBuilder<'a, 'll> {
 // FIXME(eddyb) pass `&CStr` directly to FFI once it's a thin pointer.
 const UNNAMED: *const c_char = c"".as_ptr();
 
-impl<'ll, 'tcx> BackendTypes for Builder<'_, 'll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> BackendTypes for Builder<'_, 'll, 'tcx> {
     type Value = <CodegenCx<'ll, 'tcx> as BackendTypes>::Value;
     type Metadata = <CodegenCx<'ll, 'tcx> as BackendTypes>::Metadata;
     type Function = <CodegenCx<'ll, 'tcx> as BackendTypes>::Function;
@@ -247,7 +247,7 @@ impl<'tcx> FnAbiOfHelpers<'tcx> for Builder<'_, '_, 'tcx> {
     }
 }
 
-impl<'ll, 'tcx> Deref for Builder<'_, 'll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> Deref for Builder<'_, 'll, 'tcx> {
     type Target = CodegenCx<'ll, 'tcx>;
 
     #[inline]
@@ -279,7 +279,7 @@ macro_rules! set_math_builder_methods {
 }
 
 //impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
-impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for GenericBuilder<'a, 'll, CodegenCx<'ll, 'tcx>> {
+impl<'a, 'll: 'tcx, 'tcx> BuilderMethods<'a, 'tcx> for GenericBuilder<'a, 'll, CodegenCx<'ll, 'tcx>> {
     type CodegenCx = CodegenCx<'ll, 'tcx>;
 
     fn build(cx: &'a CodegenCx<'ll, 'tcx>, llbb: &'ll BasicBlock) -> Self {
@@ -1347,14 +1347,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for GenericBuilder<'a, 'll, Codegen
     }
 }
 
-impl<'ll> StaticBuilderMethods for Builder<'_, 'll, '_> {
+impl<'ll: 'tcx, 'tcx> StaticBuilderMethods for Builder<'_, 'll, 'tcx> {
     fn get_static(&mut self, def_id: DefId) -> &'ll Value {
         // Forward to the `get_static` method of `CodegenCx`
         self.cx().get_static(def_id)
     }
 }
 
-impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
+impl<'a, 'll: 'tcx, 'tcx> Builder<'a, 'll, 'tcx> {
     fn with_cx(cx: &'a CodegenCx<'ll, 'tcx>) -> Self {
         // Create a fresh builder from the crate context.
         let llbuilder = unsafe { llvm::LLVMCreateBuilderInContext(cx.llcx) };

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -26,8 +26,8 @@ use crate::type_of::LayoutLlvmExt;
 use crate::va_arg::emit_va_arg;
 use crate::value::Value;
 
-fn get_simple_intrinsic<'ll>(
-    cx: &CodegenCx<'ll, '_>,
+fn get_simple_intrinsic<'ll: 'tcx, 'tcx>(
+    cx: &CodegenCx<'ll, 'tcx>,
     name: Symbol,
 ) -> Option<(&'ll Type, &'ll Value)> {
     let llvm_name = match name {
@@ -153,7 +153,7 @@ fn get_simple_intrinsic<'ll>(
     Some(cx.get_intrinsic(llvm_name))
 }
 
-impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     fn codegen_intrinsic_call(
         &mut self,
         instance: ty::Instance<'tcx>,
@@ -677,8 +677,8 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     }
 }
 
-fn catch_unwind_intrinsic<'ll>(
-    bx: &mut Builder<'_, 'll, '_>,
+fn catch_unwind_intrinsic<'a, 'll: 'tcx, 'tcx>(
+    bx: &mut Builder<'a, 'll, 'tcx>,
     try_func: &'ll Value,
     data: &'ll Value,
     catch_func: &'ll Value,
@@ -709,8 +709,8 @@ fn catch_unwind_intrinsic<'ll>(
 // instructions are meant to work for all targets, as of the time of this
 // writing, however, LLVM does not recommend the usage of these new instructions
 // as the old ones are still more optimized.
-fn codegen_msvc_try<'ll>(
-    bx: &mut Builder<'_, 'll, '_>,
+fn codegen_msvc_try<'a, 'll: 'tcx, 'tcx> (
+    bx: &mut Builder<'a, 'll, 'tcx>,
     try_func: &'ll Value,
     data: &'ll Value,
     catch_func: &'ll Value,
@@ -856,8 +856,8 @@ fn codegen_msvc_try<'ll>(
 }
 
 // WASM's definition of the `rust_try` function.
-fn codegen_wasm_try<'ll>(
-    bx: &mut Builder<'_, 'll, '_>,
+fn codegen_wasm_try<'ll: 'tcx, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
     try_func: &'ll Value,
     data: &'ll Value,
     catch_func: &'ll Value,
@@ -940,8 +940,8 @@ fn codegen_wasm_try<'ll>(
 // function calling it, and that function may already have other personality
 // functions in play. By calling a shim we're guaranteed that our shim will have
 // the right personality function.
-fn codegen_gnu_try<'ll>(
-    bx: &mut Builder<'_, 'll, '_>,
+fn codegen_gnu_try<'ll: 'tcx, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
     try_func: &'ll Value,
     data: &'ll Value,
     catch_func: &'ll Value,
@@ -999,8 +999,8 @@ fn codegen_gnu_try<'ll>(
 // Variant of codegen_gnu_try used for emscripten where Rust panics are
 // implemented using C++ exceptions. Here we use exceptions of a specific type
 // (`struct rust_panic`) to represent Rust panics.
-fn codegen_emcc_try<'ll>(
-    bx: &mut Builder<'_, 'll, '_>,
+fn codegen_emcc_try<'ll: 'tcx, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
     try_func: &'ll Value,
     data: &'ll Value,
     catch_func: &'ll Value,
@@ -1081,7 +1081,7 @@ fn codegen_emcc_try<'ll>(
 
 // Helper function to give a Block to a closure to codegen a shim function.
 // This is currently primarily used for the `try` intrinsic functions above.
-fn gen_fn<'ll, 'tcx>(
+fn gen_fn<'ll: 'tcx, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     name: &str,
     rust_fn_sig: ty::PolyFnSig<'tcx>,
@@ -1104,7 +1104,7 @@ fn gen_fn<'ll, 'tcx>(
 // catch exceptions.
 //
 // This function is only generated once and is then cached.
-fn get_rust_try_fn<'ll, 'tcx>(
+fn get_rust_try_fn<'ll: 'tcx, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     codegen: &mut dyn FnMut(Builder<'_, 'll, 'tcx>),
 ) -> (&'ll Type, &'ll Value) {
@@ -1150,7 +1150,7 @@ fn get_rust_try_fn<'ll, 'tcx>(
     rust_try
 }
 
-fn generic_simd_intrinsic<'ll, 'tcx>(
+fn generic_simd_intrinsic<'ll: 'tcx, 'tcx>(
     bx: &mut Builder<'_, 'll, 'tcx>,
     name: Symbol,
     callee_ty: Ty<'tcx>,
@@ -1518,7 +1518,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         }
     }
 
-    fn simd_simple_float_intrinsic<'ll, 'tcx>(
+    fn simd_simple_float_intrinsic<'ll: 'tcx, 'tcx>(
         name: Symbol,
         in_elem: Ty<'_>,
         in_ty: Ty<'_>,
@@ -1634,7 +1634,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         }
     }
 
-    fn llvm_vector_ty<'ll>(cx: &CodegenCx<'ll, '_>, elem_ty: Ty<'_>, vec_len: u64) -> &'ll Type {
+    fn llvm_vector_ty<'ll: 'tcx, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, elem_ty: Ty<'_>, vec_len: u64) -> &'ll Type {
         let elem_ty = match *elem_ty.kind() {
             ty::Int(v) => cx.type_int_from_ty(v),
             ty::Uint(v) => cx.type_uint_from_ty(v),

compiler/rustc_codegen_llvm/src/type_.rs

@@ -35,7 +35,7 @@ impl fmt::Debug for Type {
     }
 }
 
-impl<'ll> CodegenCx<'ll, '_> {}
+//impl<'ll> CodegenCx<'ll, 'tcx> {}
 impl<'ll> SimpleCx<'ll> {
     pub(crate) fn type_named_struct(&self, name: &str) -> &'ll Type {
         let name = SmallCStr::new(name);
@@ -75,7 +75,7 @@ impl<'ll> SimpleCx<'ll> {
         }
     }
 }
-impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> CodegenCx<'ll, 'tcx> {
     pub(crate) fn type_bool(&self) -> &'ll Type {
         self.type_i8()
     }
@@ -142,7 +142,7 @@ impl<'ll> SimpleCx<'ll> {
     }
 }
 
-impl<'ll, 'tcx> BaseTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> BaseTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn type_i8(&self) -> &'ll Type {
         unsafe { llvm::LLVMInt8TypeInContext(self.llcx) }
     }
@@ -246,7 +246,7 @@ impl Type {
     }
 }
 
-impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn backend_type(&self, layout: TyAndLayout<'tcx>) -> &'ll Type {
         layout.llvm_type(self)
     }
@@ -281,7 +281,7 @@ impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 }
 
-impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+impl<'ll: 'tcx, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn add_type_metadata(&self, function: &'ll Value, typeid: String) {
         let typeid_metadata = self.typeid_metadata(typeid).unwrap();
         unsafe {

compiler/rustc_codegen_llvm/src/type_of.rs

@@ -12,7 +12,7 @@ use tracing::debug;
 use crate::common::*;
 use crate::type_::Type;
 
-fn uncached_llvm_type<'a, 'tcx>(
+fn uncached_llvm_type<'a: 'tcx, 'tcx>(
     cx: &CodegenCx<'a, 'tcx>,
     layout: TyAndLayout<'tcx>,
     defer: &mut Option<(&'a Type, TyAndLayout<'tcx>)>,
@@ -80,7 +80,7 @@ fn uncached_llvm_type<'a, 'tcx>(
     }
 }
 
-fn struct_llfields<'a, 'tcx>(
+fn struct_llfields<'a: 'tcx, 'tcx>(
     cx: &CodegenCx<'a, 'tcx>,
     layout: TyAndLayout<'tcx>,
 ) -> (Vec<&'a Type>, bool) {
@@ -139,7 +139,7 @@ fn struct_llfields<'a, 'tcx>(
     (result, packed)
 }
 
-impl<'a, 'tcx> CodegenCx<'a, 'tcx> {
+impl<'a: 'tcx, 'tcx> CodegenCx<'a, 'tcx> {
     pub(crate) fn align_of(&self, ty: Ty<'tcx>) -> Align {
         self.layout_of(ty).align.abi
     }