Fix: fix raw_eq being missing

Author: RDambrosio016

crates/rustc_codegen_nvvm/CHANGELOG.md

@@ -4,6 +4,10 @@ Notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+## 0.2.3 - 1/2/22
+
+- Fixed the `raw_eq` intrinsic being undefined.
+
 ## 0.2.2 - 12/5/21 
 
 - Pass all ADTs directly, fixing certain structs being passed indirectly because they are scalar pairs.

crates/rustc_codegen_nvvm/src/ctx_intrinsics.rs

@@ -36,6 +36,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
         let t_i128 = self.type_vector(t_i64, 2);
         let t_f32 = self.type_f32();
         let t_f64 = self.type_f64();
+        let t_isize = self.type_isize();
 
         let t_i8_i1 = self.type_struct(&[t_i8, i1], false);
         let t_i16_i1 = self.type_struct(&[t_i16, i1], false);
@@ -176,6 +177,10 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
         ifn!(map, "llvm.expect.i1", fn(i1, i1) -> i1);
         ifn!(map, "llvm.prefetch", fn(i8p, t_i32, t_i32, t_i32) -> void);
 
+        // This isn't an "LLVM intrinsic", but LLVM's optimization passes
+        // recognize it like one and we assume it exists in `core::slice::cmp`
+        ifn!(map, "memcmp", fn(i8p, i8p, t_isize) -> t_i32);
+
         ifn!(map, "llvm.va_start", fn(i8p) -> void);
         ifn!(map, "llvm.va_end", fn(i8p) -> void);
         ifn!(map, "llvm.va_copy", fn(i8p, i8p) -> void);

crates/rustc_codegen_nvvm/src/intrinsic.rs

@@ -5,6 +5,7 @@ use crate::ty::LayoutLlvmExt;
 use crate::{builder::Builder, context::CodegenCx};
 use rustc_codegen_ssa::common::span_invalid_monomorphization_error;
 use rustc_codegen_ssa::mir::place::PlaceRef;
+use rustc_codegen_ssa::traits::DerivedTypeMethods;
 use rustc_codegen_ssa::traits::{BaseTypeMethods, BuilderMethods, ConstMethods, OverflowOp};
 use rustc_codegen_ssa::{mir::operand::OperandRef, traits::IntrinsicCallMethods};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
@@ -425,6 +426,44 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                     }
                 }
             }
+            sym::raw_eq => {
+                use abi::Abi::*;
+                use rustc_codegen_ssa::common::IntPredicate;
+                let tp_ty = substs.type_at(0);
+                let layout = self.layout_of(tp_ty).layout;
+                let use_integer_compare = match layout.abi {
+                    Scalar(_) | ScalarPair(_, _) => true,
+                    Uninhabited | Vector { .. } => false,
+                    Aggregate { .. } => {
+                        // For rusty ABIs, small aggregates are actually passed
+                        // as `RegKind::Integer` (see `FnAbi::adjust_for_abi`),
+                        // so we re-use that same threshold here.
+                        layout.size <= self.data_layout().pointer_size * 2
+                    }
+                };
+
+                let a = args[0].immediate();
+                let b = args[1].immediate();
+                if layout.size.bytes() == 0 {
+                    self.const_bool(true)
+                } else if use_integer_compare {
+                    let integer_ty = self.type_ix(layout.size.bits());
+                    let ptr_ty = self.type_ptr_to(integer_ty);
+                    let a_ptr = self.bitcast(a, ptr_ty);
+                    let a_val = self.load(integer_ty, a_ptr, layout.align.abi);
+                    let b_ptr = self.bitcast(b, ptr_ty);
+                    let b_val = self.load(integer_ty, b_ptr, layout.align.abi);
+                    self.icmp(IntPredicate::IntEQ, a_val, b_val)
+                } else {
+                    let i8p_ty = self.type_i8p();
+                    let a_ptr = self.bitcast(a, i8p_ty);
+                    let b_ptr = self.bitcast(b, i8p_ty);
+                    let n = self.const_usize(layout.size.bytes());
+                    let intrinsic = self.get_intrinsic("memcmp");
+                    let cmp = self.call(self.type_i1(), intrinsic, &[a_ptr, b_ptr, n], None);
+                    self.icmp(IntPredicate::IntEQ, cmp, self.const_i32(0))
+                }
+            }
             // is this even supported by nvvm? i did not find a definitive answer
             _ if name_str.starts_with("simd_") => todo!("simd intrinsics"),
             _ => bug!("unknown intrinsic '{}'", name),