Moved Funclet

Author: denismerigoux

src/librustc_codegen_llvm/common.rs

@@ -30,7 +30,7 @@ use rustc::hir;
 use interfaces::BuilderMethods;
 use mir::constant::const_alloc_to_llvm;
 use mir::place::PlaceRef;
-use rustc_codegen_utils::common::{OperandBundleDef, TypeKind};
+use rustc_codegen_utils::common::TypeKind;
 
 use libc::{c_uint, c_char};
 use std::iter;
@@ -68,42 +68,6 @@ pub use context::CodegenCx;
 *
 */
 
-/// A structure representing an active landing pad for the duration of a basic
-/// block.
-///
-/// Each `Block` may contain an instance of this, indicating whether the block
-/// is part of a landing pad or not. This is used to make decision about whether
-/// to emit `invoke` instructions (e.g. in a landing pad we don't continue to
-/// use `invoke`) and also about various function call metadata.
-///
-/// For GNU exceptions (`landingpad` + `resume` instructions) this structure is
-/// just a bunch of `None` instances (not too interesting), but for MSVC
-/// exceptions (`cleanuppad` + `cleanupret` instructions) this contains data.
-/// When inside of a landing pad, each function call in LLVM IR needs to be
-/// annotated with which landing pad it's a part of. This is accomplished via
-/// the `OperandBundleDef` value created for MSVC landing pads.
-pub struct Funclet<'ll, V> {
-    cleanuppad: V,
-    operand: OperandBundleDef<'ll, V>,
-}
-
-impl<'ll, V : CodegenObject> Funclet<'ll, V> {
-    pub fn new(cleanuppad: V) -> Self {
-        Funclet {
-            cleanuppad,
-            operand: OperandBundleDef::new("funclet", cleanuppad),
-        }
-    }
-
-    pub fn cleanuppad(&self) -> V {
-        self.cleanuppad
-    }
-
-    pub fn bundle(&self) -> &OperandBundleDef<'ll, V> {
-        &self.operand
-    }
-}
-
 impl Backend<'ll> for CodegenCx<'ll, 'tcx, &'ll Value> {
     type Value = &'ll Value;
     type BasicBlock = &'ll BasicBlock;

src/librustc_codegen_llvm/interfaces/mod.rs

@@ -32,13 +32,10 @@ pub use self::debuginfo::{DebugInfoMethods, DebugInfoBuilderMethods};
 pub use self::abi::{AbiMethods, AbiBuilderMethods};
 pub use self::declare::{DeclareMethods, PreDefineMethods};
 pub use self::asm::{AsmMethods, AsmBuilderMethods};
-
-use std::fmt;
+pub use rustc_codegen_utils::interfaces::CodegenObject;
 
 pub trait CodegenMethods<'ll, 'tcx: 'll> :
     Backend<'ll> + TypeMethods<'ll, 'tcx> + MiscMethods<'ll, 'tcx> + ConstMethods<'ll, 'tcx> +
     StaticMethods<'ll> + DebugInfoMethods<'ll, 'tcx> + AbiMethods<'tcx> +
     IntrinsicDeclarationMethods<'ll> + DeclareMethods<'ll, 'tcx> + AsmMethods +
     PreDefineMethods<'ll, 'tcx> {}
-
-pub trait CodegenObject : Copy + PartialEq + fmt::Debug {}

src/librustc_codegen_llvm/mir/mod.rs

@@ -16,7 +16,7 @@ use rustc::mir::{self, Mir};
 use rustc::ty::subst::Substs;
 use rustc::session::config::DebugInfo;
 use base;
-use common::Funclet;
+use rustc_codegen_utils::common::Funclet;
 use debuginfo::{self, VariableAccess, VariableKind, FunctionDebugContext};
 use monomorphize::Instance;
 use abi::{FnType, PassMode};

src/librustc_codegen_utils/common.rs

@@ -11,6 +11,7 @@
 
 use rustc::ty::{self, Ty, TyCtxt};
 use syntax_pos::DUMMY_SP;
+use interfaces::CodegenObject;
 
 
 pub fn type_needs_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool {
@@ -39,6 +40,44 @@ impl<'a, V> OperandBundleDef<'a, V> {
     }
 }
 
+
+
+/// A structure representing an active landing pad for the duration of a basic
+/// block.
+///
+/// Each `Block` may contain an instance of this, indicating whether the block
+/// is part of a landing pad or not. This is used to make decision about whether
+/// to emit `invoke` instructions (e.g. in a landing pad we don't continue to
+/// use `invoke`) and also about various function call metadata.
+///
+/// For GNU exceptions (`landingpad` + `resume` instructions) this structure is
+/// just a bunch of `None` instances (not too interesting), but for MSVC
+/// exceptions (`cleanuppad` + `cleanupret` instructions) this contains data.
+/// When inside of a landing pad, each function call in LLVM IR needs to be
+/// annotated with which landing pad it's a part of. This is accomplished via
+/// the `OperandBundleDef` value created for MSVC landing pads.
+pub struct Funclet<'ll, V> {
+    cleanuppad: V,
+    operand: OperandBundleDef<'ll, V>,
+}
+
+impl<'ll, V : CodegenObject> Funclet<'ll, V> {
+    pub fn new(cleanuppad: V) -> Self {
+        Funclet {
+            cleanuppad,
+            operand: OperandBundleDef::new("funclet", cleanuppad),
+        }
+    }
+
+    pub fn cleanuppad(&self) -> V {
+        self.cleanuppad
+    }
+
+    pub fn bundle(&self) -> &OperandBundleDef<'ll, V> {
+        &self.operand
+    }
+}
+
 pub enum IntPredicate {
     IntEQ,
     IntNE,

src/librustc_codegen_utils/interfaces/mod.rs

@@ -0,0 +1,13 @@
+// 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.
+
+use std::fmt;
+
+pub trait CodegenObject : Copy + PartialEq + fmt::Debug {}

src/librustc_codegen_utils/lib.rs

@@ -47,6 +47,7 @@ pub mod codegen_backend;
 pub mod symbol_names;
 pub mod symbol_names_test;
 pub mod common;
+pub mod interfaces;
 
 /// check for the #[rustc_error] annotation, which forces an
 /// error in codegen. This is used to write compile-fail tests