From cd42bb97f0cd6ea6d758659f4208dbabe8f4873d Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 6 Sep 2016 16:04:51 +0200 Subject: [PATCH] rustup to rustc 1.13.0-nightly (91f057de3 2016-09-04) --- Cargo.lock | 12 ++++++------ src/bin/miri.rs | 19 +++++++++++-------- src/interpreter/mod.rs | 10 +++++----- src/interpreter/step.rs | 22 ++++++++++++++-------- src/interpreter/terminator.rs | 23 ++++++++++++----------- 5 files changed, 48 insertions(+), 38 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0217a26fddd..d85ee67cf3e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -37,7 +37,7 @@ version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", - "regex 0.1.73 (registry+https://github.com/rust-lang/crates.io-index)", + "regex 0.1.75 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -82,19 +82,19 @@ dependencies = [ [[package]] name = "regex" -version = "0.1.73" +version = "0.1.75" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "aho-corasick 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", - "regex-syntax 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)", + "regex-syntax 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", "thread_local 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)", "utf8-ranges 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "regex-syntax" -version = "0.3.4" +version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] @@ -145,8 +145,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ab83497bf8bf4ed2a74259c1c802351fcd67a65baa86394b6ba73c36f4838054" "checksum log_settings 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3d382732ea0fbc09790c4899db3255bdea0fc78b54bf234bd18a63bb603915b6" "checksum memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d8b629fb514376c675b98c1421e80b151d3817ac42d7c667717d282761418d20" -"checksum regex 0.1.73 (registry+https://github.com/rust-lang/crates.io-index)" = "56b7ee9f764ecf412c6e2fff779bca4b22980517ae335a21aeaf4e32625a5df2" -"checksum regex-syntax 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "31040aad7470ad9d8c46302dcffba337bb4289ca5da2e3cd6e37b64109a85199" +"checksum regex 0.1.75 (registry+https://github.com/rust-lang/crates.io-index)" = "f62414f9d3b0f53e827ac46d6f8ce2ff6a91afd724225a5986e54e81e170693c" +"checksum regex-syntax 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "279401017ae31cf4e15344aa3f085d0e2e5c1e70067289ef906906fdbe92c8fd" "checksum rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)" = "6159e4e6e559c81bd706afe9c8fd68f547d3e851ce12e76b1de7914bab61691b" "checksum thread-id 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a9539db560102d1cef46b8b78ce737ff0bb64e7e18d35b2a5688f7d097d0ff03" "checksum thread_local 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "55dd963dbaeadc08aa7266bf7f91c3154a7805e32bb94b820b769d2ef3b4744d" diff --git a/src/bin/miri.rs b/src/bin/miri.rs index 728266a755d..4fc20c96d21 100644 --- a/src/bin/miri.rs +++ b/src/bin/miri.rs @@ -13,7 +13,7 @@ use miri::{eval_main, run_mir_passes}; use rustc::session::Session; use rustc::mir::mir_map::MirMap; use rustc_driver::{driver, CompilerCalls, Compilation}; -use syntax::ast::MetaItemKind; +use syntax::ast::{MetaItemKind, NestedMetaItemKind}; struct MiriCompilerCalls; @@ -52,14 +52,17 @@ impl<'a> CompilerCalls<'a> for MiriCompilerCalls { MetaItemKind::List(ref name, _) if name != "miri" => {} MetaItemKind::List(_, ref items) => for item in items { match item.node { - MetaItemKind::NameValue(ref name, ref value) => { - match &**name { - "memory_size" => memory_size = extract_str(value).parse().expect("not a number"), - "step_limit" => step_limit = extract_str(value).parse().expect("not a number"), - "stack_limit" => stack_limit = extract_str(value).parse().expect("not a number"), - _ => state.session.span_err(item.span, "unknown miri attribute"), + NestedMetaItemKind::MetaItem(ref inner) => match inner.node { + MetaItemKind::NameValue(ref name, ref value) => { + match &**name { + "memory_size" => memory_size = extract_str(value).parse().expect("not a number"), + "step_limit" => step_limit = extract_str(value).parse().expect("not a number"), + "stack_limit" => stack_limit = extract_str(value).parse().expect("not a number"), + _ => state.session.span_err(item.span, "unknown miri attribute"), + } } - } + _ => state.session.span_err(inner.span, "miri attributes need to be of key = value kind"), + }, _ => state.session.span_err(item.span, "miri attributes need to be of key = value kind"), } }, diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs index 5ef423f21fb..0afca11c0ac 100644 --- a/src/interpreter/mod.rs +++ b/src/interpreter/mod.rs @@ -292,7 +292,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { // TODO(solson): Is this inefficient? Needs investigation. let ty = self.monomorphize(ty, substs); - self.tcx.normalizing_infer_ctxt(Reveal::All).enter(|infcx| { + self.tcx.infer_ctxt(None, None, Reveal::All).enter(|infcx| { // TODO(solson): Report this error properly. ty.layout(&infcx).unwrap() }) @@ -454,7 +454,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } General { discr, ref variants, .. } => { - if let mir::AggregateKind::Adt(adt_def, variant, _) = *kind { + if let mir::AggregateKind::Adt(adt_def, variant, _, _) = *kind { let discr_val = adt_def.variants[variant].disr_val.to_u64_unchecked(); let discr_size = discr.size().bytes() as usize; self.memory.write_uint(dest, discr_val, discr_size)?; @@ -468,7 +468,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } RawNullablePointer { nndiscr, .. } => { - if let mir::AggregateKind::Adt(_, variant, _) = *kind { + if let mir::AggregateKind::Adt(_, variant, _, _) = *kind { if nndiscr == variant as u64 { assert_eq!(operands.len(), 1); let operand = &operands[0]; @@ -485,7 +485,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } StructWrappedNullablePointer { nndiscr, ref nonnull, ref discrfield } => { - if let mir::AggregateKind::Adt(_, variant, _) = *kind { + if let mir::AggregateKind::Adt(_, variant, _, _) = *kind { if nndiscr == variant as u64 { let offsets = iter::once(0) .chain(nonnull.offset_after_field.iter().map(|s| s.bytes())); @@ -503,7 +503,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { CEnum { discr, signed, .. } => { assert_eq!(operands.len(), 0); - if let mir::AggregateKind::Adt(adt_def, variant, _) = *kind { + if let mir::AggregateKind::Adt(adt_def, variant, _, _) = *kind { let val = adt_def.variants[variant].disr_val.to_u64_unchecked(); let size = discr.size().bytes() as usize; diff --git a/src/interpreter/step.rs b/src/interpreter/step.rs index 75dc7ee0941..3175d2a16a3 100644 --- a/src/interpreter/step.rs +++ b/src/interpreter/step.rs @@ -24,11 +24,11 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } let block = self.frame().block; - let stmt = self.frame().stmt; + let stmt_id = self.frame().stmt; let mir = self.mir(); let basic_block = &mir.basic_blocks()[block]; - if let Some(ref stmt) = basic_block.statements.get(stmt) { + if let Some(ref stmt) = basic_block.statements.get(stmt_id) { let mut new = Ok(0); ConstantExtractor { span: stmt.source_info.span, @@ -37,7 +37,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { ecx: self, mir: &mir, new_constants: &mut new, - }.visit_statement(block, stmt); + }.visit_statement(block, stmt, mir::Location { + block: block, + statement_index: stmt_id, + }); if new? == 0 { self.statement(stmt)?; } @@ -55,7 +58,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { ecx: self, mir: &mir, new_constants: &mut new, - }.visit_terminator(block, terminator); + }.visit_terminator(block, terminator, mir::Location { + block: block, + statement_index: stmt_id, + }); if new? == 0 { self.terminator(terminator)?; } @@ -135,8 +141,8 @@ impl<'a, 'b, 'tcx> ConstantExtractor<'a, 'b, 'tcx> { } impl<'a, 'b, 'tcx> Visitor<'tcx> for ConstantExtractor<'a, 'b, 'tcx> { - fn visit_constant(&mut self, constant: &mir::Constant<'tcx>) { - self.super_constant(constant); + fn visit_constant(&mut self, constant: &mir::Constant<'tcx>, location: mir::Location) { + self.super_constant(constant, location); match constant.literal { // already computed by rustc mir::Literal::Value { .. } => {} @@ -170,8 +176,8 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ConstantExtractor<'a, 'b, 'tcx> { } } - fn visit_lvalue(&mut self, lvalue: &mir::Lvalue<'tcx>, context: LvalueContext) { - self.super_lvalue(lvalue, context); + fn visit_lvalue(&mut self, lvalue: &mir::Lvalue<'tcx>, context: LvalueContext, location: mir::Location) { + self.super_lvalue(lvalue, context, location); if let mir::Lvalue::Static(def_id) = *lvalue { let substs = subst::Substs::empty(self.ecx.tcx); let span = self.span; diff --git a/src/interpreter/terminator.rs b/src/interpreter/terminator.rs index b8f8b132088..159cfd09ed3 100644 --- a/src/interpreter/terminator.rs +++ b/src/interpreter/terminator.rs @@ -240,6 +240,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { // The discriminant_value intrinsic returns 0 for non-sum types. Array { .. } | FatPointer { .. } | Scalar { .. } | Univariant { .. } | Vector { .. } => 0, + UntaggedUnion { .. } => unimplemented!(), }; Ok(discr_val) @@ -278,7 +279,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { "assume" => {} "copy_nonoverlapping" => { - let elem_ty = substs.types[0]; + let elem_ty = substs.types().next().expect("should at least have one type argument"); let elem_size = self.type_size(elem_ty); let elem_align = self.type_align(elem_ty); let src = self.memory.read_ptr(args_ptrs[0])?; @@ -288,7 +289,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } "discriminant_value" => { - let ty = substs.types[0]; + let ty = substs.types().next().expect("should have at least one type argument"); let adt_ptr = self.memory.read_ptr(args_ptrs[0])?; let discr_val = self.read_discriminant_value(adt_ptr, ty)?; self.memory.write_uint(dest, discr_val, 8)?; @@ -299,19 +300,19 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { "init" => self.memory.write_repeat(dest, 0, dest_layout.size(&self.tcx.data_layout).bytes() as usize)?, "min_align_of" => { - let elem_ty = substs.types[0]; + let elem_ty = substs.types().next().expect("should have at least one type argument"); let elem_align = self.type_align(elem_ty); self.memory.write_uint(dest, elem_align as u64, pointer_size)?; } "move_val_init" => { - let ty = substs.types[0]; + let ty = substs.types().next().expect("should have at least one type argument"); let ptr = self.memory.read_ptr(args_ptrs[0])?; self.move_(args_ptrs[1], ptr, ty)?; } "offset" => { - let pointee_ty = substs.types[0]; + let pointee_ty = substs.types().next().expect("should have at least one type argument"); let pointee_size = self.type_size(pointee_ty) as isize; let ptr_arg = args_ptrs[0]; let offset = self.memory.read_isize(args_ptrs[1])?; @@ -343,13 +344,13 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } "size_of" => { - let ty = substs.types[0]; + let ty = substs.types().next().expect("should have at least one type argument"); let size = self.type_size(ty) as u64; self.memory.write_uint(dest, size, pointer_size)?; } "size_of_val" => { - let ty = substs.types[0]; + let ty = substs.types().next().expect("should have at least one type argument"); if self.type_is_sized(ty) { let size = self.type_size(ty) as u64; self.memory.write_uint(dest, size, pointer_size)?; @@ -369,7 +370,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } "transmute" => { - let ty = substs.types[0]; + let ty = substs.types().next().expect("should have at least one type argument"); self.move_(args_ptrs[0], dest, ty)?; } "uninit" => self.memory.mark_definedness(dest, dest_layout.size(&self.tcx.data_layout).bytes() as usize, false)?, @@ -457,7 +458,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { fn fulfill_obligation(&self, trait_ref: ty::PolyTraitRef<'tcx>) -> traits::Vtable<'tcx, ()> { // Do the initial selection for the obligation. This yields the shallow result we are // looking for -- that is, what specific impl. - self.tcx.normalizing_infer_ctxt(Reveal::All).enter(|infcx| { + self.tcx.infer_ctxt(None, None, Reveal::All).enter(|infcx| { let mut selcx = traits::SelectionContext::new(&infcx); let obligation = traits::Obligation::new( @@ -570,14 +571,14 @@ fn get_impl_method<'a, 'tcx>( impl_substs: &'tcx Substs<'tcx>, name: ast::Name, ) -> ImplMethod<'tcx> { - assert!(!substs.types.needs_infer()); + assert!(!substs.types().any(|ty| ty.needs_infer())); let trait_def_id = tcx.trait_id_of_impl(impl_def_id).unwrap(); let trait_def = tcx.lookup_trait_def(trait_def_id); match trait_def.ancestors(impl_def_id).fn_defs(tcx, name).next() { Some(node_item) => { - let substs = tcx.normalizing_infer_ctxt(Reveal::All).enter(|infcx| { + let substs = tcx.infer_ctxt(None, None, Reveal::All).enter(|infcx| { let substs = substs.rebase_onto(tcx, trait_def_id, impl_substs); let substs = traits::translate_substs(&infcx, impl_def_id, substs, node_item.node);