src/librustc_codegen_ssa/common.rs

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