src/librustc_codegen_ssa/common.rs

   1 #![allow(non_camel_case_types, non_snake_case)]
   2
   3 use rustc::ty::{Ty, TyCtxt};
   4 use syntax_pos::Span;
   5
   6 use rustc::hir::def_id::DefId;
   7 use rustc::middle::lang_items::LangItem;
   8 use crate::base;
   9 use crate::traits::*;
  10
  11 use rustc::hir;
  12 use crate::traits::BuilderMethods;
  13
  14 pub enum IntPredicate {
  15     IntEQ,
  16     IntNE,
  17     IntUGT,
  18     IntUGE,
  19     IntULT,
  20     IntULE,
  21     IntSGT,
  22     IntSGE,
  23     IntSLT,
  24     IntSLE
  25 }
  26
  27
  28 #[allow(dead_code)]
  29 pub enum RealPredicate {
  30     RealPredicateFalse,
  31     RealOEQ,
  32     RealOGT,
  33     RealOGE,
  34     RealOLT,
  35     RealOLE,
  36     RealONE,
  37     RealORD,
  38     RealUNO,
  39     RealUEQ,
  40     RealUGT,
  41     RealUGE,
  42     RealULT,
  43     RealULE,
  44     RealUNE,
  45     RealPredicateTrue
  46 }
  47
  48 pub enum AtomicRmwBinOp {
  49     AtomicXchg,
  50     AtomicAdd,
  51     AtomicSub,
  52     AtomicAnd,
  53     AtomicNand,
  54     AtomicOr,
  55     AtomicXor,
  56     AtomicMax,
  57     AtomicMin,
  58     AtomicUMax,
  59     AtomicUMin
  60 }
  61
  62 pub enum AtomicOrdering {
  63     #[allow(dead_code)]
  64     NotAtomic,
  65     Unordered,
  66     Monotonic,
  67     // Consume,  // Not specified yet.
  68     Acquire,
  69     Release,
  70     AcquireRelease,
  71     SequentiallyConsistent,
  72 }
  73
  74 pub enum SynchronizationScope {
  75     // FIXME: figure out if this variant is needed at all.
  76     #[allow(dead_code)]
  77     Other,
  78     SingleThread,
  79     CrossThread,
  80 }
  81
  82 #[derive(Copy, Clone, PartialEq, Debug)]
  83 pub enum TypeKind {
  84     Void,
  85     Half,
  86     Float,
  87     Double,
  88     X86_FP80,
  89     FP128,
  90     PPC_FP128,
  91     Label,
  92     Integer,
  93     Function,
  94     Struct,
  95     Array,
  96     Pointer,
  97     Vector,
  98     Metadata,
  99     X86_MMX,
 100     Token,
 101 }
 102
 103 // FIXME(mw): Anything that is produced via DepGraph::with_task() must implement
 104 //            the HashStable trait. Normally DepGraph::with_task() calls are
 105 //            hidden behind queries, but CGU creation is a special case in two
 106 //            ways: (1) it's not a query and (2) CGU are output nodes, so their
 107 //            Fingerprints are not actually needed. It remains to be clarified
 108 //            how exactly this case will be handled in the red/green system but
 109 //            for now we content ourselves with providing a no-op HashStable
 110 //            implementation for CGUs.
 111 mod temp_stable_hash_impls {
 112     use rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher,
 113                                                HashStable};
 114     use crate::ModuleCodegen;
 115
 116     impl<HCX, M> HashStable<HCX> for ModuleCodegen<M> {
 117         fn hash_stable<W: StableHasherResult>(&self,
 118                                               _: &mut HCX,
 119                                               _: &mut StableHasher<W>) {
 120             // do nothing
 121         }
 122     }
 123 }
 124
 125 pub fn langcall(tcx: TyCtxt<'_, '_, '_>,
 126                 span: Option<Span>,
 127                 msg: &str,
 128                 li: LangItem)
 129                 -> DefId {
 130     tcx.lang_items().require(li).unwrap_or_else(|s| {
 131         let msg = format!("{} {}", msg, s);
 132         match span {
 133             Some(span) => tcx.sess.span_fatal(span, &msg[..]),
 134             None => tcx.sess.fatal(&msg[..]),
 135         }
 136     })
 137 }
 138
 139 // To avoid UB from LLVM, these two functions mask RHS with an
 140 // appropriate mask unconditionally (i.e., the fallback behavior for
 141 // all shifts). For 32- and 64-bit types, this matches the semantics
 142 // of Java. (See related discussion on #1877 and #10183.)
 143
 144 pub fn build_unchecked_lshift<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
 145     bx: &mut Bx,
 146     lhs: Bx::Value,
 147     rhs: Bx::Value
 148 ) -> Bx::Value {
 149     let rhs = base::cast_shift_expr_rhs(bx, hir::BinOpKind::Shl, lhs, rhs);
 150     // #1877, #10183: Ensure that input is always valid
 151     let rhs = shift_mask_rhs(bx, rhs);
 152     bx.shl(lhs, rhs)
 153 }
 154
 155 pub fn build_unchecked_rshift<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
 156     bx: &mut Bx,
 157     lhs_t: Ty<'tcx>,
 158     lhs: Bx::Value,
 159     rhs: Bx::Value
 160 ) -> Bx::Value {
 161     let rhs = base::cast_shift_expr_rhs(bx, hir::BinOpKind::Shr, lhs, rhs);
 162     // #1877, #10183: Ensure that input is always valid
 163     let rhs = shift_mask_rhs(bx, rhs);
 164     let is_signed = lhs_t.is_signed();
 165     if is_signed {
 166         bx.ashr(lhs, rhs)
 167     } else {
 168         bx.lshr(lhs, rhs)
 169     }
 170 }
 171
 172 fn shift_mask_rhs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
 173     bx: &mut Bx,
 174     rhs: Bx::Value
 175 ) -> Bx::Value {
 176     let rhs_llty = bx.val_ty(rhs);
 177     let shift_val = shift_mask_val(bx, rhs_llty, rhs_llty, false);
 178     bx.and(rhs, shift_val)
 179 }
 180
 181 pub fn shift_mask_val<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
 182     bx: &mut Bx,
 183     llty: Bx::Type,
 184     mask_llty: Bx::Type,
 185     invert: bool
 186 ) -> Bx::Value {
 187     let kind = bx.type_kind(llty);
 188     match kind {
 189         TypeKind::Integer => {
 190             // i8/u8 can shift by at most 7, i16/u16 by at most 15, etc.
 191             let val = bx.int_width(llty) - 1;
 192             if invert {
 193                 bx.const_int(mask_llty, !val as i64)
 194             } else {
 195                 bx.const_uint(mask_llty, val)
 196             }
 197         },
 198         TypeKind::Vector => {
 199             let mask = shift_mask_val(
 200                 bx,
 201                 bx.element_type(llty),
 202                 bx.element_type(mask_llty),
 203                 invert
 204             );
 205             bx.vector_splat(bx.vector_length(mask_llty), mask)
 206         },
 207         _ => bug!("shift_mask_val: expected Integer or Vector, found {:?}", kind),
 208     }
 209 }