use upstream 64-bit functions, add overflow assertions where none exist

Author: erer1243

Diff for: compiler/rustc_codegen_llvm/src/common.rs

@@ -95,11 +95,12 @@ impl<'ll> BackendTypes for CodegenCx<'ll, '_> {
 
 impl<'ll> CodegenCx<'ll, '_> {
     pub fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
-        unsafe { llvm::LLVMRustConstArray(ty, elts.as_ptr(), elts.len()) }
+        unsafe { llvm::LLVMConstArray2(ty, elts.as_ptr(), elts.len()) }
     }
 
     pub fn const_vector(&self, elts: &[&'ll Value]) -> &'ll Value {
-        unsafe { llvm::LLVMRustConstVector(elts.as_ptr(), elts.len()) }
+        let len = c_uint::try_from(elts.len()).expect("LLVMConstVector elements len overflow");
+        unsafe { llvm::LLVMConstVector(elts.as_ptr(), len) }
     }
 
     pub fn const_bytes(&self, bytes: &[u8]) -> &'ll Value {
@@ -329,7 +330,7 @@ pub fn val_ty(v: &Value) -> &Type {
 pub fn bytes_in_context<'ll>(llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
     unsafe {
         let ptr = bytes.as_ptr() as *const c_char;
-        llvm::LLVMRustConstStringInContext(llcx, ptr, bytes.len(), True)
+        llvm::LLVMConstStringInContext2(llcx, ptr, bytes.len(), True)
     }
 }
 
@@ -338,7 +339,8 @@ pub fn struct_in_context<'ll>(
     elts: &[&'ll Value],
     packed: bool,
 ) -> &'ll Value {
-    unsafe { llvm::LLVMRustConstStructInContext(llcx, elts.as_ptr(), elts.len(), packed as Bool) }
+    let len = c_uint::try_from(elts.len()).expect("LLVMConstStructInContext elements len overflow");
+    unsafe { llvm::LLVMConstStructInContext(llcx, elts.as_ptr(), len, packed as Bool) }
 }
 
 #[inline]

Diff for: compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -931,6 +931,27 @@ extern "C" {
     pub fn LLVMConstIntOfArbitraryPrecision(IntTy: &Type, Wn: c_uint, Ws: *const u64) -> &Value;
     pub fn LLVMConstReal(RealTy: &Type, N: f64) -> &Value;
 
+    // Operations on composite constants
+    pub fn LLVMConstArray2<'a>(
+        ElementTy: &'a Type,
+        ConstantVals: *const &'a Value,
+        Length: size_t,
+    ) -> &'a Value;
+    pub fn LLVMArrayType2(ElementType: &Type, ElementCount: u64) -> &Type;
+    pub fn LLVMConstStringInContext2(
+        C: &Context,
+        Str: *const c_char,
+        Length: size_t,
+        DontNullTerminate: Bool,
+    ) -> &Value;
+    pub fn LLVMConstStructInContext<'a>(
+        C: &'a Context,
+        ConstantVals: *const &'a Value,
+        Count: c_uint,
+        Packed: Bool,
+    ) -> &'a Value;
+    pub fn LLVMConstVector(ScalarConstantVals: *const &Value, Size: c_uint) -> &Value;
+
     // Constant expressions
     pub fn LLVMConstInBoundsGEP2<'a>(
         ty: &'a Type,
@@ -1510,9 +1531,6 @@ extern "C" {
     /// See llvm::LLVMTypeKind::getTypeID.
     pub fn LLVMRustGetTypeKind(Ty: &Type) -> TypeKind;
 
-    // Operations on array, pointer, and vector types (sequence types)
-    pub fn LLVMRustArrayType(ElementType: &Type, ElementCount: u64) -> &Type;
-
     // Operations on all values
     pub fn LLVMRustGlobalAddMetadata<'a>(Val: &'a Value, KindID: c_uint, Metadata: &'a Metadata);
     pub fn LLVMRustIsNonGVFunctionPointerTy(Val: &Value) -> bool;
@@ -1526,31 +1544,6 @@ extern "C" {
         low: &mut u64,
     ) -> bool;
 
-    // Operations on composite constants.
-    // They match LLVMConst* but use size_t lengths instead of unsigned int.
-    // See https://github.com/rust-lang/rust/issues/121868
-    // See https://llvm.org/doxygen/group__LLVMCCoreValueConstantComposite.html
-    pub fn LLVMRustConstStringInContext(
-        C: &Context,
-        Str: *const c_char,
-        Length: size_t,
-        DontNullTerminate: Bool,
-    ) -> &Value;
-    pub fn LLVMRustConstStructInContext<'a>(
-        C: &'a Context,
-        ConstantVals: *const &'a Value,
-        Count: size_t,
-        Packed: Bool,
-    ) -> &'a Value;
-    // FIXME: replace with LLVMConstArray2 when bumped minimal version to llvm-17
-    // https://github.com/llvm/llvm-project/commit/35276f16e5a2cae0dfb49c0fbf874d4d2f177acc
-    pub fn LLVMRustConstArray<'a>(
-        ElementTy: &'a Type,
-        ConstantVals: *const &'a Value,
-        Length: size_t,
-    ) -> &'a Value;
-    pub fn LLVMRustConstVector(ScalarConstantVals: *const &Value, Size: size_t) -> &Value;
-
     // Operations on global variables, functions, and aliases (globals)
     pub fn LLVMRustGetLinkage(Global: &Value) -> Linkage;
     pub fn LLVMRustSetLinkage(Global: &Value, RustLinkage: Linkage);

Diff for: compiler/rustc_codegen_llvm/src/type_.rs

@@ -233,7 +233,7 @@ impl<'ll, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn type_array(&self, ty: &'ll Type, len: u64) -> &'ll Type {
-        unsafe { llvm::LLVMRustArrayType(ty, len) }
+        unsafe { llvm::LLVMArrayType2(ty, len) }
     }
 }
 

Diff for: compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -1214,14 +1214,6 @@ extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
   }
 }
 
-// LLVMArrayType function does not support 64-bit ElementCount
-// FIXME: replace with LLVMArrayType2 when bumped minimal version to llvm-17
-// https://github.com/llvm/llvm-project/commit/35276f16e5a2cae0dfb49c0fbf874d4d2f177acc
-extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
-                                         uint64_t ElementCount) {
-  return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
-}
-
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
 
 extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
@@ -2082,34 +2074,33 @@ extern "C" bool LLVMRustLLVMHasZstdCompressionForDebugSymbols() {
 }
 
 // Operations on composite constants.
-// They match LLVMConst* but use size_t lengths instead of unsigned int.
+// These are clones of LLVM api functions that will become available in future releases.
+// They can be removed once Rust's minimum supported LLVM version supports them.
 // See https://github.com/rust-lang/rust/issues/121868
 // See https://llvm.org/doxygen/group__LLVMCCoreValueConstantComposite.html
-extern "C" LLVMValueRef LLVMRustConstStringInContext(LLVMContextRef C,
-                                                     const char *Str,
-                                                     size_t Length,
-                                                     bool DontNullTerminate) {
-  return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), !DontNullTerminate));
-}
 
-// See LLVMRustConstStringInContext
-extern "C" LLVMValueRef LLVMRustConstStructInContext(LLVMContextRef C,
-                                                     LLVMValueRef *ConstantVals,
-                                                     size_t Count,
-                                                     bool Packed) {
-  Constant **Elements = unwrap<Constant>(ConstantVals, Count);
-  return wrap(ConstantStruct::getAnon(*unwrap(C), ArrayRef(Elements, Count), Packed));
+// FIXME Change version check once patch is accepted into LLVM
+#if LLVM_VERSION_LT(999, 0)
+extern "C" LLVMValueRef LLVMConstStringInContext2(LLVMContextRef C,
+                                                  const char *Str,
+                                                  size_t Length,
+                                                  bool DontNullTerminate) {
+  return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length), !DontNullTerminate));
 }
+#endif
 
-// See LLVMRustConstStringInContext
-extern "C" LLVMValueRef LLVMRustConstArray(LLVMTypeRef ElementTy,
-                                           LLVMValueRef *ConstantVals,
-                                           size_t Length) {
+// FIXME: Remove when Rust's minimum supported LLVM version reaches 17.
+// https://github.com/llvm/llvm-project/commit/35276f16e5a2cae0dfb49c0fbf874d4d2f177acc
+#if LLVM_VERSION_LT(17, 0)
+extern "C" LLVMValueRef LLVMConstArray2(LLVMTypeRef ElementTy,
+                                        LLVMValueRef *ConstantVals,
+                                        size_t Length) {
   ArrayRef<Constant *> V(unwrap<Constant>(ConstantVals, Length), Length);
   return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
 }
 
-// See LLVMRustConstStringInContext
-extern "C" LLVMValueRef LLVMRustConstVector(LLVMValueRef *ScalarConstantVals, size_t Size) {
-  return wrap(ConstantVector::get(ArrayRef(unwrap<Constant>(ScalarConstantVals, Size), Size)));
+extern "C" LLVMTypeRef LLVMArrayType2(LLVMTypeRef ElementTy,
+                                      uint64_t ElementCount) {
+  return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
 }
+#endif