1 // Copyright 2012-2014 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.
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.
11 use llvm::{self, ValueRef};
12 use rustc::mir::interpret::ConstEvalErr;
13 use rustc_mir::interpret::{read_target_uint, const_val_field};
14 use rustc::hir::def_id::DefId;
16 use rustc_data_structures::indexed_vec::Idx;
17 use rustc_data_structures::sync::Lrc;
18 use rustc::mir::interpret::{GlobalId, Pointer, Scalar, Allocation, ConstValue, AllocType};
19 use rustc::ty::{self, Ty};
20 use rustc::ty::layout::{self, HasDataLayout, LayoutOf, Size};
22 use common::{CodegenCx};
23 use common::{C_bytes, C_struct, C_uint_big, C_undef, C_usize};
25 use type_of::LayoutLlvmExt;
27 use syntax::ast::Mutability;
28 use syntax::codemap::Span;
30 use super::super::callee;
31 use super::FunctionCx;
33 pub fn scalar_to_llvm(cx: &CodegenCx,
35 layout: &layout::Scalar,
36 llty: &Type) -> ValueRef {
37 let bitsize = if layout.is_bool() { 1 } else { layout.value.size(cx).bits() };
39 Scalar::Bits { defined, .. } if (defined as u64) < bitsize || defined == 0 => {
40 C_undef(Type::ix(cx, bitsize))
42 Scalar::Bits { bits, .. } => {
43 let llval = C_uint_big(Type::ix(cx, bitsize), bits);
44 if layout.value == layout::Pointer {
45 unsafe { llvm::LLVMConstIntToPtr(llval, llty) }
47 consts::bitcast(llval, llty)
51 let alloc_type = cx.tcx.alloc_map.lock().get(ptr.alloc_id);
52 let base_addr = match alloc_type {
53 Some(AllocType::Memory(alloc)) => {
54 let init = const_alloc_to_llvm(cx, alloc);
55 if alloc.runtime_mutability == Mutability::Mutable {
56 consts::addr_of_mut(cx, init, alloc.align, "byte_str")
58 consts::addr_of(cx, init, alloc.align, "byte_str")
61 Some(AllocType::Function(fn_instance)) => {
62 callee::get_fn(cx, fn_instance)
64 Some(AllocType::Static(def_id)) => {
65 assert!(cx.tcx.is_static(def_id).is_some());
66 consts::get_static(cx, def_id)
68 None => bug!("missing allocation {:?}", ptr.alloc_id),
70 let llval = unsafe { llvm::LLVMConstInBoundsGEP(
71 consts::bitcast(base_addr, Type::i8p(cx)),
72 &C_usize(cx, ptr.offset.bytes()),
75 if layout.value != layout::Pointer {
76 unsafe { llvm::LLVMConstPtrToInt(llval, llty) }
78 consts::bitcast(llval, llty)
84 pub fn const_alloc_to_llvm(cx: &CodegenCx, alloc: &Allocation) -> ValueRef {
85 let mut llvals = Vec::with_capacity(alloc.relocations.len() + 1);
86 let layout = cx.data_layout();
87 let pointer_size = layout.pointer_size.bytes() as usize;
89 let mut next_offset = 0;
90 for &(offset, alloc_id) in alloc.relocations.iter() {
91 let offset = offset.bytes();
92 assert_eq!(offset as usize as u64, offset);
93 let offset = offset as usize;
94 if offset > next_offset {
95 llvals.push(C_bytes(cx, &alloc.bytes[next_offset..offset]));
97 let ptr_offset = read_target_uint(
99 &alloc.bytes[offset..(offset + pointer_size)],
100 ).expect("const_alloc_to_llvm: could not read relocation pointer") as u64;
101 llvals.push(scalar_to_llvm(
103 Pointer { alloc_id, offset: Size::from_bytes(ptr_offset) }.into(),
105 value: layout::Primitive::Pointer,
110 next_offset = offset + pointer_size;
112 if alloc.bytes.len() >= next_offset {
113 llvals.push(C_bytes(cx, &alloc.bytes[next_offset ..]));
116 C_struct(cx, &llvals, true)
119 pub fn codegen_static_initializer<'a, 'tcx>(
120 cx: &CodegenCx<'a, 'tcx>,
122 ) -> Result<(ValueRef, &'tcx Allocation), Lrc<ConstEvalErr<'tcx>>> {
123 let instance = ty::Instance::mono(cx.tcx, def_id);
128 let param_env = ty::ParamEnv::reveal_all();
129 let static_ = cx.tcx.const_eval(param_env.and(cid))?;
131 let alloc = match static_.val {
132 ConstValue::ByRef(alloc, n) if n.bytes() == 0 => alloc,
133 _ => bug!("static const eval returned {:#?}", static_),
135 Ok((const_alloc_to_llvm(cx, alloc), alloc))
138 impl FunctionCx<'a, 'll, 'tcx> {
141 bx: &Builder<'a, 'll, 'tcx>,
142 constant: &'tcx ty::Const<'tcx>,
143 ) -> Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>> {
145 ConstValue::Unevaluated(def_id, ref substs) => {
147 let param_env = ty::ParamEnv::reveal_all();
148 let instance = ty::Instance::resolve(tcx, param_env, def_id, substs).unwrap();
153 tcx.const_eval(param_env.and(cid))
159 pub fn eval_mir_constant(
161 bx: &Builder<'a, 'll, 'tcx>,
162 constant: &mir::Constant<'tcx>,
163 ) -> Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>> {
164 let c = self.monomorphize(&constant.literal);
165 self.fully_evaluate(bx, c)
168 /// process constant containing SIMD shuffle indices
169 pub fn simd_shuffle_indices(
171 bx: &Builder<'a, 'll, 'tcx>,
174 constant: Result<&'tcx ty::Const<'tcx>, Lrc<ConstEvalErr<'tcx>>>,
175 ) -> (ValueRef, Ty<'tcx>) {
178 let field_ty = c.ty.builtin_index().unwrap();
179 let fields = match c.ty.sty {
180 ty::TyArray(_, n) => n.unwrap_usize(bx.tcx()),
181 ref other => bug!("invalid simd shuffle type: {}", other),
183 let values: Result<Vec<ValueRef>, Lrc<_>> = (0..fields).map(|field| {
184 let field = const_val_field(
186 ty::ParamEnv::reveal_all(),
189 mir::Field::new(field as usize),
192 if let Some(prim) = field.to_scalar() {
193 let layout = bx.cx.layout_of(field_ty);
194 let scalar = match layout.abi {
195 layout::Abi::Scalar(ref x) => x,
196 _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
200 layout.immediate_llvm_type(bx.cx),
203 bug!("simd shuffle field {:?}", field)
206 let llval = C_struct(bx.cx, &values?, false);
209 .unwrap_or_else(|e| {
212 "could not evaluate shuffle_indices at compile time",
214 // We've errored, so we don't have to produce working code.
215 let ty = self.monomorphize(&ty);
216 let llty = bx.cx.layout_of(ty).llvm_type(bx.cx);