Allow tidy check in codegen

compiler/rustc_codegen_cranelift/docs/dwarf.md

@@ -89,7 +89,7 @@ DWARF version must be at least 4.
 (15:46:34) tromey:   if (name == NULL)
 (15:46:34) tromey:     {
 (15:46:37) tromey:       complaint (_("missing name for subprogram DIE at %s"),
-(15:46:40) tromey: 		 sect_offset_str (die->sect_off));
+(15:46:40) tromey:       sect_offset_str (die->sect_off));
 (15:46:47) tromey: I wonder if that comment is correct though
 (15:47:34) tromey: I guess pedantically maybe it is, DWARF 5 3.3.1 says
 (15:47:43) tromey: The subroutine or entry point entry has a DW_AT_name attribute whose value is
@@ -126,8 +126,8 @@ DWARF version must be at least 4.
 (16:04:58) mjw: The idea was that instead of two relocations and two address wide fields, you have one address and a constant offset.
 (16:05:05) tromey: ahh, I see the code now
 (16:05:07) tromey: I forgot about this
-(16:05:18) tromey: 	  if (cu->header.version >= 4 && attr_high->form_is_constant ())
-(16:05:18) tromey: 	    high += low;
+(16:05:18) tromey:    if (cu->header.version >= 4 && attr_high->form_is_constant ())
+(16:05:18) tromey:      high += low;
 (16:05:36) mjw: that second offset doesn't need a relocation and can often be packed in something small, like an uleb128
 (16:05:51) mjw: using udata might not be ideal though, but is allowed
 (16:05:51) tromey: bjorn3: the problem is that this CU claims to be DWARF 3 but is using a DWARF 4 feature

compiler/rustc_codegen_cranelift/example/std_example.rs

@@ -274,7 +274,7 @@ unsafe fn test_simd() {
         test_mm256_permutevar8x32_epi32();
 
         #[rustfmt::skip]
-    let mask1 = _mm_movemask_epi8(dbg!(_mm_setr_epi8(255u8 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));
+    let mask1 = _mm_movemask_epi8(dbg!(_mm_setr_epi8(255u8 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))); // ignore-tidy-dbg
         assert_eq!(mask1, 1);
 
         #[cfg(not(jit))]

compiler/rustc_codegen_cranelift/scripts/rustup.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# ignore-tidy-linelength
 
 set -e
 
@@ -53,7 +54,7 @@ case $1 in
         "$cg_clif/git-fixed-subtree.sh" push --prefix=compiler/rustc_codegen_cranelift/ "$cg_clif" sync_from_rust
         popd
         git merge sync_from_rust
-	;;
+    ;;
     "pull")
         check_git_fixed_subtree
 

compiler/rustc_codegen_cranelift/scripts/setup_rust_fork.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# ignore-tidy-linelength
 set -e
 
 # CG_CLIF_FORCE_GNU_AS will force usage of as instead of the LLVM backend of rustc as

compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# ignore-tidy-linelength
 set -e
 
 cd $(dirname "$0")/../
@@ -175,7 +176,7 @@ rm -r tests/run-make/panic-abort-eh_frame # .eh_frame emitted with panic=abort
 
 # bugs in the test suite
 # ======================
-rm tests/ui/process/nofile-limit.rs # TODO some AArch64 linking issue
+rm tests/ui/process/nofile-limit.rs # FIXME some AArch64 linking issue
 rm -r tests/ui/codegen/equal-pointers-unequal # make incorrect assumptions about the location of stack variables
 rm -r tests/incremental/extern_static/issue-49153.rs # assumes reference to undefined static gets optimized away
 

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -356,10 +356,10 @@ fn codegen_float_intrinsic_call<'tcx>(
         sym::fmaf64 => ("fma", 3, fx.tcx.types.f64, types::F64),
         sym::fmaf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128),
         // FIXME: calling `fma` from libc without FMA target feature uses expensive sofware emulation
-        sym::fmuladdf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f16
-        sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f32
-        sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f64
-        sym::fmuladdf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128), // TODO: use cranelift intrinsic analogous to llvm.fmuladd.f128
+        sym::fmuladdf16 => ("fmaf16", 3, fx.tcx.types.f16, types::F16), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f16
+        sym::fmuladdf32 => ("fmaf", 3, fx.tcx.types.f32, types::F32), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f32
+        sym::fmuladdf64 => ("fma", 3, fx.tcx.types.f64, types::F64), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f64
+        sym::fmuladdf128 => ("fmaf128", 3, fx.tcx.types.f128, types::F128), // FIXME: use cranelift intrinsic analogous to llvm.fmuladd.f128
         sym::copysignf16 => ("copysignf16", 2, fx.tcx.types.f16, types::F16),
         sym::copysignf32 => ("copysignf", 2, fx.tcx.types.f32, types::F32),
         sym::copysignf64 => ("copysign", 2, fx.tcx.types.f64, types::F64),

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -1,10 +1,9 @@
 // tidy-alphabetical-start
-// Note: please avoid adding other feature gates where possible
-#![feature(rustc_private)]
 // Only used to define intrinsics in `compiler_builtins.rs`.
 #![cfg_attr(feature = "jit", feature(f16))]
 #![cfg_attr(feature = "jit", feature(f128))]
 // Note: please avoid adding other feature gates where possible
+#![feature(rustc_private)]
 #![warn(rust_2018_idioms)]
 #![warn(unreachable_pub)]
 #![warn(unused_lifetimes)]

compiler/rustc_codegen_gcc/Readme.md

@@ -23,7 +23,7 @@ The default configuration (see below in the [Quick start](#quick-start) section)
 - rustup: follow instructions on the [official website](https://rustup.rs)
 - consider to install DejaGnu which is necessary for running the libgccjit test suite. [website](https://www.gnu.org/software/dejagnu/#downloading)
 - additional packages: `flex`, `libmpfr-dev`, `libgmp-dev`, `libmpc3`, `libmpc-dev`
-  
+
 ### Quick start
 
 1. Clone and configure the repository:
@@ -37,10 +37,10 @@ The default configuration (see below in the [Quick start](#quick-start) section)
    ```bash
    ./y.sh prepare  # downloads and patches sysroot
    ./y.sh build --sysroot --release
-   
+
    # Verify setup with a simple test
    ./y.sh cargo build --manifest-path tests/hello-world/Cargo.toml
-   
+
    # Run full test suite (expect ~100 failing UI tests)
    ./y.sh test --release
    ```

compiler/rustc_codegen_gcc/build_system/src/prepare.rs

@@ -148,7 +148,7 @@ fn prepare_libcore(
     Ok(())
 }
 
-// TODO: remove when we can ignore warnings in rustdoc tests.
+// FIXME: remove when we can ignore warnings in rustdoc tests.
 fn prepare_rand() -> Result<(), String> {
     // Apply patch for the rand crate.
     let file_path = "patches/crates/0001-Remove-deny-warnings.patch";

compiler/rustc_codegen_gcc/build_system/src/test.rs

@@ -285,7 +285,7 @@ fn build_sysroot(env: &Env, args: &TestArg) -> Result<(), String> {
     Ok(())
 }
 
-// TODO(GuillaumeGomez): when rewriting in Rust, refactor with the code in tests/lang_tests_common.rs if possible.
+// FIXME(GuillaumeGomez): when rewriting in Rust, refactor with the code in tests/lang_tests_common.rs if possible.
 fn maybe_run_command_in_vm(
     command: &[&dyn AsRef<OsStr>],
     env: &Env,
@@ -648,16 +648,16 @@ fn test_projects(env: &Env, args: &TestArg) -> Result<(), String> {
         "https://github.com/BurntSushi/memchr",
         "https://github.com/dtolnay/itoa",
         "https://github.com/rust-lang/cfg-if",
-        //"https://github.com/rust-lang-nursery/lazy-static.rs", // TODO: re-enable when the
+        //"https://github.com/rust-lang-nursery/lazy-static.rs", // FIXME: re-enable when the
         //failing test is fixed upstream.
         //"https://github.com/marshallpierce/rust-base64", // FIXME: one test is OOM-killed.
-        // TODO: ignore the base64 test that is OOM-killed.
+        // FIXME: ignore the base64 test that is OOM-killed.
         //"https://github.com/time-rs/time", // FIXME: one test fails (https://github.com/time-rs/time/issues/719).
         "https://github.com/rust-lang/log",
         "https://github.com/bitflags/bitflags",
         //"https://github.com/serde-rs/serde", // FIXME: one test fails.
-        //"https://github.com/rayon-rs/rayon", // TODO: very slow, only run on master?
-        //"https://github.com/rust-lang/cargo", // TODO: very slow, only run on master?
+        //"https://github.com/rayon-rs/rayon", // FIXME: very slow, only run on master?
+        //"https://github.com/rust-lang/cargo", // FIXME: very slow, only run on master?
     ];
 
     let mut env = env.clone();
@@ -699,7 +699,7 @@ fn test_libcore(env: &Env, args: &TestArg) -> Result<(), String> {
     println!("[TEST] libcore");
     let path = get_sysroot_dir().join("sysroot_src/library/coretests");
     let _ = remove_dir_all(path.join("target"));
-    // TODO(antoyo): run in release mode when we fix the failures.
+    // FIXME(antoyo): run in release mode when we fix the failures.
     run_cargo_command(&[&"test"], Some(&path), env, args)?;
     Ok(())
 }

compiler/rustc_codegen_gcc/doc/debugging-libgccjit.md

@@ -6,25 +6,25 @@ Sometimes, libgccjit will crash and output an error like this:
 during RTL pass: expand
 libgccjit.so: error: in expmed_mode_index, at expmed.h:249
 0x7f0da2e61a35 expmed_mode_index
-	../../../gcc/gcc/expmed.h:249
+    ../../../gcc/gcc/expmed.h:249
 0x7f0da2e61aa4 expmed_op_cost_ptr
-	../../../gcc/gcc/expmed.h:271
+    ../../../gcc/gcc/expmed.h:271
 0x7f0da2e620dc sdiv_cost_ptr
-	../../../gcc/gcc/expmed.h:540
+    ../../../gcc/gcc/expmed.h:540
 0x7f0da2e62129 sdiv_cost
-	../../../gcc/gcc/expmed.h:558
+    ../../../gcc/gcc/expmed.h:558
 0x7f0da2e73c12 expand_divmod(int, tree_code, machine_mode, rtx_def*, rtx_def*, rtx_def*, int)
-	../../../gcc/gcc/expmed.c:4335
+    ../../../gcc/gcc/expmed.c:4335
 0x7f0da2ea1423 expand_expr_real_2(separate_ops*, rtx_def*, machine_mode, expand_modifier)
-	../../../gcc/gcc/expr.c:9240
+    ../../../gcc/gcc/expr.c:9240
 0x7f0da2cd1a1e expand_gimple_stmt_1
-	../../../gcc/gcc/cfgexpand.c:3796
+    ../../../gcc/gcc/cfgexpand.c:3796
 0x7f0da2cd1c30 expand_gimple_stmt
-	../../../gcc/gcc/cfgexpand.c:3857
+    ../../../gcc/gcc/cfgexpand.c:3857
 0x7f0da2cd90a9 expand_gimple_basic_block
-	../../../gcc/gcc/cfgexpand.c:5898
+    ../../../gcc/gcc/cfgexpand.c:5898
 0x7f0da2cdade8 execute
-	../../../gcc/gcc/cfgexpand.c:6582
+    ../../../gcc/gcc/cfgexpand.c:6582
 ```
 
 To see the code which causes this error, call the following function:
@@ -71,4 +71,4 @@ Maybe by calling the following at the beginning of gdb:
 set substitute-path /usr/src/debug/gcc /path/to/gcc-repo/gcc
 ```
 
-TODO(antoyo): but that's not what I remember I was doing.
+FIXME(antoyo): but that's not what I remember I was doing.

compiler/rustc_codegen_gcc/doc/subtree.md

@@ -47,6 +47,6 @@ git push
 PATH="$HOME/bin:$PATH" ~/bin/git-subtree push -P compiler/rustc_codegen_gcc/ ../rustc_codegen_gcc/ sync_branch_name
 ```
 
-TODO: write a script that does the above.
+FIXME: write a script that does the above.
 
 https://rust-lang.zulipchat.com/#narrow/stream/301329-t-devtools/topic/subtree.20madness/near/258877725

compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs

@@ -275,7 +275,7 @@ fn main() {
         }
     }
 
-    // TODO(antoyo): to make this work, support weak linkage.
+    // FIXME(antoyo): to make this work, support weak linkage.
     //unsafe { assert_eq!(ABC as usize, 0); }
 
     &mut (|| Some(0 as *const ())) as &mut dyn FnMut() -> Option<*const ()>;

compiler/rustc_codegen_gcc/example/std_example.rs

@@ -135,7 +135,7 @@ unsafe fn test_simd() {
     test_mm_extract_epi8();
     test_mm_insert_epi16();
 
-    let mask1 = _mm_movemask_epi8(dbg!(_mm_setr_epi8(255u8 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));
+    let mask1 = _mm_movemask_epi8(dbg!(_mm_setr_epi8(255u8 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))); // ignore-tidy-dbg
     assert_eq!(mask1, 1);
 }
 

compiler/rustc_codegen_gcc/src/abi.rs

@@ -105,7 +105,7 @@ pub struct FnAbiGcc<'gcc> {
 }
 
 pub trait FnAbiGccExt<'gcc, 'tcx> {
-    // TODO(antoyo): return a function pointer type instead?
+    // FIXME(antoyo): return a function pointer type instead?
     fn gcc_type(&self, cx: &CodegenCx<'gcc, 'tcx>) -> FnAbiGcc<'gcc>;
     fn ptr_to_gcc_type(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc>;
     #[cfg(feature = "master")]
@@ -260,7 +260,7 @@ pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &Arch) -> Option<FnAttri
             &Arch::Nvptx64 => FnAttribute::NvptxKernel,
             arch => panic!("Arch {arch} does not support GpuKernel calling convention"),
         },
-        // TODO(antoyo): check if those AVR attributes are mapped correctly.
+        // FIXME(antoyo): check if those AVR attributes are mapped correctly.
         CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
             InterruptKind::Avr => FnAttribute::AvrSignal,
             InterruptKind::AvrNonBlocking => FnAttribute::AvrInterrupt,

compiler/rustc_codegen_gcc/src/allocator.rs

@@ -98,7 +98,7 @@ fn create_wrapper_function(
     )));
 
     if tcx.sess.must_emit_unwind_tables() {
-        // TODO(antoyo): emit unwind tables.
+        // FIXME(antoyo): emit unwind tables.
     }
 
     let block = func.new_block("entry");
@@ -138,6 +138,6 @@ fn create_wrapper_function(
         block.end_with_void_return(None);
     }
 
-    // TODO(@Commeownist): Check if we need to emit some extra debugging info in certain circumstances
+    // FIXME(@Commeownist): Check if we need to emit some extra debugging info in certain circumstances
     // as described in https://github.com/rust-lang/rust/commit/77a96ed5646f7c3ee8897693decc4626fe380643
 }

compiler/rustc_codegen_gcc/src/asm.rs

@@ -308,13 +308,13 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                 }
 
                 InlineAsmOperandRef::SymFn { instance } => {
-                    // TODO(@Amanieu): Additional mangling is needed on
+                    // FIXME(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O)
                     // or byte count suffixes (x86 Windows).
                     constants_len += self.tcx.symbol_name(instance).name.len();
                 }
                 InlineAsmOperandRef::SymStatic { def_id } => {
-                    // TODO(@Amanieu): Additional mangling is needed on
+                    // FIXME(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O).
                     constants_len +=
                         self.tcx.symbol_name(Instance::mono(self.tcx, def_id)).name.len();
@@ -440,7 +440,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
             match *piece {
                 InlineAsmTemplatePiece::String(ref string) => {
                     for char in string.chars() {
-                        // TODO(antoyo): might also need to escape | if rustc doesn't do it.
+                        // FIXME(antoyo): might also need to escape | if rustc doesn't do it.
                         let escaped_char = match char {
                             '%' => "%%",
                             '{' => "%{",
@@ -496,15 +496,15 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                         }
 
                         InlineAsmOperandRef::SymFn { instance } => {
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O)
                             // or byte count suffixes (x86 Windows).
                             let name = self.tcx.symbol_name(instance).name;
                             template_str.push_str(name);
                         }
 
                         InlineAsmOperandRef::SymStatic { def_id } => {
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O).
                             let instance = Instance::mono(self.tcx, def_id);
                             let name = self.tcx.symbol_name(instance).name;
@@ -557,7 +557,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                 InlineAsmArch::PowerPC | InlineAsmArch::PowerPC64 => {
                     // "cc" is cr0 on powerpc.
                 }
-                // TODO(@Commeownist): I'm not 100% sure this one clobber is sufficient
+                // FIXME(@Commeownist): I'm not 100% sure this one clobber is sufficient
                 // on all architectures. For instance, what about FP stack?
                 _ => {
                     extended_asm.add_clobber("cc");
@@ -571,7 +571,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
             extended_asm.set_volatile_flag(true);
         }
         if !options.contains(InlineAsmOptions::NOSTACK) {
-            // TODO(@Commeownist): figure out how to align stack
+            // FIXME(@Commeownist): figure out how to align stack
         }
         if dest.is_none() && options.contains(InlineAsmOptions::NORETURN) {
             let builtin_unreachable = self.context.get_builtin_function("__builtin_unreachable");
@@ -640,7 +640,7 @@ fn explicit_reg_to_gcc(reg: InlineAsmReg) -> &'static str {
     // For explicit registers, we have to create a register variable: https://stackoverflow.com/a/31774784/389119
     match reg {
         InlineAsmReg::X86(reg) => {
-            // TODO(antoyo): add support for vector register.
+            // FIXME(antoyo): add support for vector register.
             match reg.reg_class() {
                 X86InlineAsmRegClass::reg_byte => {
                     // GCC does not support the `b` suffix, so we just strip it
@@ -901,16 +901,16 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                         GlobalAsmOperandRef::SymFn { instance } => {
                             let function = get_fn(self, instance);
                             self.add_used_function(function);
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O)
                             // or byte count suffixes (x86 Windows).
                             let name = self.tcx.symbol_name(instance).name;
                             template_str.push_str(name);
                         }
 
                         GlobalAsmOperandRef::SymStatic { def_id } => {
-                            // TODO(antoyo): set the global variable as used.
-                            // TODO(@Amanieu): Additional mangling is needed on
+                            // FIXME(antoyo): set the global variable as used.
+                            // FIXME(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O).
                             let instance = Instance::mono(self.tcx, def_id);
                             let name = self.tcx.symbol_name(instance).name;
@@ -930,7 +930,7 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     }
 
     fn mangled_name(&self, instance: Instance<'tcx>) -> String {
-        // TODO(@Amanieu): Additional mangling is needed on
+        // FIXME(@Amanieu): Additional mangling is needed on
         // some targets to add a leading underscore (Mach-O)
         // or byte count suffixes (x86 Windows).
         self.tcx.symbol_name(instance).name.to_string()

compiler/rustc_codegen_gcc/src/attributes.rs

@@ -126,19 +126,19 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
         .map(|features| features.name.as_str())
         .flat_map(|feat| to_gcc_features(cx.tcx.sess, feat).into_iter())
         .chain(codegen_fn_attrs.instruction_set.iter().map(|x| match *x {
-            InstructionSetAttr::ArmA32 => "-thumb-mode", // TODO(antoyo): support removing feature.
+            InstructionSetAttr::ArmA32 => "-thumb-mode", // FIXME(antoyo): support removing feature.
             InstructionSetAttr::ArmT32 => "thumb-mode",
         }))
         .collect::<Vec<_>>();
 
-    // TODO(antoyo): cg_llvm adds global features to each function so that LTO keep them.
+    // FIXME(antoyo): cg_llvm adds global features to each function so that LTO keep them.
     // Check if GCC requires the same.
     let mut global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());
     function_features.extend(&mut global_features);
     let target_features = function_features
         .iter()
         .filter_map(|feature| {
-            // TODO(antoyo): support soft-float.
+            // FIXME(antoyo): support soft-float.
             if feature.contains("soft-float") {
                 return None;
             }