Revert some changes to rust compiler code (rust-lang#42) (rust-lang#667)

* Use rustc SwitchTarget as is (rust-lang#42)

There is no need to modify rustc code in order to access the
SwitchTarget targets field. Change direct access to calls to
all_targets().

* Remove old change made to rustc_driver (rust-lang#42)

This is no longer needed.

* Use rustc TyS as is (rust-lang#42)

There is no need to access the kind and flags field of TyS directly.
We should be using kind() and flags() methods instead. Thus, I'm
removing the modification we made to the original rustc code to make
these variables public and fixing the code that relied on the direct
access.

* Revert changes from ScalarInt

Use conversion methods instead.

Author: celinval

compiler/rustc_codegen_rmc/src/codegen/assumptions.rs

@@ -8,10 +8,9 @@ use cbmc::NO_PRETTY_NAME;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::ty;
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::ScalarInt;
 use rustc_middle::ty::Ty;
 use rustc_middle::ty::{IntTy, UintTy};
-use rustc_target::abi::{FieldsShape, Primitive, TagEncoding, Variants};
+use rustc_target::abi::{FieldsShape, Primitive, Size, TagEncoding, Variants};
 
 fn fold_invariants_gen<F: Fn(Expr, Expr) -> Expr>(mut iv: Vec<Expr>, dfl: Expr, comb: F) -> Expr {
     let mut res: Option<Expr> = None;
@@ -446,8 +445,9 @@ impl<'tcx> GotocCtx<'tcx> {
                 };
                 for (_, discr) in def.discriminants(tcx.tcx) {
                     let val = (discr.val << (128 - 8 * sz)) >> (128 - 8 * sz);
+                    let scalar = Scalar::from_uint(val, Size::from_bytes(sz));
                     cases.push(case.clone().eq(tcx.codegen_const_value(
-                        ConstValue::Scalar(Scalar::Int(ScalarInt { data: val, size: sz })),
+                        ConstValue::Scalar(scalar),
                         discr_t,
                         None,
                     )));

compiler/rustc_codegen_rmc/src/codegen/operand.rs

@@ -10,9 +10,7 @@ use rustc_middle::mir::interpret::{
 };
 use rustc_middle::mir::{Constant, ConstantKind, Operand};
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{
-    self, Const, ConstKind, FloatTy, Instance, IntTy, ScalarInt, Ty, Uint, UintTy,
-};
+use rustc_middle::ty::{self, Const, ConstKind, FloatTy, Instance, IntTy, Ty, Uint, UintTy};
 use rustc_span::def_id::DefId;
 use rustc_span::Span;
 use rustc_target::abi::{FieldsShape, Size, TagEncoding, Variants};
@@ -78,46 +76,67 @@ impl<'tcx> GotocCtx<'tcx> {
         }
     }
 
-    pub fn codegen_const_value(
+    fn codegen_slice_value(
         &mut self,
         v: ConstValue<'tcx>,
         lit_ty: Ty<'tcx>,
         span: Option<&Span>,
+        data: &Allocation,
+        start: usize,
+        end: usize,
     ) -> Expr {
-        match v {
-            ConstValue::Scalar(s) => self.codegen_scalar(s, lit_ty, span),
-            ConstValue::Slice { data, start, end } => match lit_ty.kind() {
-                ty::Ref(_, ty::TyS { kind: ty::Str, .. }, _) => {
+        if let ty::Ref(_, ref_ty, _) = lit_ty.kind() {
+            match ref_ty.kind() {
+                ty::Str => {
                     let slice = data.inspect_with_uninit_and_ptr_outside_interpreter(start..end);
                     let s = ::std::str::from_utf8(slice).expect("non utf8 str from miri");
-                    Expr::struct_expr_from_values(
+                    return Expr::struct_expr_from_values(
                         self.codegen_ty(lit_ty),
                         vec![Expr::string_constant(s), Expr::int_constant(s.len(), Type::size_t())],
                         &self.symbol_table,
-                    )
+                    );
                 }
-                ty::Ref(
-                    _,
-                    ty::TyS { kind: ty::Slice(ty::TyS { kind: Uint(UintTy::U8), .. }), .. },
-                    _,
-                ) => {
-                    // The case where we have a slice of u8 is easy enough: make an array of u8
-                    // TODO: Handle cases with larger int types by making an array of bytes,
-                    // then using byte-extract on it.
-                    let slice = data.inspect_with_uninit_and_ptr_outside_interpreter(start..end);
-                    let vec_of_bytes: Vec<Expr> = slice
-                        .iter()
-                        .map(|b| Expr::int_constant(*b, Type::unsigned_int(8)))
-                        .collect();
-                    let len = vec_of_bytes.len();
-                    let array_expr =
-                        Expr::array_expr(Type::unsigned_int(8).array_of(len), vec_of_bytes);
-                    let data_expr = array_expr.array_to_ptr();
-                    let len_expr = Expr::int_constant(len, Type::size_t());
-                    slice_fat_ptr(self.codegen_ty(lit_ty), data_expr, len_expr, &self.symbol_table)
+                ty::Slice(slice_ty) => {
+                    if let Uint(UintTy::U8) = slice_ty.kind() {
+                        // The case where we have a slice of u8 is easy enough: make an array of u8
+                        // TODO: Handle cases with larger int types by making an array of bytes,
+                        // then using byte-extract on it.
+                        let slice =
+                            data.inspect_with_uninit_and_ptr_outside_interpreter(start..end);
+                        let vec_of_bytes: Vec<Expr> = slice
+                            .iter()
+                            .map(|b| Expr::int_constant(*b, Type::unsigned_int(8)))
+                            .collect();
+                        let len = vec_of_bytes.len();
+                        let array_expr =
+                            Expr::array_expr(Type::unsigned_int(8).array_of(len), vec_of_bytes);
+                        let data_expr = array_expr.array_to_ptr();
+                        let len_expr = Expr::int_constant(len, Type::size_t());
+                        return slice_fat_ptr(
+                            self.codegen_ty(lit_ty),
+                            data_expr,
+                            len_expr,
+                            &self.symbol_table,
+                        );
+                    }
                 }
-                _ => unimplemented!("\nv {:?}\nlit_ty {:?}\nspan {:?}", v, lit_ty, span),
-            },
+                _ => {}
+            }
+        }
+        unimplemented!("\nv {:?}\nlit_ty {:?}\nspan {:?}", v, lit_ty, span);
+    }
+
+    pub fn codegen_const_value(
+        &mut self,
+        v: ConstValue<'tcx>,
+        lit_ty: Ty<'tcx>,
+        span: Option<&Span>,
+    ) -> Expr {
+        match v {
+            ConstValue::Scalar(s) => self.codegen_scalar(s, lit_ty, span),
+            ConstValue::Slice { data, start, end } => {
+                self.codegen_slice_value(v, lit_ty, span, &data, start, end)
+            }
             ConstValue::ByRef { alloc, offset } => {
                 debug!("ConstValue by ref {:?} {:?}", alloc, offset);
                 let mem_var =
@@ -132,31 +151,35 @@ impl<'tcx> GotocCtx<'tcx> {
     }
 
     fn codegen_scalar(&mut self, s: Scalar, ty: Ty<'tcx>, span: Option<&Span>) -> Expr {
-        debug! {"codegen_scalar\n{:?}\n{:?}\n{:?}\n{:?}",s, ty, span, &ty.kind};
+        debug! {"codegen_scalar\n{:?}\n{:?}\n{:?}\n{:?}",s, ty, span, &ty.kind()};
         match (s, &ty.kind()) {
-            (Scalar::Int(ScalarInt { data, .. }), ty::Int(it)) => match it {
-                IntTy::I8 => Expr::int_constant(data, Type::signed_int(8)),
-                IntTy::I16 => Expr::int_constant(data, Type::signed_int(16)),
-                IntTy::I32 => Expr::int_constant(data, Type::signed_int(32)),
-                IntTy::I64 => Expr::int_constant(data, Type::signed_int(64)),
-                IntTy::I128 => Expr::int_constant(data, Type::signed_int(128)),
-                IntTy::Isize => Expr::int_constant(data, Type::ssize_t()),
+            (Scalar::Int(_), ty::Int(it)) => match it {
+                // We treat the data as bit vector. Thus, we extract the value as unsigned and set
+                // the type to signed int.
+                IntTy::I8 => Expr::int_constant(s.to_u8().unwrap(), Type::signed_int(8)),
+                IntTy::I16 => Expr::int_constant(s.to_u16().unwrap(), Type::signed_int(16)),
+                IntTy::I32 => Expr::int_constant(s.to_u32().unwrap(), Type::signed_int(32)),
+                IntTy::I64 => Expr::int_constant(s.to_u64().unwrap(), Type::signed_int(64)),
+                IntTy::I128 => Expr::int_constant(s.to_u128().unwrap(), Type::signed_int(128)),
+                IntTy::Isize => {
+                    Expr::int_constant(s.to_machine_usize(self).unwrap(), Type::ssize_t())
+                }
             },
-            (Scalar::Int(ScalarInt { data, .. }), ty::Uint(it)) => match it {
-                UintTy::U8 => Expr::int_constant(data, Type::unsigned_int(8)),
-                UintTy::U16 => Expr::int_constant(data, Type::unsigned_int(16)),
-                UintTy::U32 => Expr::int_constant(data, Type::unsigned_int(32)),
-                UintTy::U64 => Expr::int_constant(data, Type::unsigned_int(64)),
-                UintTy::U128 => Expr::int_constant(data, Type::unsigned_int(128)),
-                UintTy::Usize => Expr::int_constant(data, Type::size_t()),
+            (Scalar::Int(_), ty::Uint(it)) => match it {
+                UintTy::U8 => Expr::int_constant(s.to_u8().unwrap(), Type::unsigned_int(8)),
+                UintTy::U16 => Expr::int_constant(s.to_u16().unwrap(), Type::unsigned_int(16)),
+                UintTy::U32 => Expr::int_constant(s.to_u32().unwrap(), Type::unsigned_int(32)),
+                UintTy::U64 => Expr::int_constant(s.to_u64().unwrap(), Type::unsigned_int(64)),
+                UintTy::U128 => Expr::int_constant(s.to_u128().unwrap(), Type::unsigned_int(128)),
+                UintTy::Usize => {
+                    Expr::int_constant(s.to_machine_usize(self).unwrap(), Type::size_t())
+                }
             },
-            (Scalar::Int(ScalarInt { .. }), ty::Bool) => {
-                Expr::c_bool_constant(s.to_bool().unwrap())
-            }
-            (Scalar::Int(ScalarInt { .. }), ty::Char) => {
+            (Scalar::Int(_), ty::Bool) => Expr::c_bool_constant(s.to_bool().unwrap()),
+            (Scalar::Int(_), ty::Char) => {
                 Expr::int_constant(s.to_i32().unwrap(), Type::signed_int(32))
             }
-            (Scalar::Int(ScalarInt { .. }), ty::Float(k)) =>
+            (Scalar::Int(_), ty::Float(k)) =>
             // rustc uses a sophisticated format for floating points that is hard to get f32/f64 from.
             // Instead, we use integers with the right width to represent the bit pattern.
             {
@@ -165,18 +188,23 @@ impl<'tcx> GotocCtx<'tcx> {
                     FloatTy::F64 => Expr::double_constant_from_bitpattern(s.to_u64().unwrap()),
                 }
             }
-            (Scalar::Int(ScalarInt { size: 0, .. }), ty::FnDef(d, substs)) => {
+            (Scalar::Int(int), ty::FnDef(d, substs)) => {
+                assert_eq!(int.size(), Size::ZERO);
                 self.codegen_fndef(*d, substs, span)
             }
-            (Scalar::Int(ScalarInt { .. }), ty::RawPtr(tm)) => {
+            (Scalar::Int(_), ty::RawPtr(tm)) => {
                 Expr::pointer_constant(s.to_u64().unwrap(), self.codegen_ty(tm.ty).to_pointer())
             }
             // TODO: Removing this doesn't cause any regressions to fail.
             // We need a regression for this case.
-            (Scalar::Int(ScalarInt { data: 0, .. }), ty::Ref(_, ty, _)) => {
-                self.codegen_ty(ty).to_pointer().null()
+            (Scalar::Int(int), ty::Ref(_, ty, _)) => {
+                if int.is_null() {
+                    self.codegen_ty(ty).to_pointer().null()
+                } else {
+                    unreachable!()
+                }
             }
-            (Scalar::Int(ScalarInt { .. }), ty::Adt(adt, subst)) => {
+            (Scalar::Int(_), ty::Adt(adt, subst)) => {
                 if adt.is_struct() || adt.is_union() {
                     // in this case, we must have a one variant ADT. there are two cases
                     let variant = &adt.variants.raw[0];

compiler/rustc_codegen_rmc/src/codegen/statement.rs

@@ -41,8 +41,9 @@ impl<'tcx> GotocCtx<'tcx> {
                 Stmt::goto(self.current_fn().find_label(target), loc)
             }
             TerminatorKind::SwitchInt { discr, switch_ty, targets } => match targets {
-                SwitchTargets { values, targets } => {
-                    self.codegen_switch_int(discr, switch_ty, values, targets)
+                SwitchTargets { values, .. } => {
+                    let all_targets = targets.all_targets();
+                    self.codegen_switch_int(discr, switch_ty, values, all_targets)
                 }
             },
             TerminatorKind::Resume => Stmt::assert_false("resume instruction", loc),
@@ -197,7 +198,7 @@ impl<'tcx> GotocCtx<'tcx> {
         discr: &Operand<'tcx>,
         switch_ty: Ty<'tcx>,
         values: &SmallVec<[u128; 1]>,
-        targets: &SmallVec<[BasicBlock; 2]>,
+        targets: &[BasicBlock],
     ) -> Stmt {
         assert_eq!(targets.len(), values.len() + 1);
 

compiler/rustc_driver/src/lib.rs

@@ -595,24 +595,6 @@ fn show_content_with_pager(content: &str) {
 }
 
 impl RustcDefaultCalls {
-    fn process_rlink(sess: &Session, compiler: &interface::Compiler) -> Result<(), ErrorReported> {
-        if let Input::File(file) = compiler.input() {
-            // FIXME: #![crate_type] and #![crate_name] support not implemented yet
-            let attrs = vec![];
-            sess.init_crate_types(collect_crate_types(sess, &attrs));
-            let outputs = compiler.build_output_filenames(&sess, &attrs);
-            let rlink_data = fs::read_to_string(file).unwrap_or_else(|err| {
-                sess.fatal(&format!("failed to read rlink file: {}", err));
-            });
-            let codegen_results: CodegenResults = json::decode(&rlink_data).unwrap_or_else(|err| {
-                sess.fatal(&format!("failed to decode rlink: {}", err));
-            });
-            compiler.codegen_backend().link(&sess, Box::new(codegen_results), &outputs)
-        } else {
-            sess.fatal("rlink must be a file")
-        }
-    }
-
     pub fn try_process_rlink(sess: &Session, compiler: &interface::Compiler) -> Compilation {
         if sess.opts.debugging_opts.link_only {
             if let Input::File(file) = compiler.input() {

compiler/rustc_middle/src/mir/terminator.rs

@@ -35,7 +35,7 @@ pub struct SwitchTargets {
     //
     // However we’ve decided to keep this as-is until we figure a case
     // where some other approach seems to be strictly better than other.
-    pub targets: SmallVec<[BasicBlock; 2]>,
+    targets: SmallVec<[BasicBlock; 2]>,
 }
 
 impl SwitchTargets {

compiler/rustc_middle/src/ty/consts/int.rs

@@ -122,8 +122,8 @@ impl std::fmt::Debug for ConstInt {
 pub struct ScalarInt {
     /// The first `size` bytes of `data` are the value.
     /// Do not try to read less or more bytes than that. The remaining bytes must be 0.
-    pub data: u128,
-    pub size: u8,
+    data: u128,
+    size: u8,
 }
 
 // Cannot derive these, as the derives take references to the fields, and we

compiler/rustc_middle/src/ty/mod.rs

@@ -365,10 +365,10 @@ pub struct CReaderCacheKey {
 pub struct TyS<'tcx> {
     /// This field shouldn't be used directly and may be removed in the future.
     /// Use `TyS::kind()` instead.
-    pub kind: TyKind<'tcx>,
+    kind: TyKind<'tcx>,
     /// This field shouldn't be used directly and may be removed in the future.
     /// Use `TyS::flags()` instead.
-    pub flags: TypeFlags,
+    flags: TypeFlags,
 
     /// This is a kind of confusing thing: it stores the smallest
     /// binder such that