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;
  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>) -> Lvalue<'tcx> {
  31         let temp = self.local_decls.push(LocalDecl::new_temp(ty));
  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 = Constant {
  44             span: span,
  45             ty: ty,
  46             literal: literal,
  47         };
  48         Operand::Constant(constant)
  49     }
  50
  51     pub fn unit_rvalue(&mut self) -> Rvalue<'tcx> {
  52         Rvalue::Aggregate(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 => Literal::Value { value: ConstVal::Char('\0') },
  63             ty::TyUint(ity) => {
  64                 let val = match ity {
  65                     ast::UintTy::U8  => ConstInt::U8(0),
  66                     ast::UintTy::U16 => ConstInt::U16(0),
  67                     ast::UintTy::U32 => ConstInt::U32(0),
  68                     ast::UintTy::U64 => ConstInt::U64(0),
  69                     ast::UintTy::U128 => ConstInt::U128(0),
  70                     ast::UintTy::Us => {
  71                         let uint_ty = self.hir.tcx().sess.target.uint_type;
  72                         let val = ConstUsize::new(0, uint_ty).unwrap();
  73                         ConstInt::Usize(val)
  74                     }
  75                 };
  76
  77                 Literal::Value { value: ConstVal::Integral(val) }
  78             }
  79             ty::TyInt(ity) => {
  80                 let val = match ity {
  81                     ast::IntTy::I8  => ConstInt::I8(0),
  82                     ast::IntTy::I16 => ConstInt::I16(0),
  83                     ast::IntTy::I32 => ConstInt::I32(0),
  84                     ast::IntTy::I64 => ConstInt::I64(0),
  85                     ast::IntTy::I128 => ConstInt::I128(0),
  86                     ast::IntTy::Is => {
  87                         let int_ty = self.hir.tcx().sess.target.int_type;
  88                         let val = ConstIsize::new(0, int_ty).unwrap();
  89                         ConstInt::Isize(val)
  90                     }
  91                 };
  92
  93                 Literal::Value { value: ConstVal::Integral(val) }
  94             }
  95             _ => {
  96                 span_bug!(span, "Invalid type for zero_literal: `{:?}`", ty)
  97             }
  98         };
  99
 100         self.literal_operand(span, ty, literal)
 101     }
 102
 103     pub fn push_usize(&mut self,
 104                       block: BasicBlock,
 105                       source_info: SourceInfo,
 106                       value: u64)
 107                       -> Lvalue<'tcx> {
 108         let usize_ty = self.hir.usize_ty();
 109         let temp = self.temp(usize_ty);
 110         self.cfg.push_assign_constant(
 111             block, source_info, &temp,
 112             Constant {
 113                 span: source_info.span,
 114                 ty: self.hir.usize_ty(),
 115                 literal: self.hir.usize_literal(value),
 116             });
 117         temp
 118     }
 119 }