Add ffi_const and ffi_pure extern fn attributes

Author: gnzlbg

src/librustc/hir/mod.rs

@@ -2489,6 +2489,29 @@ bitflags! {
         /// #[used], indicates that LLVM can't eliminate this function (but the
         /// linker can!)
         const USED                      = 1 << 9;
+        /// #[ffi_pure], indicates that a function has no effects except for
+        /// its return value, that its return value depends only on the
+        /// parameters and/or global variables, and that its return value does
+        /// not change between two consecutive calls (for example, because of
+        /// volatile access to the global variables).
+        ///
+        /// Such a function can be subject to common sub-expression elimination
+        /// and loop optimization just as an arithmetic operator would be. Some
+        /// common examples of pure functions are `strlen` or `memcmp`.
+        const FFI_PURE = 1 << 10;
+        /// #[ffi_const], indicates that a function has no effects except for
+        /// its return value and that its return value depends only on the
+        /// value of the function parameters.
+        ///
+        /// This attribute is stricter than `#[ffi_pure]`, since the function
+        /// return value is not allowed to depend on anything that is not the
+        /// value of the function parameters, like global memory, or other
+        /// values, like dereferencing a pointer function parameter to read
+        /// another value.
+        ///
+        /// A `#[ffi_const]` function that returns void is a `nop` in the
+        /// abstract machine.
+        const FFI_CONST = 1 << 11;
     }
 }
 

src/librustc_codegen_llvm/attributes.rs

@@ -223,6 +223,12 @@ pub fn from_fn_attrs(
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::COLD) {
         Attribute::Cold.apply_llfn(Function, llfn);
     }
+    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_PURE) {
+        Attribute::ReadOnly.apply_llfn(Function, llfn);
+    }
+    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_CONST) {
+        Attribute::ReadNone.apply_llfn(Function, llfn);
+    }
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
         naked(llfn, true);
     }

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -116,6 +116,7 @@ pub enum Attribute {
     SanitizeMemory  = 22,
     NonLazyBind     = 23,
     OptimizeNone    = 24,
+    ReadNone        = 25,
 }
 
 /// LLVMIntPredicate

src/librustc_typeck/collect.rs

@@ -2270,6 +2270,30 @@ fn codegen_fn_attrs<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefId) -> Codegen
             codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR;
         } else if attr.check_name("unwind") {
             codegen_fn_attrs.flags |= CodegenFnAttrFlags::UNWIND;
+        } else if attr.check_name("ffi_pure") {
+            if tcx.is_foreign_item(id) {
+                codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE;
+            } else {
+                // `#[ffi_pure]` is only allowed `extern fn`s
+                struct_span_err!(
+                    tcx.sess,
+                    attr.span,
+                    E0724,
+                    "`#[ffi_pure]` may only be used on `extern fn`s"
+                ).emit();
+            }
+        } else if attr.check_name("ffi_const") {
+            if tcx.is_foreign_item(id) {
+                codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST;
+            } else {
+                // `#[ffi_const]` is only allowed `extern fn`s
+                struct_span_err!(
+                    tcx.sess,
+                    attr.span,
+                    E0725,
+                    "`#[ffi_const]` may only be used on `extern fn`s"
+                ).emit();
+            }
         } else if attr.check_name("rustc_allocator_nounwind") {
             codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_ALLOCATOR_NOUNWIND;
         } else if attr.check_name("naked") {

src/librustc_typeck/diagnostics.rs

@@ -4720,4 +4720,6 @@ register_diagnostics! {
     E0698, // type inside generator must be known in this context
     E0719, // duplicate values for associated type binding
     E0722, // Malformed #[optimize] attribute
+    E0724, // `#[ffi_pure]` is only allowed `extern fn`s
+    E0725, // `#[ffi_const]` is only allowed `extern fn`s
 }

src/libsyntax/feature_gate.rs

@@ -290,6 +290,12 @@ declare_features! (
     // The `repr(i128)` annotation for enums.
     (active, repr128, "1.16.0", Some(35118), None),
 
+    // Allows the use of `#[ffi_pure]` on extern functions.
+    (active, ffi_pure, "1.34.0", Some(58329), None),
+
+    // Allows the use of `#[ffi_const]` on extern functions.
+    (active, ffi_const, "1.34.0", Some(58328), None),
+
     // The `unadjusted` ABI; perma-unstable.
     //
     // rustc internal
@@ -1124,6 +1130,16 @@ pub const BUILTIN_ATTRIBUTES: &[(&str, AttributeType, AttributeTemplate, Attribu
                                  "the `#[naked]` attribute \
                                   is an experimental feature",
                                  cfg_fn!(naked_functions))),
+    ("ffi_pure", Whitelisted, template!(Word), Gated(Stability::Unstable,
+                                                     "ffi_pure",
+                                                     "the `#[ffi_pure]` attribute \
+                                                      is an experimental feature",
+                                                     cfg_fn!(ffi_pure))),
+    ("ffi_const", Whitelisted, template!(Word), Gated(Stability::Unstable,
+                                                      "ffi_const",
+                                                      "the `#[ffi_const]` attribute \
+                                                       is an experimental feature",
+                                                      cfg_fn!(ffi_const))),
     ("target_feature", Whitelisted, template!(List: r#"enable = "name""#), Ungated),
     ("export_name", Whitelisted, template!(NameValueStr: "name"), Ungated),
     ("inline", Whitelisted, template!(Word, List: "always|never"), Ungated),

src/rustllvm/RustWrapper.cpp

@@ -170,6 +170,8 @@ static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
     return Attribute::OptimizeForSize;
   case ReadOnly:
     return Attribute::ReadOnly;
+  case ReadNone:
+    return Attribute::ReadNone;
   case SExt:
     return Attribute::SExt;
   case StructRet:

src/rustllvm/rustllvm.h

@@ -85,6 +85,7 @@ enum LLVMRustAttribute {
   SanitizeMemory = 22,
   NonLazyBind = 23,
   OptimizeNone = 24,
+  ReadNone = 25,
 };
 
 typedef struct OpaqueRustString *RustStringRef;

src/test/codegen/ffi-const.rs

@@ -0,0 +1,16 @@
+// compile-flags: -C no-prepopulate-passes
+#![crate_type = "lib"]
+#![feature(ffi_const)]
+
+// CHECK-LABEL: @bar()
+#[no_mangle]
+pub fn bar() { unsafe { foo() } }
+
+
+extern {
+    // CHECK-LABEL: @foo() unnamed_addr #1
+    // CHECK: attributes #1 = { {{.*}}readnone{{.*}} }
+    #[no_mangle]
+    #[ffi_const]
+    pub fn foo();
+}

src/test/codegen/ffi-pure.rs

@@ -0,0 +1,13 @@
+// compile-flags: -C no-prepopulate-passes
+#![crate_type = "lib"]
+#![feature(ffi_pure)]
+
+// CHECK-LABEL: @bar()
+#[no_mangle]
+pub fn bar() { unsafe { foo() } }
+
+extern {
+    // CHECK-LABEL: @foo() unnamed_addr #1
+    // CHECK: attributes #1 = { {{.*}}readonly{{.*}} }
+    #[ffi_pure] pub fn foo();
+}