diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index 36ebb3d513944..d482acbb3b901 100644 --- a/src/librustc/lib/llvm.rs +++ b/src/librustc/lib/llvm.rs @@ -277,6 +277,7 @@ pub mod debuginfo { pub type DIDerivedType = DIType; pub type DICompositeType = DIDerivedType; pub type DIVariable = DIDescriptor; + pub type DIGlobalVariable = DIDescriptor; pub type DIArray = DIDescriptor; pub type DISubrange = DIDescriptor; @@ -1589,6 +1590,18 @@ pub mod llvm { Col: c_uint) -> DILexicalBlock; + pub fn LLVMDIBuilderCreateStaticVariable(Builder: DIBuilderRef, + Context: DIDescriptor, + Name: *c_char, + LinkageName: *c_char, + File: DIFile, + LineNo: c_uint, + Ty: DIType, + isLocalToUnit: bool, + Val: ValueRef, + Decl: ValueRef) + -> DIGlobalVariable; + pub fn LLVMDIBuilderCreateLocalVariable(Builder: DIBuilderRef, Tag: c_uint, Scope: DIDescriptor, diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index dc154206e7117..fb6813e59db1d 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -28,6 +28,7 @@ use middle::trans::inline; use middle::trans::machine; use middle::trans::type_::Type; use middle::trans::type_of; +use middle::trans::debuginfo; use middle::ty; use util::ppaux::{Repr, ty_to_str}; @@ -688,5 +689,6 @@ pub fn trans_const(ccx: &CrateContext, m: ast::Mutability, id: ast::NodeId) { if m != ast::MutMutable { llvm::LLVMSetGlobalConstant(g, True); } + debuginfo::create_global_var_metadata(ccx, id, g); } } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 9f5959e05deec..a75d5237d1f0a 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -280,6 +280,66 @@ pub fn finalize(cx: &CrateContext) { }; } +/// Creates debug information for the given global variable. +/// +/// Adds the created metadata nodes directly to the crate's IR. +pub fn create_global_var_metadata(cx: &CrateContext, + node_id: ast::NodeId, + global: ValueRef) { + if cx.dbg_cx.is_none() { + return; + } + + let var_item = cx.tcx.map.get(node_id); + + let (ident, span) = match var_item { + ast_map::NodeItem(item) => { + match item.node { + ast::ItemStatic(..) => (item.ident, item.span), + _ => cx.sess().span_bug(item.span, + format!("debuginfo::create_global_var_metadata() - + Captured var-id refers to unexpected ast_item + variant: {:?}", + var_item)) + } + }, + _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() - Captured var-id \ + refers to unexpected ast_map variant: {:?}", + var_item)) + }; + + let filename = span_start(cx, span).file.name.clone(); + let file_metadata = file_metadata(cx, filename); + + let is_local_to_unit = is_node_local_to_unit(cx, node_id); + let loc = span_start(cx, span); + + let variable_type = ty::node_id_to_type(cx.tcx(), node_id); + let type_metadata = type_metadata(cx, variable_type, span); + + let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id)); + let var_name = token::get_ident(ident).get().to_str(); + let linkage_name = namespace_node.mangled_name_of_contained_item(var_name); + let var_scope = namespace_node.scope; + + var_name.with_c_str(|var_name| { + linkage_name.with_c_str(|linkage_name| { + unsafe { + llvm::LLVMDIBuilderCreateStaticVariable(DIB(cx), + var_scope, + var_name, + linkage_name, + file_metadata, + loc.line as c_uint, + type_metadata, + is_local_to_unit, + global, + ptr::null()); + } + }) + }); +} + /// Creates debug information for the given local variable. /// /// Adds the created metadata nodes directly to the crate's IR. @@ -640,13 +700,7 @@ pub fn create_function_debug_context(cx: &CrateContext, // Clang sets this parameter to the opening brace of the function's block, so let's do this too. let scope_line = span_start(cx, top_level_block.span).line; - // The is_local_to_unit flag indicates whether a function is local to the current compilation - // unit (i.e. if it is *static* in the C-sense). The *reachable* set should provide a good - // approximation of this, as it contains everything that might leak out of the current crate - // (by being externally visible or by being inlined into something externally visible). It might - // better to use the `exported_items` set from `driver::CrateAnalysis` in the future, but (atm) - // this set is not available in the translation pass. - let is_local_to_unit = !cx.reachable.contains(&fn_ast_id); + let is_local_to_unit = is_node_local_to_unit(cx, fn_ast_id); let fn_metadata = function_name.with_c_str(|function_name| { linkage_name.with_c_str(|linkage_name| { @@ -854,6 +908,17 @@ pub fn create_function_debug_context(cx: &CrateContext, // Module-Internal debug info creation functions //=------------------------------------------------------------------------------------------------- +fn is_node_local_to_unit(cx: &CrateContext, node_id: ast::NodeId) -> bool +{ + // The is_local_to_unit flag indicates whether a function is local to the current compilation + // unit (i.e. if it is *static* in the C-sense). The *reachable* set should provide a good + // approximation of this, as it contains everything that might leak out of the current crate + // (by being externally visible or by being inlined into something externally visible). It might + // better to use the `exported_items` set from `driver::CrateAnalysis` in the future, but (atm) + // this set is not available in the translation pass. + !cx.reachable.contains(&node_id) +} + fn create_DIArray(builder: DIBuilderRef, arr: &[DIDescriptor]) -> DIArray { return unsafe { llvm::LLVMDIBuilderGetOrCreateArray(builder, arr.as_ptr(), arr.len() as u32) diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index aaaf512bcf3fe..4755c7873fcb2 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -323,6 +323,28 @@ extern "C" LLVMValueRef LLVMDIBuilderCreateLexicalBlock( unwrapDI(File), Line, Col)); } +extern "C" LLVMValueRef LLVMDIBuilderCreateStaticVariable( + DIBuilderRef Builder, + LLVMValueRef Context, + const char* Name, + const char* LinkageName, + LLVMValueRef File, + unsigned LineNo, + LLVMValueRef Ty, + bool isLocalToUnit, + LLVMValueRef Val, + LLVMValueRef Decl = NULL) { + return wrap(Builder->createStaticVariable(unwrapDI(Context), + Name, + LinkageName, + unwrapDI(File), + LineNo, + unwrapDI(Ty), + isLocalToUnit, + unwrap(Val), + unwrapDI(Decl))); +} + extern "C" LLVMValueRef LLVMDIBuilderCreateLocalVariable( DIBuilderRef Builder, unsigned Tag, diff --git a/src/rustllvm/rustllvm.def.in b/src/rustllvm/rustllvm.def.in index ee82fa80f8743..0b4a619c41990 100644 --- a/src/rustllvm/rustllvm.def.in +++ b/src/rustllvm/rustllvm.def.in @@ -586,6 +586,7 @@ LLVMDIBuilderCreate LLVMDIBuilderDispose LLVMDIBuilderFinalize LLVMDIBuilderCreateCompileUnit +LLVMDIBuilderCreateStaticVariable LLVMDIBuilderCreateLocalVariable LLVMDIBuilderCreateFunction LLVMDIBuilderCreateFile diff --git a/src/test/debug-info/basic-types-globals-metadata.rs b/src/test/debug-info/basic-types-globals-metadata.rs new file mode 100644 index 0000000000000..943af3d0437f9 --- /dev/null +++ b/src/test/debug-info/basic-types-globals-metadata.rs @@ -0,0 +1,68 @@ +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// ignore-android: FIXME(#10381) + +// compile-flags:-g +// debugger:rbreak zzz +// debugger:run +// debugger:finish +// debugger:whatis 'basic-types-globals-metadata::B' +// check:type = bool +// debugger:whatis 'basic-types-globals-metadata::I' +// check:type = int +// debugger:whatis 'basic-types-globals-metadata::C' +// check:type = char +// debugger:whatis 'basic-types-globals-metadata::I8' +// check:type = i8 +// debugger:whatis 'basic-types-globals-metadata::I16' +// check:type = i16 +// debugger:whatis 'basic-types-globals-metadata::I32' +// check:type = i32 +// debugger:whatis 'basic-types-globals-metadata::I64' +// check:type = i64 +// debugger:whatis 'basic-types-globals-metadata::U' +// check:type = uint +// debugger:whatis 'basic-types-globals-metadata::U8' +// check:type = u8 +// debugger:whatis 'basic-types-globals-metadata::U16' +// check:type = u16 +// debugger:whatis 'basic-types-globals-metadata::U32' +// check:type = u32 +// debugger:whatis 'basic-types-globals-metadata::U64' +// check:type = u64 +// debugger:whatis 'basic-types-globals-metadata::F32' +// check:type = f32 +// debugger:whatis 'basic-types-globals-metadata::F64' +// check:type = f64 +// debugger:continue + +#[allow(unused_variable)]; + +static B: bool = false; +static I: int = -1; +static C: char = 'a'; +static I8: i8 = 68; +static I16: i16 = -16; +static I32: i32 = -32; +static I64: i64 = -64; +static U: uint = 1; +static U8: u8 = 100; +static U16: u16 = 16; +static U32: u32 = 32; +static U64: u64 = 64; +static F32: f32 = 2.5; +static F64: f64 = 3.5; + +fn main() { + _zzz(); +} + +fn _zzz() {()} diff --git a/src/test/debug-info/basic-types-globals.rs b/src/test/debug-info/basic-types-globals.rs new file mode 100644 index 0000000000000..4847144c57f6a --- /dev/null +++ b/src/test/debug-info/basic-types-globals.rs @@ -0,0 +1,74 @@ +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Caveats - gdb prints any 8-bit value (meaning rust I8 and u8 values) +// as its numerical value along with its associated ASCII char, there +// doesn't seem to be any way around this. Also, gdb doesn't know +// about UTF-32 character encoding and will print a rust char as only +// its numerical value. + +// ignore-android: FIXME(#10381) + +// compile-flags:-g +// debugger:rbreak zzz +// debugger:run +// debugger:finish +// debugger:print 'basic-types-globals::B' +// check:$1 = false +// debugger:print 'basic-types-globals::I' +// check:$2 = -1 +// debugger:print 'basic-types-globals::C' +// check:$3 = 97 +// debugger:print/d 'basic-types-globals::I8' +// check:$4 = 68 +// debugger:print 'basic-types-globals::I16' +// check:$5 = -16 +// debugger:print 'basic-types-globals::I32' +// check:$6 = -32 +// debugger:print 'basic-types-globals::I64' +// check:$7 = -64 +// debugger:print 'basic-types-globals::U' +// check:$8 = 1 +// debugger:print/d 'basic-types-globals::U8' +// check:$9 = 100 +// debugger:print 'basic-types-globals::U16' +// check:$10 = 16 +// debugger:print 'basic-types-globals::U32' +// check:$11 = 32 +// debugger:print 'basic-types-globals::U64' +// check:$12 = 64 +// debugger:print 'basic-types-globals::F32' +// check:$13 = 2.5 +// debugger:print 'basic-types-globals::F64' +// check:$14 = 3.5 +// debugger:continue + +#[allow(unused_variable)]; + +static B: bool = false; +static I: int = -1; +static C: char = 'a'; +static I8: i8 = 68; +static I16: i16 = -16; +static I32: i32 = -32; +static I64: i64 = -64; +static U: uint = 1; +static U8: u8 = 100; +static U16: u16 = 16; +static U32: u32 = 32; +static U64: u64 = 64; +static F32: f32 = 2.5; +static F64: f64 = 3.5; + +fn main() { + _zzz(); +} + +fn _zzz() {()} diff --git a/src/test/debug-info/basic-types-metadata.rs b/src/test/debug-info/basic-types-metadata.rs index 1c6d20783c59a..95228343bda40 100644 --- a/src/test/debug-info/basic-types-metadata.rs +++ b/src/test/debug-info/basic-types-metadata.rs @@ -46,8 +46,7 @@ // check:type = f64 // debugger:info functions _yyy // check:[...]![...]_yyy([...])([...]); -// debugger:detach -// debugger:quit +// debugger:continue #[allow(unused_variable)]; diff --git a/src/test/debug-info/basic-types-mut-globals.rs b/src/test/debug-info/basic-types-mut-globals.rs new file mode 100644 index 0000000000000..51391faed7a11 --- /dev/null +++ b/src/test/debug-info/basic-types-mut-globals.rs @@ -0,0 +1,128 @@ +// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Caveats - gdb prints any 8-bit value (meaning rust I8 and u8 values) +// as its numerical value along with its associated ASCII char, there +// doesn't seem to be any way around this. Also, gdb doesn't know +// about UTF-32 character encoding and will print a rust char as only +// its numerical value. + +// ignore-android: FIXME(#10381) + +// compile-flags:-g +// debugger:rbreak zzz +// debugger:run +// debugger:finish + +// Check initializers +// debugger:print 'basic-types-mut-globals::B' +// check:$1 = false +// debugger:print 'basic-types-mut-globals::I' +// check:$2 = -1 +// debugger:print 'basic-types-mut-globals::C' +// check:$3 = 97 +// debugger:print/d 'basic-types-mut-globals::I8' +// check:$4 = 68 +// debugger:print 'basic-types-mut-globals::I16' +// check:$5 = -16 +// debugger:print 'basic-types-mut-globals::I32' +// check:$6 = -32 +// debugger:print 'basic-types-mut-globals::I64' +// check:$7 = -64 +// debugger:print 'basic-types-mut-globals::U' +// check:$8 = 1 +// debugger:print/d 'basic-types-mut-globals::U8' +// check:$9 = 100 +// debugger:print 'basic-types-mut-globals::U16' +// check:$10 = 16 +// debugger:print 'basic-types-mut-globals::U32' +// check:$11 = 32 +// debugger:print 'basic-types-mut-globals::U64' +// check:$12 = 64 +// debugger:print 'basic-types-mut-globals::F32' +// check:$13 = 2.5 +// debugger:print 'basic-types-mut-globals::F64' +// check:$14 = 3.5 +// debugger:continue + +// Check new values +// debugger:print 'basic-types-mut-globals'::B +// check:$15 = true +// debugger:print 'basic-types-mut-globals'::I +// check:$16 = 2 +// debugger:print 'basic-types-mut-globals'::C +// check:$17 = 102 +// debugger:print/d 'basic-types-mut-globals'::I8 +// check:$18 = 78 +// debugger:print 'basic-types-mut-globals'::I16 +// check:$19 = -26 +// debugger:print 'basic-types-mut-globals'::I32 +// check:$20 = -12 +// debugger:print 'basic-types-mut-globals'::I64 +// check:$21 = -54 +// debugger:print 'basic-types-mut-globals'::U +// check:$22 = 5 +// debugger:print/d 'basic-types-mut-globals'::U8 +// check:$23 = 20 +// debugger:print 'basic-types-mut-globals'::U16 +// check:$24 = 32 +// debugger:print 'basic-types-mut-globals'::U32 +// check:$25 = 16 +// debugger:print 'basic-types-mut-globals'::U64 +// check:$26 = 128 +// debugger:print 'basic-types-mut-globals'::F32 +// check:$27 = 5.75 +// debugger:print 'basic-types-mut-globals'::F64 +// check:$28 = 9.25 + +// debugger:detach +// debugger:quit + +#[allow(unused_variable)]; + +static mut B: bool = false; +static mut I: int = -1; +static mut C: char = 'a'; +static mut I8: i8 = 68; +static mut I16: i16 = -16; +static mut I32: i32 = -32; +static mut I64: i64 = -64; +static mut U: uint = 1; +static mut U8: u8 = 100; +static mut U16: u16 = 16; +static mut U32: u32 = 32; +static mut U64: u64 = 64; +static mut F32: f32 = 2.5; +static mut F64: f64 = 3.5; + +fn main() { + _zzz(); + + unsafe { + B = true; + I = 2; + C = 'f'; + I8 = 78; + I16 = -26; + I32 = -12; + I64 = -54; + U = 5; + U8 = 20; + U16 = 32; + U32 = 16; + U64 = 128; + F32 = 5.75; + F64 = 9.25; + } + + _zzz(); +} + +fn _zzz() {()} diff --git a/src/test/debug-info/c-style-enum.rs b/src/test/debug-info/c-style-enum.rs index 6515541739914..7229480b2733e 100644 --- a/src/test/debug-info/c-style-enum.rs +++ b/src/test/debug-info/c-style-enum.rs @@ -12,29 +12,63 @@ // compile-flags:-g // debugger:rbreak zzz + +// debugger:print 'c-style-enum::SINGLE_VARIANT' +// check:$1 = TheOnlyVariant + +// debugger:print 'c-style-enum::AUTO_ONE' +// check:$2 = One + +// debugger:print 'c-style-enum::AUTO_TWO' +// check:$3 = One + +// debugger:print 'c-style-enum::AUTO_THREE' +// check:$4 = One + +// debugger:print 'c-style-enum::MANUAL_ONE' +// check:$5 = OneHundred + +// debugger:print 'c-style-enum::MANUAL_TWO' +// check:$6 = OneHundred + +// debugger:print 'c-style-enum::MANUAL_THREE' +// check:$7 = OneHundred + // debugger:run // debugger:finish // debugger:print auto_one -// check:$1 = One +// check:$8 = One // debugger:print auto_two -// check:$2 = Two +// check:$9 = Two // debugger:print auto_three -// check:$3 = Three +// check:$10 = Three // debugger:print manual_one_hundred -// check:$4 = OneHundred +// check:$11 = OneHundred // debugger:print manual_one_thousand -// check:$5 = OneThousand +// check:$12 = OneThousand // debugger:print manual_one_million -// check:$6 = OneMillion +// check:$13 = OneMillion // debugger:print single_variant -// check:$7 = TheOnlyVariant +// check:$14 = TheOnlyVariant + +// debugger:print 'c-style-enum::AUTO_TWO' +// check:$15 = Two + +// debugger:print 'c-style-enum::AUTO_THREE' +// check:$16 = Three + +// debugger:print 'c-style-enum::MANUAL_TWO' +// check:$17 = OneThousand + +// debugger:print 'c-style-enum::MANUAL_THREE' +// check:$18 = OneMillion #[allow(unused_variable)]; @@ -54,6 +88,16 @@ enum SingleVariant { TheOnlyVariant } +static SINGLE_VARIANT: SingleVariant = TheOnlyVariant; + +static mut AUTO_ONE: AutoDiscriminant = One; +static mut AUTO_TWO: AutoDiscriminant = One; +static mut AUTO_THREE: AutoDiscriminant = One; + +static mut MANUAL_ONE: ManualDiscriminant = OneHundred; +static mut MANUAL_TWO: ManualDiscriminant = OneHundred; +static mut MANUAL_THREE: ManualDiscriminant = OneHundred; + fn main() { let auto_one = One; @@ -66,6 +110,14 @@ fn main() { let single_variant = TheOnlyVariant; + unsafe { + AUTO_TWO = Two; + AUTO_THREE = Three; + + MANUAL_TWO = OneThousand; + MANUAL_THREE = OneMillion; + }; + zzz(); } diff --git a/src/test/debug-info/lexical-scopes-in-block-expression.rs b/src/test/debug-info/lexical-scopes-in-block-expression.rs index 39e716403a1fc..72611e3bafa7c 100644 --- a/src/test/debug-info/lexical-scopes-in-block-expression.rs +++ b/src/test/debug-info/lexical-scopes-in-block-expression.rs @@ -15,183 +15,207 @@ // debugger:rbreak zzz // debugger:run +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$1 = 0 + // STRUCT EXPRESSION // debugger:finish // debugger:print val -// check:$1 = -1 +// check:$2 = -1 // debugger:print ten -// check:$2 = 10 +// check:$3 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$3 = 11 +// check:$4 = 11 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$5 = 1 // debugger:print ten -// check:$4 = 10 +// check:$6 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$5 = -1 +// check:$7 = -1 // debugger:print ten -// check:$6 = 10 +// check:$8 = 10 // debugger:continue // FUNCTION CALL // debugger:finish // debugger:print val -// check:$7 = -1 +// check:$9 = -1 // debugger:print ten -// check:$8 = 10 +// check:$10 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$9 = 12 +// check:$11 = 12 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$12 = 2 // debugger:print ten -// check:$10 = 10 +// check:$13 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$11 = -1 +// check:$14 = -1 // debugger:print ten -// check:$12 = 10 +// check:$15 = 10 // debugger:continue // TUPLE EXPRESSION // debugger:finish // debugger:print val -// check:$13 = -1 +// check:$16 = -1 // debugger:print ten -// check:$14 = 10 +// check:$17 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$15 = 13 +// check:$18 = 13 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$19 = 3 // debugger:print ten -// check:$16 = 10 +// check:$20 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$17 = -1 +// check:$21 = -1 // debugger:print ten -// check:$18 = 10 +// check:$22 = 10 // debugger:continue // VEC EXPRESSION // debugger:finish // debugger:print val -// check:$19 = -1 +// check:$23 = -1 // debugger:print ten -// check:$20 = 10 +// check:$24 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$21 = 14 +// check:$25 = 14 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$26 = 4 // debugger:print ten -// check:$22 = 10 +// check:$27 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$23 = -1 +// check:$28 = -1 // debugger:print ten -// check:$24 = 10 +// check:$29 = 10 // debugger:continue // REPEAT VEC EXPRESSION // debugger:finish // debugger:print val -// check:$25 = -1 +// check:$30 = -1 // debugger:print ten -// check:$26 = 10 +// check:$31 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$27 = 15 +// check:$32 = 15 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$33 = 5 // debugger:print ten -// check:$28 = 10 +// check:$34 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$29 = -1 +// check:$35 = -1 // debugger:print ten -// check:$30 = 10 +// check:$36 = 10 // debugger:continue // ASSIGNMENT EXPRESSION // debugger:finish // debugger:print val -// check:$31 = -1 +// check:$37 = -1 // debugger:print ten -// check:$32 = 10 +// check:$38 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$33 = 16 +// check:$39 = 16 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$40 = 6 // debugger:print ten -// check:$34 = 10 +// check:$41 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$35 = -1 +// check:$42 = -1 // debugger:print ten -// check:$36 = 10 +// check:$43 = 10 // debugger:continue // ARITHMETIC EXPRESSION // debugger:finish // debugger:print val -// check:$37 = -1 +// check:$44 = -1 // debugger:print ten -// check:$38 = 10 +// check:$45 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$39 = 17 +// check:$46 = 17 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$47 = 7 // debugger:print ten -// check:$40 = 10 +// check:$48 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$41 = -1 +// check:$49 = -1 // debugger:print ten -// check:$42 = 10 +// check:$50 = 10 // debugger:continue // INDEX EXPRESSION // debugger:finish // debugger:print val -// check:$43 = -1 +// check:$51 = -1 // debugger:print ten -// check:$44 = 10 +// check:$52 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$45 = 18 +// check:$53 = 18 +// debugger:print 'lexical-scopes-in-block-expression::MUT_INT' +// check:$54 = 8 // debugger:print ten -// check:$46 = 10 +// check:$55 = 10 // debugger:continue // debugger:finish // debugger:print val -// check:$47 = -1 +// check:$56 = -1 // debugger:print ten -// check:$48 = 10 +// check:$57 = 10 // debugger:continue +#[allow(unused_variable)]; +#[allow(dead_assignment)]; + +static mut MUT_INT: int = 0; + struct Point { x: int, y: int @@ -213,6 +237,7 @@ fn main() { sentinel(); let val = ten + 1; + unsafe {MUT_INT = 1;}; zzz(); sentinel(); @@ -231,6 +256,7 @@ fn main() { sentinel(); let val = ten + 2; + unsafe {MUT_INT = 2;}; zzz(); sentinel(); @@ -248,6 +274,7 @@ fn main() { sentinel(); let val = ten + 3; + unsafe {MUT_INT = 3;}; zzz(); sentinel(); @@ -264,6 +291,7 @@ fn main() { sentinel(); let val = ten + 4; + unsafe {MUT_INT = 4;}; zzz(); sentinel(); @@ -280,6 +308,7 @@ fn main() { sentinel(); let val = ten + 5; + unsafe {MUT_INT = 5;}; zzz(); sentinel(); @@ -297,6 +326,7 @@ fn main() { sentinel(); let val = ten + 6; + unsafe {MUT_INT = 6;}; zzz(); sentinel(); @@ -313,6 +343,7 @@ fn main() { sentinel(); let val = ten + 7; + unsafe {MUT_INT = 7;}; zzz(); sentinel(); @@ -330,6 +361,7 @@ fn main() { sentinel(); let val = ten + 8; + unsafe {MUT_INT = 8;}; zzz(); sentinel(); diff --git a/src/test/debug-info/simple-struct.rs b/src/test/debug-info/simple-struct.rs index 69ec4213183aa..5f9789ff620c0 100644 --- a/src/test/debug-info/simple-struct.rs +++ b/src/test/debug-info/simple-struct.rs @@ -13,28 +13,66 @@ // compile-flags:-g // debugger:set print pretty off // debugger:rbreak zzz + +// debugger:print 'simple-struct::NO_PADDING_16' +// check:$1 = {x = 1000, y = -1001} + +// debugger:print 'simple-struct::NO_PADDING_32' +// check:$2 = {x = 1, y = 2, z = 3} + +// debugger:print 'simple-struct::NO_PADDING_64' +// check:$3 = {x = 4, y = 5, z = 6} + +// debugger:print 'simple-struct::NO_PADDING_163264' +// check:$4 = {a = 7, b = 8, c = 9, d = 10} + +// debugger:print 'simple-struct::INTERNAL_PADDING' +// check:$5 = {x = 11, y = 12} + +// debugger:print 'simple-struct::PADDING_AT_END' +// check:$6 = {x = 13, y = 14} + // debugger:run // debugger:finish // debugger:print no_padding16 -// check:$1 = {x = 10000, y = -10001} +// check:$7 = {x = 10000, y = -10001} // debugger:print no_padding32 -// check:$2 = {x = -10002, y = -10003.5, z = 10004} +// check:$8 = {x = -10002, y = -10003.5, z = 10004} // debugger:print no_padding64 -// check:$3 = {x = -10005.5, y = 10006, z = 10007} +// check:$9 = {x = -10005.5, y = 10006, z = 10007} // debugger:print no_padding163264 -// check:$4 = {a = -10008, b = 10009, c = 10010, d = 10011} +// check:$10 = {a = -10008, b = 10009, c = 10010, d = 10011} // debugger:print internal_padding -// check:$5 = {x = 10012, y = -10013} +// check:$11 = {x = 10012, y = -10013} // debugger:print padding_at_end -// check:$6 = {x = -10014, y = 10015} +// check:$12 = {x = -10014, y = 10015} + +// debugger:print 'simple-struct::NO_PADDING_16' +// check:$13 = {x = 100, y = -101} + +// debugger:print 'simple-struct::NO_PADDING_32' +// check:$14 = {x = -15, y = -16, z = 17} + +// debugger:print 'simple-struct::NO_PADDING_64' +// check:$15 = {x = -18, y = 19, z = 20} + +// debugger:print 'simple-struct::NO_PADDING_163264' +// check:$16 = {a = -21, b = 22, c = 23, d = 24} + +// debugger:print 'simple-struct::INTERNAL_PADDING' +// check:$17 = {x = 25, y = -26} + +// debugger:print 'simple-struct::PADDING_AT_END' +// check:$18 = {x = -27, y = 28} #[allow(unused_variable)]; +#[allow(dead_code)]; struct NoPadding16 { x: u16, @@ -70,6 +108,40 @@ struct PaddingAtEnd { y: u16 } +static mut NO_PADDING_16: NoPadding16 = NoPadding16 { + x: 1000, + y: -1001 +}; + +static mut NO_PADDING_32: NoPadding32 = NoPadding32 { + x: 1, + y: 2.0, + z: 3 +}; + +static mut NO_PADDING_64: NoPadding64 = NoPadding64 { + x: 4.0, + y: 5, + z: 6 +}; + +static mut NO_PADDING_163264: NoPadding163264 = NoPadding163264 { + a: 7, + b: 8, + c: 9, + d: 10 +}; + +static mut INTERNAL_PADDING: InternalPadding = InternalPadding { + x: 11, + y: 12 +}; + +static mut PADDING_AT_END: PaddingAtEnd = PaddingAtEnd { + x: 13, + y: 14 +}; + fn main() { let no_padding16 = NoPadding16 { x: 10000, y: -10001 }; let no_padding32 = NoPadding32 { x: -10002, y: -10003.5, z: 10004 }; @@ -79,6 +151,30 @@ fn main() { let internal_padding = InternalPadding { x: 10012, y: -10013 }; let padding_at_end = PaddingAtEnd { x: -10014, y: 10015 }; + unsafe { + NO_PADDING_16.x = 100; + NO_PADDING_16.y = -101; + + NO_PADDING_32.x = -15; + NO_PADDING_32.y = -16.0; + NO_PADDING_32.z = 17; + + NO_PADDING_64.x = -18.0; + NO_PADDING_64.y = 19; + NO_PADDING_64.z = 20; + + NO_PADDING_163264.a = -21; + NO_PADDING_163264.b = 22; + NO_PADDING_163264.c = 23; + NO_PADDING_163264.d = 24; + + INTERNAL_PADDING.x = 25; + INTERNAL_PADDING.y = -26; + + PADDING_AT_END.x = -27; + PADDING_AT_END.y = 28; + } + zzz(); } diff --git a/src/test/debug-info/simple-tuple.rs b/src/test/debug-info/simple-tuple.rs index 732e44b8c19b1..877b6285d133d 100644 --- a/src/test/debug-info/simple-tuple.rs +++ b/src/test/debug-info/simple-tuple.rs @@ -13,27 +13,74 @@ // compile-flags:-g // debugger:set print pretty off // debugger:rbreak zzz + +// debugger:print/d 'simple-tuple::NO_PADDING_8' +// check:$1 = {-50, 50} +// debugger:print 'simple-tuple::NO_PADDING_16' +// check:$2 = {-1, 2, 3} +// debugger:print 'simple-tuple::NO_PADDING_32' +// check:$3 = {4, 5, 6} +// debugger:print 'simple-tuple::NO_PADDING_64' +// check:$4 = {7, 8, 9} + +// debugger:print 'simple-tuple::INTERNAL_PADDING_1' +// check:$5 = {10, 11} +// debugger:print 'simple-tuple::INTERNAL_PADDING_2' +// check:$6 = {12, 13, 14, 15} + +// debugger:print 'simple-tuple::PADDING_AT_END' +// check:$7 = {16, 17} + // debugger:run // debugger:finish // debugger:print/d noPadding8 -// check:$1 = {-100, 100} +// check:$8 = {-100, 100} // debugger:print noPadding16 -// check:$2 = {0, 1, 2} +// check:$9 = {0, 1, 2} // debugger:print noPadding32 -// check:$3 = {3, 4.5, 5} +// check:$10 = {3, 4.5, 5} // debugger:print noPadding64 -// check:$4 = {6, 7.5, 8} +// check:$11 = {6, 7.5, 8} // debugger:print internalPadding1 -// check:$5 = {9, 10} +// check:$12 = {9, 10} // debugger:print internalPadding2 -// check:$6 = {11, 12, 13, 14} +// check:$13 = {11, 12, 13, 14} // debugger:print paddingAtEnd -// check:$7 = {15, 16} +// check:$14 = {15, 16} + +// debugger:print/d 'simple-tuple::NO_PADDING_8' +// check:$15 = {-127, 127} +// debugger:print 'simple-tuple::NO_PADDING_16' +// check:$16 = {-10, 10, 9} +// debugger:print 'simple-tuple::NO_PADDING_32' +// check:$17 = {14, 15, 16} +// debugger:print 'simple-tuple::NO_PADDING_64' +// check:$18 = {17, 18, 19} + +// debugger:print 'simple-tuple::INTERNAL_PADDING_1' +// check:$19 = {110, 111} +// debugger:print 'simple-tuple::INTERNAL_PADDING_2' +// check:$20 = {112, 113, 114, 115} + +// debugger:print 'simple-tuple::PADDING_AT_END' +// check:$21 = {116, 117} #[allow(unused_variable)]; +#[allow(dead_code)]; + +static mut NO_PADDING_8: (i8, u8) = (-50, 50); +static mut NO_PADDING_16: (i16, i16, u16) = (-1, 2, 3); + +static mut NO_PADDING_32: (i32, f32, u32) = (4, 5.0, 6); +static mut NO_PADDING_64: (i64, f64, u64) = (7, 8.0, 9); + +static mut INTERNAL_PADDING_1: (i16, i32) = (10, 11); +static mut INTERNAL_PADDING_2: (i16, i32, u32, u64) = (12, 13, 14, 15); + +static mut PADDING_AT_END: (i32, i16) = (16, 17); fn main() { let noPadding8: (i8, u8) = (-100, 100); @@ -46,6 +93,19 @@ fn main() { let paddingAtEnd: (i32, i16) = (15, 16); + unsafe { + NO_PADDING_8 = (-127, 127); + NO_PADDING_16 = (-10, 10, 9); + + NO_PADDING_32 = (14, 15.0, 16); + NO_PADDING_64 = (17, 18.0, 19); + + INTERNAL_PADDING_1 = (110, 111); + INTERNAL_PADDING_2 = (112, 113, 114, 115); + + PADDING_AT_END = (116, 117); + } + zzz(); } diff --git a/src/test/debug-info/vec-slices.rs b/src/test/debug-info/vec-slices.rs index e50e7a9919860..b60e581841174 100644 --- a/src/test/debug-info/vec-slices.rs +++ b/src/test/debug-info/vec-slices.rs @@ -47,6 +47,11 @@ // debugger:print padded_struct.data_ptr[1] // check:$13 = {x = 13, y = 14, z = 15} +// debugger:print 'vec-slices::MUT_VECT_SLICE'.length +// check:$14 = 2 +// debugger:print *((int64_t[2]*)('vec-slices::MUT_VECT_SLICE'.data_ptr)) +// check:$15 = {64, 65} + #[allow(unused_variable)]; struct AStruct { @@ -55,6 +60,9 @@ struct AStruct { z: i16 } +static VECT_SLICE: &'static [i64] = &[64, 65]; +static mut MUT_VECT_SLICE: &'static [i64] = &[32]; + fn main() { let empty: &[i64] = &[]; let singleton: &[i64] = &[1]; @@ -68,6 +76,10 @@ fn main() { AStruct { x: 13, y: 14, z: 15 } ]; + unsafe { + MUT_VECT_SLICE = VECT_SLICE; + } + zzz(); } diff --git a/src/test/debug-info/vec.rs b/src/test/debug-info/vec.rs index 04f47f44f18d2..ad88606d48532 100644 --- a/src/test/debug-info/vec.rs +++ b/src/test/debug-info/vec.rs @@ -17,12 +17,22 @@ // debugger:finish // debugger:print a // check:$1 = {1, 2, 3} +// debugger:print vec::VECT +// check:$2 = {4, 5, 6} #[allow(unused_variable)]; +static mut VECT: [i32, ..3] = [1, 2, 3]; + fn main() { let a = [1, 2, 3]; + unsafe { + VECT[0] = 4; + VECT[1] = 5; + VECT[2] = 6; + } + zzz(); }