Plugin provided "intrinsics".

Allows plugins to define functions which are only expanded by the plugin
after all type checking, inference, etc etc, ie only once codegen
encounters a call to the intrinsic. In this initial version, the codegen
crate is reponsible for calling the plugin intrinsic codgen trait and
codegening the resulting extra MIR statements. Plugins are limited to
`mir::StatementKind` and those contained therein, so they can't insert
extra basic blocks, or insert calls to arbitraty functions. This means
the compiler can still reason about what is reachable.

The form of the interface with the plugins is slightly different than
what was proposed in rust-lang#51623.
Additionally, signature checking is added.

Author: DiamondLovesYou

src/librustc/mir/mod.rs

@@ -29,6 +29,7 @@ use rustc_data_structures::small_vec::SmallVec;
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::sync::ReadGuard;
 use rustc_serialize as serialize;
+use std::collections::HashMap;
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter, Write};
 use std::ops::{Index, IndexMut};
@@ -2923,3 +2924,39 @@ impl<'tcx> TypeFoldable<'tcx> for Literal<'tcx> {
         }
     }
 }
+pub type PluginIntrinsics = HashMap<String, Box<PluginIntrinsicCodegen>>;
+pub trait PluginIntrinsicCodegen: Sync + Send {
+    /// Codegen a plugin-defined intrinsic. This is intended to be used to
+    /// "return" values based on the monomorphized and erased types of the
+    /// function call. Codegen will codegen the `extra_stmts` and then insert
+    /// an unconditional branch to the exit block.
+    ///
+    /// Consider this to be highly unstable; it will likely change without
+    /// warning. There is also no spec for this, it is 100% implementation
+    /// defined, and may not be implemented at all for some codegen backends.
+    ///
+    /// If the codegen backend is multithreaded, this will be called from
+    /// any number of threads, hence `Sync + Send`.
+    ///
+    /// YOU ARE RESPONSIBLE FOR THE SAFETY OF THE EXTRA STATEMENTS.
+    /// You have been warned. Good luck, have fun.
+    fn codegen_simple_intrinsic<'a, 'tcx>(&self,
+                                          tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                          source_info: SourceInfo,
+                                          sig: &ty::FnSig<'tcx>,
+                                          parent_mir: &Mir<'tcx>,
+                                          parent_param_substs: &'tcx Substs<'tcx>,
+                                          args: &Vec<Operand<'tcx>>,
+                                          dest: Place<'tcx>,
+                                          extra_stmts: &mut Vec<StatementKind<'tcx>>)
+        where 'tcx: 'a;
+
+    /// The following are used for during typeck:
+
+    /// The number of generic parameters expected.
+    fn generic_parameter_count<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> usize;
+    /// The types of the input args.
+    fn inputs<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<Ty<'tcx>>;
+    /// The return type.
+    fn output<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx>;
+}

src/librustc/session/mod.rs

@@ -19,14 +19,16 @@ use lint;
 use lint::builtin::BuiltinLintDiagnostics;
 use middle::allocator::AllocatorKind;
 use middle::dependency_format;
+use mir::PluginIntrinsics;
 use session::search_paths::PathKind;
 use session::config::{OutputType};
 use ty::tls;
 use util::nodemap::{FxHashSet};
 use util::common::{duration_to_secs_str, ErrorReported};
 use util::common::ProfileQueriesMsg;
 
-use rustc_data_structures::sync::{self, Lrc, Lock, LockCell, OneThread, Once, RwLock};
+use rustc_data_structures::sync::{self, Lrc, Lock, LockCell, OneThread, Once,
+                                  RwLock, ArcCell, };
 
 use syntax::ast::NodeId;
 use errors::{self, DiagnosticBuilder, DiagnosticId};
@@ -54,6 +56,7 @@ use std::fmt;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
+use std::sync::Arc;
 use std::sync::mpsc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
@@ -92,6 +95,7 @@ pub struct Session {
     pub one_time_diagnostics: Lock<FxHashSet<(DiagnosticMessageId, Option<Span>, String)>>,
     pub plugin_llvm_passes: OneThread<RefCell<Vec<String>>>,
     pub plugin_attributes: OneThread<RefCell<Vec<(String, AttributeType)>>>,
+    pub plugin_intrinsics: ArcCell<PluginIntrinsics>,
     pub crate_types: Once<Vec<config::CrateType>>,
     pub dependency_formats: Once<dependency_format::Dependencies>,
     /// The crate_disambiguator is constructed out of all the `-C metadata`
@@ -1109,6 +1113,7 @@ pub fn build_session_(
         one_time_diagnostics: Lock::new(FxHashSet()),
         plugin_llvm_passes: OneThread::new(RefCell::new(Vec::new())),
         plugin_attributes: OneThread::new(RefCell::new(Vec::new())),
+        plugin_intrinsics: ArcCell::new(Arc::new(HashMap::new())),
         crate_types: Once::new(),
         dependency_formats: Once::new(),
         crate_disambiguator: Once::new(),

src/librustc_codegen_llvm/context.rs

@@ -26,6 +26,7 @@ use type_of::PointeeInfo;
 
 use rustc_data_structures::base_n;
 use rustc::mir::mono::Stats;
+use rustc::mir::PluginIntrinsics;
 use rustc::session::config::{self, NoDebugInfo};
 use rustc::session::Session;
 use rustc::ty::layout::{LayoutError, LayoutOf, Size, TyLayout};
@@ -102,6 +103,7 @@ pub struct CodegenCx<'a, 'tcx: 'a> {
     pub rust_try_fn: Cell<Option<ValueRef>>,
 
     intrinsics: RefCell<FxHashMap<&'static str, ValueRef>>,
+    pub plugin_intrinsics: Arc<PluginIntrinsics>,
 
     /// A counter that is used for generating local symbol names
     local_gen_sym_counter: Cell<usize>,
@@ -306,6 +308,7 @@ impl<'a, 'tcx> CodegenCx<'a, 'tcx> {
                 eh_unwind_resume: Cell::new(None),
                 rust_try_fn: Cell::new(None),
                 intrinsics: RefCell::new(FxHashMap()),
+                plugin_intrinsics: tcx.sess.plugin_intrinsics.get(),
                 local_gen_sym_counter: Cell::new(0),
             };
             cx.isize_ty = Type::isize(&cx);

src/librustc_codegen_llvm/mir/block.rs

@@ -454,6 +454,38 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
                     return;
                 }
 
+                if let Some(intrinsic) = intrinsic {
+                    if let Some(trans) = bx.cx.plugin_intrinsics.get(intrinsic) {
+                        // Get the extra statements from the plugin:
+                        let &(ref dest, target) = destination
+                          .as_ref()
+                          .unwrap();
+
+                        let mut extra_stmts = Vec::new();
+                        trans.codegen_simple_intrinsic(bx.tcx(),
+                                                       terminator.source_info,
+                                                       &sig,
+                                                       self.mir,
+                                                       self.param_substs,
+                                                       args,
+                                                       dest.clone(),
+                                                       &mut extra_stmts);
+
+                        // Now, codegen:
+                        for stmt_kind in extra_stmts.into_iter() {
+                            let stmt = mir::Statement {
+                                source_info: terminator.source_info,
+                                kind: stmt_kind,
+                            };
+                            bx = self.codegen_statement(bx, &stmt);
+                        }
+
+                        // Lastly, jump to the target block:
+                        funclet_br(self, bx, target);
+                        return;
+                    }
+                }
+
                 let extra_args = &args[sig.inputs().len()..];
                 let extra_args = extra_args.iter().map(|op_arg| {
                     let op_ty = op_arg.ty(self.mir, bx.tcx());

src/librustc_data_structures/sync.rs

@@ -39,6 +39,7 @@ use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::fmt;
 use std::ops::{Deref, DerefMut};
+use std::sync::{Arc, atomic::AtomicPtr, atomic, };
 use owning_ref::{Erased, OwningRef};
 
 pub fn serial_join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
@@ -751,3 +752,55 @@ impl<T> DerefMut for OneThread<T> {
         &mut self.inner
     }
 }
+
+/// Provides atomic mutability by replacing the value inside this `ArcCell`.
+/// Similar to the `crossbeam` structure of the same name.
+#[derive(Debug)]
+pub struct ArcCell<T>(AtomicPtr<T>);
+impl<T> ArcCell<T> {
+    pub fn new(v: Arc<T>) -> Self {
+        ArcCell(AtomicPtr::new(Arc::into_raw(v) as *mut _))
+    }
+    pub fn get(&self) -> Arc<T> {
+        let ptr = self.0.load(atomic::Ordering::Acquire);
+        let arc = unsafe { Arc::from_raw(ptr as *const T) };
+        let ret = arc.clone();
+        // don't drop our copy:
+        ::std::mem::forget(arc);
+        ret
+    }
+    /// Update the value, returning the previous value.
+    pub fn set(&self, v: Arc<T>) -> Arc<T> {
+        let new = Arc::into_raw(v) as *mut _;
+        let mut expected = self.0.load(atomic::Ordering::Acquire);
+        loop {
+            match self.0.compare_exchange_weak(expected, new,
+                                               atomic::Ordering::SeqCst,
+                                               atomic::Ordering::Acquire) {
+                Ok(old) => {
+                    return unsafe { Arc::from_raw(old as *const T) };
+                },
+                Err(v) => {
+                    expected = v;
+                },
+            }
+        }
+    }
+}
+impl<T> Drop for ArcCell<T> {
+    fn drop(&mut self) {
+        let ptr = self.0.load(atomic::Ordering::Acquire);
+        // drop our copy of the arc:
+        unsafe { Arc::from_raw(ptr as *const _) };
+    }
+}
+impl<T> Clone for ArcCell<T> {
+    fn clone(&self) -> Self {
+        ArcCell::new(self.get())
+    }
+}
+impl<T> From<Arc<T>> for ArcCell<T> {
+    fn from(v: Arc<T>) -> Self {
+        Self::new(v)
+    }
+}

src/librustc_driver/driver.rs

@@ -50,7 +50,7 @@ use std::io::{self, Write};
 use std::iter;
 use std::path::{Path, PathBuf};
 use rustc_data_structures::sync::{self, Lrc, Lock};
-use std::sync::mpsc;
+use std::sync::{mpsc, Arc, };
 use syntax::{self, ast, attr, diagnostics, visit};
 use syntax::ext::base::ExtCtxt;
 use syntax::fold::Folder;
@@ -896,6 +896,7 @@ where
         lint_groups,
         llvm_passes,
         attributes,
+        intrinsics,
         ..
     } = registry;
 
@@ -914,6 +915,7 @@ where
 
         *sess.plugin_llvm_passes.borrow_mut() = llvm_passes;
         *sess.plugin_attributes.borrow_mut() = attributes.clone();
+        sess.plugin_intrinsics.set(Arc::new(intrinsics));
     })?;
 
     // Lint plugins are registered; now we can process command line flags.

src/librustc_plugin/registry.rs

@@ -11,6 +11,7 @@
 //! Used by plugin crates to tell `rustc` about the plugins they provide.
 
 use rustc::lint::{EarlyLintPassObject, LateLintPassObject, LintId, Lint};
+use rustc::mir::{PluginIntrinsics, PluginIntrinsicCodegen};
 use rustc::session::Session;
 
 use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT, IdentTT};
@@ -61,6 +62,9 @@ pub struct Registry<'a> {
     #[doc(hidden)]
     pub attributes: Vec<(String, AttributeType)>,
 
+    #[doc(hidden)]
+    pub intrinsics: PluginIntrinsics,
+
     whitelisted_custom_derives: Vec<ast::Name>,
 }
 
@@ -77,6 +81,7 @@ impl<'a> Registry<'a> {
             lint_groups: HashMap::new(),
             llvm_passes: vec![],
             attributes: vec![],
+            intrinsics: HashMap::new(),
             whitelisted_custom_derives: Vec::new(),
         }
     }
@@ -95,6 +100,17 @@ impl<'a> Registry<'a> {
         self.args_hidden.as_ref().map(|v| &v[..]).unwrap_or(&[])
     }
 
+    /// Register a plugin intrinsic. Ignored if `name` is a normal Rust intrinsic.
+    ///
+    /// When a function call to the named intrinsic is made, codegen (only LLVM, currently)
+    /// will replace the usual function call with the extra statements provided by the passed
+    /// trait object. It will then branch directly to the exit block. It is highly unsafe. Do not
+    /// use lightly.
+    pub fn register_intrinsic(&mut self, name: String,
+                              codegen: Box<PluginIntrinsicCodegen>) {
+        self.intrinsics.insert(name, codegen);
+    }
+
     /// Register a syntax extension of any kind.
     ///
     /// This is the most general hook into `libsyntax`'s expansion behavior.

src/librustc_typeck/check/intrinsic.rs

@@ -319,12 +319,20 @@ pub fn check_intrinsic_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             }
 
             ref other => {
-                struct_span_err!(tcx.sess, it.span, E0093,
+                let plugin_intrinsics = tcx.sess.plugin_intrinsics.get();
+                if let Some(plugin) = plugin_intrinsics.get(*other) {
+                  (plugin.generic_parameter_count(tcx),
+                   plugin.inputs(tcx),
+                   plugin.output(tcx))
+                } else {
+                    struct_span_err!(tcx.sess, it.span, E0093,
                                 "unrecognized intrinsic function: `{}`",
                                 *other)
                                 .span_label(it.span, "unrecognized intrinsic")
                                 .emit();
-                return;
+                    return;
+
+                }
             }
         };
         (n_tps, inputs, output)

src/test/compile-fail-fulldeps/auxiliary/plugin_intrinsic_codegen.rs

@@ -0,0 +1,84 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// force-host
+
+#![feature(plugin_registrar, rustc_private)]
+#![deny(plugin_as_library)] // should have no effect in a plugin crate
+
+extern crate rustc;
+extern crate rustc_plugin;
+
+
+use rustc::mir::*;
+use rustc::ty::{Ty, TyCtxt, FnSig, subst::Substs, };
+use rustc_plugin::Registry;
+
+#[plugin_registrar]
+pub fn plugin_registrar(reg: &mut Registry) {
+  let codegen = Box::new(GenericCountMismatch) as Box<_>;
+  reg.register_intrinsic("generic_count_mismatch".into(), codegen);
+  let codegen = Box::new(InputOutputMismatch) as Box<_>;
+  reg.register_intrinsic("type_mismatch".into(), codegen);
+}
+
+struct GenericCountMismatch;
+impl PluginIntrinsicCodegen for GenericCountMismatch {
+  fn codegen_simple_intrinsic<'a, 'tcx>(&self,
+                                        _tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                        _source_info: SourceInfo,
+                                        _sig: &FnSig<'tcx>,
+                                        _parent_mir: &Mir<'tcx>,
+                                        _parent_param_substs: &'tcx Substs<'tcx>,
+                                        _args: &Vec<Operand<'tcx>>,
+                                        _dest: Place<'tcx>,
+                                        _extra_stmts: &mut Vec<StatementKind<'tcx>>)
+    where 'tcx: 'a,
+  {
+    unreachable!()
+  }
+
+  /// The number of generic parameters expected.
+  fn generic_parameter_count<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>) -> usize { 5 }
+  /// The types of the input args.
+  fn inputs<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<Ty<'tcx>> { vec![] }
+  /// The return type.
+  fn output<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx> {
+    tcx.mk_nil()
+  }
+}
+
+struct InputOutputMismatch;
+impl PluginIntrinsicCodegen for InputOutputMismatch {
+  fn codegen_simple_intrinsic<'a, 'tcx>(&self,
+                                        _tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                        _source_info: SourceInfo,
+                                        _sig: &FnSig<'tcx>,
+                                        _parent_mir: &Mir<'tcx>,
+                                        _parent_param_substs: &'tcx Substs<'tcx>,
+                                        _args: &Vec<Operand<'tcx>>,
+                                        _dest: Place<'tcx>,
+                                        _extra_stmts: &mut Vec<StatementKind<'tcx>>)
+    where 'tcx: 'a,
+  {
+    unreachable!()
+  }
+
+  /// The number of generic parameters expected.
+  fn generic_parameter_count<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>) -> usize { 0 }
+  /// The types of the input args.
+  fn inputs<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec<Ty<'tcx>> {
+    vec![tcx.types.u64]
+  }
+  /// The return type.
+  fn output<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx> {
+    tcx.types.u64
+  }
+}