Moved common.rs enums

Author: denismerigoux

src/librustc_codegen_llvm/base.rs

@@ -53,8 +53,8 @@ use mir::place::PlaceRef;
 use builder::{Builder, MemFlags};
 use callee;
 use rustc_mir::monomorphize::item::DefPathBasedNames;
-use common::{self, RealPredicate, TypeKind};
-use rustc_codegen_utils::common::IntPredicate;
+use common;
+use rustc_codegen_utils::common::{RealPredicate, TypeKind, IntPredicate};
 use meth;
 use mir;
 use context::CodegenCx;

src/librustc_codegen_llvm/builder.rs

@@ -10,8 +10,9 @@
 
 use llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope, AsmDialect};
 use llvm::{self, False, OperandBundleDef, BasicBlock};
-use common::{self, *};
-use rustc_codegen_utils::common::IntPredicate;
+use common;
+use rustc_codegen_utils::common::{IntPredicate, TypeKind, RealPredicate};
+use rustc_codegen_utils;
 use context::CodegenCx;
 use type_::Type;
 use type_of::LayoutLlvmExt;
@@ -524,7 +525,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn atomic_load(
         &self,
         ptr: &'ll Value,
-        order: common::AtomicOrdering,
+        order: rustc_codegen_utils::common::AtomicOrdering,
         size: Size,
     ) -> &'ll Value {
         self.count_insn("load.atomic");
@@ -678,7 +679,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
    fn atomic_store(&self, val: &'ll Value, ptr: &'ll Value,
-                   order: common::AtomicOrdering, size: Size) {
+                   order: rustc_codegen_utils::common::AtomicOrdering, size: Size) {
         debug!("Store {:?} -> {:?}", val, ptr);
         self.count_insn("store.atomic");
         let ptr = self.check_store(val, ptr);
@@ -1201,8 +1202,8 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         dst: &'ll Value,
         cmp: &'ll Value,
         src: &'ll Value,
-        order: common::AtomicOrdering,
-        failure_order: common::AtomicOrdering,
+        order: rustc_codegen_utils::common::AtomicOrdering,
+        failure_order: rustc_codegen_utils::common::AtomicOrdering,
         weak: bool,
     ) -> &'ll Value {
         let weak = if weak { llvm::True } else { llvm::False };
@@ -1220,10 +1221,10 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
     fn atomic_rmw(
         &self,
-        op: common::AtomicRmwBinOp,
+        op: rustc_codegen_utils::common::AtomicRmwBinOp,
         dst: &'ll Value,
         src: &'ll Value,
-        order: common::AtomicOrdering,
+        order: rustc_codegen_utils::common::AtomicOrdering,
     ) -> &'ll Value {
         unsafe {
             llvm::LLVMBuildAtomicRMW(
@@ -1236,7 +1237,11 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn atomic_fence(&self, order: common::AtomicOrdering, scope: common::SynchronizationScope) {
+    fn atomic_fence(
+        &self,
+        order: rustc_codegen_utils::common::AtomicOrdering,
+        scope: rustc_codegen_utils::common::SynchronizationScope
+    ) {
         unsafe {
             llvm::LLVMRustBuildAtomicFence(
                 self.llbuilder,

src/librustc_codegen_llvm/common.rs

@@ -29,6 +29,7 @@ use rustc::mir::interpret::{Scalar, AllocType, Allocation};
 use rustc::hir;
 use mir::constant::const_alloc_to_llvm;
 use mir::place::PlaceRef;
+use rustc_codegen_utils::common::TypeKind;
 
 use libc::{c_uint, c_char};
 
@@ -64,81 +65,6 @@ impl<'a, V> OperandBundleDef<'a, V> {
     }
 }
 
-#[allow(dead_code)]
-pub enum RealPredicate {
-    RealPredicateFalse,
-    RealOEQ,
-    RealOGT,
-    RealOGE,
-    RealOLT,
-    RealOLE,
-    RealONE,
-    RealORD,
-    RealUNO,
-    RealUEQ,
-    RealUGT,
-    RealUGE,
-    RealULT,
-    RealULE,
-    RealUNE,
-    RealPredicateTrue
-}
-
-pub enum AtomicRmwBinOp {
-    AtomicXchg,
-    AtomicAdd,
-    AtomicSub,
-    AtomicAnd,
-    AtomicNand,
-    AtomicOr,
-    AtomicXor,
-    AtomicMax,
-    AtomicMin,
-    AtomicUMax,
-    AtomicUMin
-}
-
-pub enum AtomicOrdering {
-    #[allow(dead_code)]
-    NotAtomic,
-    Unordered,
-    Monotonic,
-    // Consume,  // Not specified yet.
-    Acquire,
-    Release,
-    AcquireRelease,
-    SequentiallyConsistent,
-}
-
-pub enum SynchronizationScope {
-    // FIXME: figure out if this variant is needed at all.
-    #[allow(dead_code)]
-    Other,
-    SingleThread,
-    CrossThread,
-}
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum TypeKind {
-    Void,
-    Half,
-    Float,
-    Double,
-    X86_FP80,
-    FP128,
-    PPc_FP128,
-    Label,
-    Integer,
-    Function,
-    Struct,
-    Array,
-    Pointer,
-    Vector,
-    Metadata,
-    X86_MMX,
-    Token,
-}
-
 /*
 * A note on nomenclature of linking: "extern", "foreign", and "upcall".
 *

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -20,7 +20,9 @@ use libc::c_char;
 use mir::operand::OperandRef;
 use mir::place::PlaceRef;
 use rustc::ty::layout::{Align, Size};
-use rustc_codegen_utils::common::IntPredicate;
+use rustc_codegen_utils::common::{
+    AtomicOrdering, AtomicRmwBinOp, IntPredicate, RealPredicate, SynchronizationScope,
+};
 
 use std::borrow::Cow;
 use std::ops::Range;

src/librustc_codegen_llvm/interfaces/type_.rs

@@ -10,12 +10,12 @@
 
 use super::backend::Backend;
 use super::HasCodegen;
-use common::TypeKind;
 use mir::place::PlaceRef;
 use rustc::ty::layout::TyLayout;
 use rustc::ty::layout::{self, Align, Size};
 use rustc::ty::Ty;
 use rustc::util::nodemap::FxHashMap;
+use rustc_codegen_utils::common::TypeKind;
 use rustc_target::abi::call::{ArgType, CastTarget, FnType, Reg};
 use std::cell::RefCell;
 use syntax::ast;

src/librustc_codegen_llvm/intrinsic.rs

@@ -18,13 +18,13 @@ use abi::{Abi, FnType, LlvmType, PassMode};
 use mir::place::PlaceRef;
 use mir::operand::{OperandRef, OperandValue};
 use base::*;
-use common::*;
 use context::CodegenCx;
 use glue;
 use type_::Type;
 use type_of::LayoutLlvmExt;
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::{LayoutOf, HasTyCtxt};
+use rustc_codegen_utils::common::TypeKind;
 use rustc::hir;
 use syntax::ast;
 use syntax::symbol::Symbol;
@@ -463,7 +463,9 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
             // This requires that atomic intrinsics follow a specific naming pattern:
             // "atomic_<operation>[_<ordering>]", and no ordering means SeqCst
             name if name.starts_with("atomic_") => {
-                use self::AtomicOrdering::*;
+                use rustc_codegen_utils::common::AtomicOrdering::*;
+                use rustc_codegen_utils::common::
+                    {SynchronizationScope, AtomicRmwBinOp};
 
                 let split: Vec<&str> = name.split('_').collect();
 

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -19,7 +19,6 @@ use libc::{c_uint, c_int, size_t, c_char};
 use libc::{c_ulonglong, c_void};
 
 use std::marker::PhantomData;
-use common;
 use rustc_codegen_utils;
 use syntax;
 
@@ -184,24 +183,26 @@ pub enum RealPredicate {
 }
 
 impl RealPredicate {
-    pub fn from_generic(realpred: common::RealPredicate) -> Self {
+    pub fn from_generic(realpred: rustc_codegen_utils::common::RealPredicate) -> Self {
         match realpred {
-            common::RealPredicate::RealPredicateFalse => RealPredicate::RealPredicateFalse,
-            common::RealPredicate::RealOEQ => RealPredicate::RealOEQ,
-            common::RealPredicate::RealOGT => RealPredicate::RealOGT,
-            common::RealPredicate::RealOGE => RealPredicate::RealOGE,
-            common::RealPredicate::RealOLT => RealPredicate::RealOLT,
-            common::RealPredicate::RealOLE => RealPredicate::RealOLE,
-            common::RealPredicate::RealONE => RealPredicate::RealONE,
-            common::RealPredicate::RealORD => RealPredicate::RealORD,
-            common::RealPredicate::RealUNO => RealPredicate::RealUNO,
-            common::RealPredicate::RealUEQ => RealPredicate::RealUEQ,
-            common::RealPredicate::RealUGT => RealPredicate::RealUGT,
-            common::RealPredicate::RealUGE => RealPredicate::RealUGE,
-            common::RealPredicate::RealULT => RealPredicate::RealULT,
-            common::RealPredicate::RealULE => RealPredicate::RealULE,
-            common::RealPredicate::RealUNE => RealPredicate::RealUNE,
-            common::RealPredicate::RealPredicateTrue => RealPredicate::RealPredicateTrue
+            rustc_codegen_utils::common::RealPredicate::RealPredicateFalse =>
+                RealPredicate::RealPredicateFalse,
+            rustc_codegen_utils::common::RealPredicate::RealOEQ => RealPredicate::RealOEQ,
+            rustc_codegen_utils::common::RealPredicate::RealOGT => RealPredicate::RealOGT,
+            rustc_codegen_utils::common::RealPredicate::RealOGE => RealPredicate::RealOGE,
+            rustc_codegen_utils::common::RealPredicate::RealOLT => RealPredicate::RealOLT,
+            rustc_codegen_utils::common::RealPredicate::RealOLE => RealPredicate::RealOLE,
+            rustc_codegen_utils::common::RealPredicate::RealONE => RealPredicate::RealONE,
+            rustc_codegen_utils::common::RealPredicate::RealORD => RealPredicate::RealORD,
+            rustc_codegen_utils::common::RealPredicate::RealUNO => RealPredicate::RealUNO,
+            rustc_codegen_utils::common::RealPredicate::RealUEQ => RealPredicate::RealUEQ,
+            rustc_codegen_utils::common::RealPredicate::RealUGT => RealPredicate::RealUGT,
+            rustc_codegen_utils::common::RealPredicate::RealUGE => RealPredicate::RealUGE,
+            rustc_codegen_utils::common::RealPredicate::RealULT => RealPredicate::RealULT,
+            rustc_codegen_utils::common::RealPredicate::RealULE => RealPredicate::RealULE,
+            rustc_codegen_utils::common::RealPredicate::RealUNE => RealPredicate::RealUNE,
+            rustc_codegen_utils::common::RealPredicate::RealPredicateTrue =>
+                RealPredicate::RealPredicateTrue
         }
     }
 }
@@ -216,7 +217,7 @@ pub enum TypeKind {
     Double = 3,
     X86_FP80 = 4,
     FP128 = 5,
-    PPc_FP128 = 6,
+    PPC_FP128 = 6,
     Label = 7,
     Integer = 8,
     Function = 9,
@@ -230,25 +231,25 @@ pub enum TypeKind {
 }
 
 impl TypeKind {
-    pub fn to_generic(self) -> common::TypeKind {
+    pub fn to_generic(self) -> rustc_codegen_utils::common::TypeKind {
         match self {
-            TypeKind::Void => common::TypeKind::Void,
-            TypeKind::Half => common::TypeKind::Half,
-            TypeKind::Float => common::TypeKind::Float,
-            TypeKind::Double => common::TypeKind::Double,
-            TypeKind::X86_FP80 => common::TypeKind::X86_FP80,
-            TypeKind::FP128 => common::TypeKind::FP128,
-            TypeKind::PPc_FP128 => common::TypeKind::PPc_FP128,
-            TypeKind::Label => common::TypeKind::Label,
-            TypeKind::Integer => common::TypeKind::Integer,
-            TypeKind::Function => common::TypeKind::Function,
-            TypeKind::Struct => common::TypeKind::Struct,
-            TypeKind::Array => common::TypeKind::Array,
-            TypeKind::Pointer => common::TypeKind::Pointer,
-            TypeKind::Vector => common::TypeKind::Vector,
-            TypeKind::Metadata => common::TypeKind::Metadata,
-            TypeKind::X86_MMX => common::TypeKind::X86_MMX,
-            TypeKind::Token => common::TypeKind::Token,
+            TypeKind::Void => rustc_codegen_utils::common::TypeKind::Void,
+            TypeKind::Half => rustc_codegen_utils::common::TypeKind::Half,
+            TypeKind::Float => rustc_codegen_utils::common::TypeKind::Float,
+            TypeKind::Double => rustc_codegen_utils::common::TypeKind::Double,
+            TypeKind::X86_FP80 => rustc_codegen_utils::common::TypeKind::X86_FP80,
+            TypeKind::FP128 => rustc_codegen_utils::common::TypeKind::FP128,
+            TypeKind::PPC_FP128 => rustc_codegen_utils::common::TypeKind::PPC_FP128,
+            TypeKind::Label => rustc_codegen_utils::common::TypeKind::Label,
+            TypeKind::Integer => rustc_codegen_utils::common::TypeKind::Integer,
+            TypeKind::Function => rustc_codegen_utils::common::TypeKind::Function,
+            TypeKind::Struct => rustc_codegen_utils::common::TypeKind::Struct,
+            TypeKind::Array => rustc_codegen_utils::common::TypeKind::Array,
+            TypeKind::Pointer => rustc_codegen_utils::common::TypeKind::Pointer,
+            TypeKind::Vector => rustc_codegen_utils::common::TypeKind::Vector,
+            TypeKind::Metadata => rustc_codegen_utils::common::TypeKind::Metadata,
+            TypeKind::X86_MMX => rustc_codegen_utils::common::TypeKind::X86_MMX,
+            TypeKind::Token => rustc_codegen_utils::common::TypeKind::Token,
         }
     }
 }
@@ -271,19 +272,19 @@ pub enum AtomicRmwBinOp {
 }
 
 impl AtomicRmwBinOp {
-    pub fn from_generic(op: common::AtomicRmwBinOp) -> Self {
+    pub fn from_generic(op: rustc_codegen_utils::common::AtomicRmwBinOp) -> Self {
         match op {
-            common::AtomicRmwBinOp::AtomicXchg => AtomicRmwBinOp::AtomicXchg,
-            common::AtomicRmwBinOp::AtomicAdd => AtomicRmwBinOp::AtomicAdd,
-            common::AtomicRmwBinOp::AtomicSub => AtomicRmwBinOp::AtomicSub,
-            common::AtomicRmwBinOp::AtomicAnd => AtomicRmwBinOp::AtomicAnd,
-            common::AtomicRmwBinOp::AtomicNand => AtomicRmwBinOp::AtomicNand,
-            common::AtomicRmwBinOp::AtomicOr => AtomicRmwBinOp::AtomicOr,
-            common::AtomicRmwBinOp::AtomicXor => AtomicRmwBinOp::AtomicXor,
-            common::AtomicRmwBinOp::AtomicMax => AtomicRmwBinOp::AtomicMax,
-            common::AtomicRmwBinOp::AtomicMin => AtomicRmwBinOp::AtomicMin,
-            common::AtomicRmwBinOp::AtomicUMax => AtomicRmwBinOp::AtomicUMax,
-            common::AtomicRmwBinOp::AtomicUMin => AtomicRmwBinOp::AtomicUMin
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicXchg => AtomicRmwBinOp::AtomicXchg,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicAdd => AtomicRmwBinOp::AtomicAdd,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicSub => AtomicRmwBinOp::AtomicSub,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicAnd => AtomicRmwBinOp::AtomicAnd,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicNand => AtomicRmwBinOp::AtomicNand,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicOr => AtomicRmwBinOp::AtomicOr,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicXor => AtomicRmwBinOp::AtomicXor,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicMax => AtomicRmwBinOp::AtomicMax,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicMin => AtomicRmwBinOp::AtomicMin,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicUMax => AtomicRmwBinOp::AtomicUMax,
+            rustc_codegen_utils::common::AtomicRmwBinOp::AtomicUMin => AtomicRmwBinOp::AtomicUMin
         }
     }
 }
@@ -304,15 +305,16 @@ pub enum AtomicOrdering {
 }
 
 impl AtomicOrdering {
-    pub fn from_generic(ao: common::AtomicOrdering) -> Self {
+    pub fn from_generic(ao: rustc_codegen_utils::common::AtomicOrdering) -> Self {
         match ao {
-            common::AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
-            common::AtomicOrdering::Unordered => AtomicOrdering::Unordered,
-            common::AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
-            common::AtomicOrdering::Acquire => AtomicOrdering::Acquire,
-            common::AtomicOrdering::Release => AtomicOrdering::Release,
-            common::AtomicOrdering::AcquireRelease => AtomicOrdering::AcquireRelease,
-            common::AtomicOrdering::SequentiallyConsistent =>
+            rustc_codegen_utils::common::AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
+            rustc_codegen_utils::common::AtomicOrdering::Unordered => AtomicOrdering::Unordered,
+            rustc_codegen_utils::common::AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
+            rustc_codegen_utils::common::AtomicOrdering::Acquire => AtomicOrdering::Acquire,
+            rustc_codegen_utils::common::AtomicOrdering::Release => AtomicOrdering::Release,
+            rustc_codegen_utils::common::AtomicOrdering::AcquireRelease =>
+                AtomicOrdering::AcquireRelease,
+            rustc_codegen_utils::common::AtomicOrdering::SequentiallyConsistent =>
                 AtomicOrdering::SequentiallyConsistent
         }
     }
@@ -331,11 +333,13 @@ pub enum SynchronizationScope {
 }
 
 impl SynchronizationScope {
-    pub fn from_generic(sc: common::SynchronizationScope) -> Self {
+    pub fn from_generic(sc: rustc_codegen_utils::common::SynchronizationScope) -> Self {
         match sc {
-            common::SynchronizationScope::Other => SynchronizationScope::Other,
-            common::SynchronizationScope::SingleThread => SynchronizationScope::SingleThread,
-            common::SynchronizationScope::CrossThread => SynchronizationScope::CrossThread,
+            rustc_codegen_utils::common::SynchronizationScope::Other => SynchronizationScope::Other,
+            rustc_codegen_utils::common::SynchronizationScope::SingleThread =>
+                SynchronizationScope::SingleThread,
+            rustc_codegen_utils::common::SynchronizationScope::CrossThread =>
+                SynchronizationScope::CrossThread,
         }
     }
 }