src/librustc_mir/build/misc.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Miscellaneous builder routines that are not specific to building any particular
  12 //! kind of thing.
  13
  14 use build::Builder;
  15
  16 use rustc_const_math::{ConstInt, ConstUsize, ConstIsize};
  17 use rustc::middle::const_val::ConstVal;
  18 use rustc::ty::{self, Ty};
  19
  20 use rustc::mir::*;
  21 use syntax::ast;
  22 use syntax_pos::{Span, DUMMY_SP};
  23
  24 impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
  25     /// Add a new temporary value of type `ty` storing the result of
  26     /// evaluating `expr`.
  27     ///
  28     /// NB: **No cleanup is scheduled for this temporary.** You should
  29     /// call `schedule_drop` once the temporary is initialized.
  30     pub fn temp(&mut self, ty: Ty<'tcx>, span: Span) -> Lvalue<'tcx> {
  31         let temp = self.local_decls.push(LocalDecl::new_temp(ty, span));
  32         let lvalue = Lvalue::Local(temp);
  33         debug!("temp: created temp {:?} with type {:?}",
  34                lvalue, self.local_decls[temp].ty);
  35         lvalue
  36     }
  37
  38     pub fn literal_operand(&mut self,
  39                            span: Span,
  40                            ty: Ty<'tcx>,
  41                            literal: Literal<'tcx>)
  42                            -> Operand<'tcx> {
  43         let constant = box Constant {
  44             span,
  45             ty,
  46             literal,
  47         };
  48         Operand::Constant(constant)
  49     }
  50
  51     pub fn unit_rvalue(&mut self) -> Rvalue<'tcx> {
  52         Rvalue::Aggregate(box AggregateKind::Tuple, vec![])
  53     }
  54
  55     // Returns a zero literal operand for the appropriate type, works for
  56     // bool, char and integers.
  57     pub fn zero_literal(&mut self, span: Span, ty: Ty<'tcx>) -> Operand<'tcx> {
  58         let literal = match ty.sty {
  59             ty::TyBool => {
  60                 self.hir.false_literal()
  61             }
  62             ty::TyChar => {
  63                 Literal::Value {
  64                     value: self.hir.tcx().mk_const(ty::Const {
  65                         val: ConstVal::Char('\0'),
  66                         ty
  67                     })
  68                 }
  69             }
  70             ty::TyUint(ity) => {
  71                 let val = match ity {
  72                     ast::UintTy::U8  => ConstInt::U8(0),
  73                     ast::UintTy::U16 => ConstInt::U16(0),
  74                     ast::UintTy::U32 => ConstInt::U32(0),
  75                     ast::UintTy::U64 => ConstInt::U64(0),
  76                     ast::UintTy::U128 => ConstInt::U128(0),
  77                     ast::UintTy::Us => {
  78                         let uint_ty = self.hir.tcx().sess.target.usize_ty;
  79                         let val = ConstUsize::new(0, uint_ty).unwrap();
  80                         ConstInt::Usize(val)
  81                     }
  82                 };
  83
  84                 Literal::Value {
  85                     value: self.hir.tcx().mk_const(ty::Const {
  86                         val: ConstVal::Integral(val),
  87                         ty
  88                     })
  89                 }
  90             }
  91             ty::TyInt(ity) => {
  92                 let val = match ity {
  93                     ast::IntTy::I8  => ConstInt::I8(0),
  94                     ast::IntTy::I16 => ConstInt::I16(0),
  95                     ast::IntTy::I32 => ConstInt::I32(0),
  96                     ast::IntTy::I64 => ConstInt::I64(0),
  97                     ast::IntTy::I128 => ConstInt::I128(0),
  98                     ast::IntTy::Is => {
  99                         let int_ty = self.hir.tcx().sess.target.isize_ty;
 100                         let val = ConstIsize::new(0, int_ty).unwrap();
 101                         ConstInt::Isize(val)
 102                     }
 103                 };
 104
 105                 Literal::Value {
 106                     value: self.hir.tcx().mk_const(ty::Const {
 107                         val: ConstVal::Integral(val),
 108                         ty
 109                     })
 110                 }
 111             }
 112             _ => {
 113                 span_bug!(span, "Invalid type for zero_literal: `{:?}`", ty)
 114             }
 115         };
 116
 117         self.literal_operand(span, ty, literal)
 118     }
 119
 120     pub fn push_usize(&mut self,
 121                       block: BasicBlock,
 122                       source_info: SourceInfo,
 123                       value: u64)
 124                       -> Lvalue<'tcx> {
 125         let usize_ty = self.hir.usize_ty();
 126         let temp = self.temp(usize_ty, source_info.span);
 127         self.cfg.push_assign_constant(
 128             block, source_info, &temp,
 129             Constant {
 130                 span: source_info.span,
 131                 ty: self.hir.usize_ty(),
 132                 literal: self.hir.usize_literal(value),
 133             });
 134         temp
 135     }
 136
 137     pub fn consume_by_copy_or_move(&self, lvalue: Lvalue<'tcx>) -> Operand<'tcx> {
 138         let tcx = self.hir.tcx();
 139         let ty = lvalue.ty(&self.local_decls, tcx).to_ty(tcx);
 140         if self.hir.type_moves_by_default(ty, DUMMY_SP) {
 141             Operand::Move(lvalue)
 142         } else {
 143             Operand::Copy(lvalue)
 144         }
 145     }
 146 }