abort, panic and print

Author: oli-obk

src/error.rs

@@ -52,6 +52,11 @@ pub enum EvalError<'tcx> {
     ReallocatedFrozenMemory,
     DeallocatedFrozenMemory,
     Layout(layout::LayoutError<'tcx>),
+    Abort,
+    Panic {
+        file: String,
+        line: u32,
+    },
 }
 
 pub type EvalResult<'tcx, T> = Result<T, EvalError<'tcx>>;
@@ -122,6 +127,10 @@ impl<'tcx> Error for EvalError<'tcx> {
                 "rustc layout computation failed",
             EvalError::UnterminatedCString(_) =>
                 "attempted to get length of a null terminated string, but no null found before end of allocation",
+            EvalError::Abort =>
+                "`abort` intrinsic reached",
+            EvalError::Panic { .. } =>
+                "panic!",
         }
     }
 
@@ -154,6 +163,8 @@ impl<'tcx> fmt::Display for EvalError<'tcx> {
                 write!(f, "expected primitive type, got {}", ty),
             EvalError::Layout(ref err) =>
                 write!(f, "rustc layout computation failed: {:?}", err),
+            EvalError::Panic { ref file, line } =>
+                write!(f, "panicked at {}:{}", file, line),
             _ => write!(f, "{}", self.description()),
         }
     }

src/eval_context.rs

@@ -43,6 +43,10 @@ pub struct EvalContext<'a, 'tcx: 'a> {
     /// This prevents infinite loops and huge computations from freezing up const eval.
     /// Remove once halting problem is solved.
     pub(super) steps_remaining: u64,
+
+    // FIXME: also add destructors
+    pub(super) pthread: HashMap<i32, Pointer>,
+    pub(super) next_pthread_key: i32,
 }
 
 /// A stack frame.
@@ -137,6 +141,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             stack: Vec::new(),
             stack_limit: limits.stack_limit,
             steps_remaining: limits.step_limit,
+            pthread: HashMap::new(),
+            next_pthread_key: 0,
         }
     }
 

src/step.rs

@@ -14,6 +14,8 @@ use error::{EvalResult, EvalError};
 use eval_context::{EvalContext, StackPopCleanup, MirRef};
 use lvalue::{Global, GlobalId, Lvalue};
 use syntax::codemap::Span;
+use syntax::attr;
+use value::{Value, PrimVal};
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     pub fn inc_step_counter_and_check_limit(&mut self, n: u64) -> EvalResult<'tcx, ()> {
@@ -124,6 +126,13 @@ struct ConstantExtractor<'a, 'b: 'a, 'tcx: 'b> {
 }
 
 impl<'a, 'b, 'tcx> ConstantExtractor<'a, 'b, 'tcx> {
+    fn weak_linkage(&self, def_id: DefId) -> bool {
+        let attributes = self.ecx.tcx.get_attrs(def_id);
+        let attr = attr::first_attr_value_str_by_name(&attributes, "linkage");
+        trace!("linkage: {:?}", attr);
+        attr.map_or(false, |name| &*name.as_str() == "weak" || &*name.as_str() == "extern_weak")
+    }
+
     fn global_item(&mut self, def_id: DefId, substs: &'tcx subst::Substs<'tcx>, span: Span, immutable: bool) {
         let cid = GlobalId {
             def_id: def_id,
@@ -133,15 +142,34 @@ impl<'a, 'b, 'tcx> ConstantExtractor<'a, 'b, 'tcx> {
         if self.ecx.globals.contains_key(&cid) {
             return;
         }
+        let ty = self.ecx.tcx.item_type(def_id);
+        let immutable = immutable && !ty.type_contents(self.ecx.tcx).interior_unsafe();
         self.try(|this| {
-            let mir = this.ecx.load_mir(def_id)?;
-            this.ecx.globals.insert(cid, Global::uninitialized(mir.return_ty));
-            let cleanup = if immutable && !mir.return_ty.type_contents(this.ecx.tcx).interior_unsafe() {
-                StackPopCleanup::Freeze
+            if this.weak_linkage(def_id) {
+                let data = match this.ecx.type_size(ty)?.expect("statics/consts can't be unsized") {
+                    0...8 => Value::ByVal(PrimVal::new(0)),
+                    n => {
+                        let ptr = this.ecx.memory.allocate(n, 1)?;
+                        this.ecx.memory.write_repeat(ptr, 0, n)?;
+                        Value::ByRef(ptr)
+                    },
+                };
+                this.ecx.globals.insert(cid, Global {
+                    data: Some(data),
+                    mutable: !immutable,
+                    ty: ty,
+                });
+                Ok(())
             } else {
-                StackPopCleanup::None
-            };
-            this.ecx.push_stack_frame(def_id, span, mir, substs, Lvalue::Global(cid), cleanup, Vec::new())
+                this.ecx.globals.insert(cid, Global::uninitialized(ty));
+                let cleanup = if immutable {
+                    StackPopCleanup::Freeze
+                } else {
+                    StackPopCleanup::None
+                };
+                let mir = this.ecx.load_mir(def_id)?;
+                this.ecx.push_stack_frame(def_id, span, mir, substs, Lvalue::Global(cid), cleanup, Vec::new())
+            }
         });
     }
     fn try<F: FnOnce(&mut Self) -> EvalResult<'tcx, ()>>(&mut self, f: F) {

src/terminator/mod.rs

@@ -15,6 +15,8 @@ use memory::Pointer;
 use value::PrimVal;
 use value::Value;
 
+use std::str::from_utf8;
+
 mod intrinsic;
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
@@ -200,14 +202,37 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             Abi::RustIntrinsic => {
                 let ty = fn_ty.sig.0.output();
                 let layout = self.type_layout(ty)?;
-                let (ret, target) = destination.unwrap();
+                let (ret, target) = match destination {
+                    Some(dest) => dest,
+                    None => {
+                        assert_eq!(&self.tcx.item_name(def_id).as_str()[..], "abort");
+                        return Err(EvalError::Abort);
+                    }
+                };
                 self.call_intrinsic(def_id, substs, arg_operands, ret, ty, layout, target)?;
                 Ok(())
             }
 
             Abi::C => {
                 let ty = fn_ty.sig.0.output();
-                let (ret, target) = destination.unwrap();
+                let (ret, target) = match destination {
+                    Some(dest) => dest,
+                    None => {
+                        assert_eq!(&self.tcx.item_name(def_id).as_str()[..], "panic_impl");
+                        let args_res: EvalResult<Vec<Value>> = arg_operands.iter()
+                            .map(|arg| self.eval_operand(arg)?.ok_or(EvalError::ReadUndefBytes))
+                            .collect();
+                        let args = args_res?;
+                        // FIXME: process panic text
+                        let file_slice = args[1].expect_slice(&self.memory)?;
+                        let file = from_utf8(self.memory.read_bytes(file_slice.0, file_slice.1)?)
+                            .expect("panic message not utf8")
+                            .to_owned();
+                        let u32 = self.tcx.types.u32;
+                        let line = self.value_to_primval(args[2], u32)?.to_u64() as u32;
+                        return Err(EvalError::Panic { file: file, line: line });
+                    }
+                };
                 self.call_c_abi(def_id, arg_operands, ret, ty)?;
                 self.goto_block(target);
                 Ok(())
@@ -358,6 +383,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         let args = args_res?;
 
         let usize = self.tcx.types.usize;
+        let i32 = self.tcx.types.i32;
 
         match &link_name[..] {
             "__rust_allocate" => {
@@ -403,6 +429,18 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 self.write_primval(dest, PrimVal::new(result as u64), dest_ty)?;
             }
 
+            "memrchr" => {
+                let ptr = args[0].read_ptr(&self.memory)?;
+                let val = self.value_to_primval(args[1], usize)?.to_u64() as u8;
+                let num = self.value_to_primval(args[2], usize)?.to_u64();
+                if let Some(idx) = self.memory.read_bytes(ptr, num)?.iter().rev().position(|&c| c == val) {
+                    let new_ptr = ptr.offset(num - idx as u64 - 1);
+                    self.write_value(Value::ByVal(PrimVal::from_ptr(new_ptr)), dest, dest_ty)?;
+                } else {
+                    self.write_value(Value::ByVal(PrimVal::new(0)), dest, dest_ty)?;
+                }
+            }
+
             "memchr" => {
                 let ptr = args[0].read_ptr(&self.memory)?;
                 let val = self.value_to_primval(args[1], usize)?.to_u64() as u8;
@@ -415,6 +453,27 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 }
             }
 
+            "write" => {
+                // int filedes
+                let filedes = self.value_to_primval(args[0], usize)?.to_u64();
+                // const void* buffer
+                let buffer = args[1].read_ptr(&self.memory)?;
+                // size_t size
+                let size = self.value_to_primval(args[0], usize)?.to_u64();
+
+                {
+                    let data = self.memory.read_bytes(buffer, size)?;
+                    info!("write to `{:x}`: {:?}", filedes, data);
+                    if filedes == 1 {
+                        for &d in data {
+                            print!("{}", d as char);
+                        }
+                    }
+                }
+
+                self.write_primval(dest, PrimVal::new(size as u64), dest_ty)?;
+            }
+
             "getenv" => {
                 {
                     let name_ptr = args[0].read_ptr(&self.memory)?;
@@ -423,6 +482,31 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 }
                 self.write_value(Value::ByVal(PrimVal::new(0)), dest, dest_ty)?;
             }
+            "pthread_key_create" => {
+                // pthread_key_t* key
+                let key = args[0].read_ptr(&self.memory)?;
+                let pthread_key_t = self.tcx.types.i32;
+                self.next_pthread_key += 1;
+                let new_key = self.next_pthread_key;
+                self.write_primval(Lvalue::from_ptr(key), PrimVal::new(new_key as u64), pthread_key_t)?;
+                self.write_primval(dest, PrimVal::new(0), dest_ty)?;
+            }
+
+            "pthread_setspecific" => {
+                let key = self.value_to_primval(args[0], i32)?.to_u64();
+                let val = args[1].read_ptr(&self.memory)?;
+                assert_eq!(key as i32 as u64, key);
+                self.pthread.insert(key as i32, val);
+                // FIXME: only keys that were created should exist
+                self.write_primval(dest, PrimVal::new(0), dest_ty)?;
+            }
+
+            "pthread_getspecific" => {
+                let key = self.value_to_primval(args[0], i32)?.to_u64();
+                assert_eq!(key as i32 as u64, key);
+                let val = self.pthread.get(&(key as i32)).map(|&p| p).unwrap_or(Pointer::from_int(0));
+                self.write_primval(dest, PrimVal::from_ptr(val), dest_ty)?;
+            }
 
             // unix panic code inside libstd will read the return value of this function
             "pthread_rwlock_rdlock" => {