src/librustc_codegen_ssa/traits/mod.rs

   1 //! Interface of a Rust codegen backend
   2 //!
   3 //! This crate defines all the traits that have to be implemented by a codegen backend in order to
   4 //! use the backend-agnostic codegen code in `rustc_codegen_ssa`.
   5 //!
   6 //! The interface is designed around two backend-specific data structures, the codegen context and
   7 //! the builder. The codegen context is supposed to be read-only after its creation and during the
   8 //! actual codegen, while the builder stores the information about the function during codegen and
   9 //! is used to produce the instructions of the backend IR.
  10 //!
  11 //! Finally, a third `Backend` structure has to implement methods related to how codegen information
  12 //! is passed to the backend, especially for asynchronous compilation.
  13 //!
  14 //! The traits contain associated types that are backend-specific, such as the backend's value or
  15 //! basic blocks.
  16
  17 mod abi;
  18 mod asm;
  19 mod backend;
  20 mod builder;
  21 mod consts;
  22 mod debuginfo;
  23 mod declare;
  24 mod intrinsic;
  25 mod misc;
  26 mod statics;
  27 mod type_;
  28 mod write;
  29
  30 pub use self::abi::AbiBuilderMethods;
  31 pub use self::asm::{AsmBuilderMethods, AsmMethods};
  32 pub use self::backend::{Backend, BackendTypes, CodegenBackend, ExtraBackendMethods};
  33 pub use self::builder::{BuilderMethods, OverflowOp};
  34 pub use self::consts::ConstMethods;
  35 pub use self::debuginfo::{DebugInfoBuilderMethods, DebugInfoMethods};
  36 pub use self::declare::{DeclareMethods, PreDefineMethods};
  37 pub use self::intrinsic::IntrinsicCallMethods;
  38 pub use self::misc::MiscMethods;
  39 pub use self::statics::{StaticBuilderMethods, StaticMethods};
  40 pub use self::type_::{
  41     ArgAbiMethods, BaseTypeMethods, DerivedTypeMethods, LayoutTypeMethods, TypeMethods,
  42 };
  43 pub use self::write::{ModuleBufferMethods, ThinBufferMethods, WriteBackendMethods};
  44
  45 use rustc_middle::ty::layout::{HasParamEnv, HasTyCtxt};
  46 use rustc_target::spec::HasTargetSpec;
  47
  48 use std::fmt;
  49
  50 pub trait CodegenObject: Copy + PartialEq + fmt::Debug {}
  51 impl<T: Copy + PartialEq + fmt::Debug> CodegenObject for T {}
  52
  53 pub trait CodegenMethods<'tcx>:
  54     Backend<'tcx>
  55     + TypeMethods<'tcx>
  56     + MiscMethods<'tcx>
  57     + ConstMethods<'tcx>
  58     + StaticMethods
  59     + DebugInfoMethods<'tcx>
  60     + DeclareMethods<'tcx>
  61     + AsmMethods
  62     + PreDefineMethods<'tcx>
  63     + HasParamEnv<'tcx>
  64     + HasTyCtxt<'tcx>
  65     + HasTargetSpec
  66 {
  67 }
  68
  69 impl<'tcx, T> CodegenMethods<'tcx> for T where
  70     Self: Backend<'tcx>
  71         + TypeMethods<'tcx>
  72         + MiscMethods<'tcx>
  73         + ConstMethods<'tcx>
  74         + StaticMethods
  75         + DebugInfoMethods<'tcx>
  76         + DeclareMethods<'tcx>
  77         + AsmMethods
  78         + PreDefineMethods<'tcx>
  79         + HasParamEnv<'tcx>
  80         + HasTyCtxt<'tcx>
  81         + HasTargetSpec
  82 {
  83 }
  84
  85 pub trait HasCodegen<'tcx>:
  86     Backend<'tcx> + ::std::ops::Deref<Target = <Self as HasCodegen<'tcx>>::CodegenCx>
  87 {
  88     type CodegenCx: CodegenMethods<'tcx>
  89         + BackendTypes<
  90             Value = Self::Value,
  91             Function = Self::Function,
  92             BasicBlock = Self::BasicBlock,
  93             Type = Self::Type,
  94             Funclet = Self::Funclet,
  95             DIScope = Self::DIScope,
  96             DIVariable = Self::DIVariable,
  97         >;
  98 }