Skip to content

Commit

Permalink
Rollup merge of rust-lang#74237 - lzutao:compiletest, r=Mark-Simulacrum
Browse files Browse the repository at this point in the history 
compiletest: Rewrite extract_*_version functions

This makes extract_lldb_version has the same version type like
extract_gdb_version.
  • Loading branch information
@Manishearth
Manishearth committed Jul 18, 2020
2 parents aa667a5 + 47a0f69 commit 89fdf3b
Show file tree
Hide file tree
Showing 4 changed files with 99 additions and 161 deletions.
2 changes: 1 addition & 1 deletion src/tools/compiletest/src/common.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -268,7 +268,7 @@ pub struct Config {
pub gdb_native_rust: bool,

/// Version of LLDB
pub lldb_version: Option<String>,
pub lldb_version: Option<u32>,

/// Whether LLDB has native rust support
pub lldb_native_rust: bool,
Expand Down
54 changes: 23 additions & 31 deletions src/tools/compiletest/src/header.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -132,32 +132,29 @@ impl EarlyProps {

fn ignore_gdb(config: &Config, line: &str) -> bool {
if let Some(actual_version) = config.gdb_version {
if line.starts_with("min-gdb-version") {
let (start_ver, end_ver) = extract_gdb_version_range(line);
if let Some(rest) = line.strip_prefix("min-gdb-version:").map(str::trim) {
let (start_ver, end_ver) = extract_gdb_version_range(rest);

if start_ver != end_ver {
panic!("Expected single GDB version")
}
// Ignore if actual version is smaller the minimum required
// version
actual_version < start_ver
} else if line.starts_with("ignore-gdb-version") {
let (min_version, max_version) = extract_gdb_version_range(line);
return actual_version < start_ver;
} else if let Some(rest) = line.strip_prefix("ignore-gdb-version:").map(str::trim) {
let (min_version, max_version) = extract_gdb_version_range(rest);

if max_version < min_version {
panic!("Malformed GDB version range: max < min")
}

actual_version >= min_version && actual_version <= max_version
} else {
false
return actual_version >= min_version && actual_version <= max_version;
}
} else {
false
}
false
}

// Takes a directive of the form "ignore-gdb-version <version1> [- <version2>]",
// Takes a directive of the form "<version1> [- <version2>]",
// returns the numeric representation of <version1> and <version2> as
// tuple: (<version1> as u32, <version2> as u32)
// If the <version2> part is omitted, the second component of the tuple
Expand All @@ -173,31 +170,32 @@ impl EarlyProps {
.take(3) // 3 or more = invalid, so take at most 3.
.collect::<Vec<Option<u32>>>();

match range_components.len() {
1 => {
let v = range_components[0].unwrap();
match *range_components {
[v] => {
let v = v.unwrap();
(v, v)
}
2 => {
let v_min = range_components[0].unwrap();
let v_max = range_components[1].expect(ERROR_MESSAGE);
[min, max] => {
let v_min = min.unwrap();
let v_max = max.expect(ERROR_MESSAGE);
(v_min, v_max)
}
_ => panic!(ERROR_MESSAGE),
}
}

fn ignore_lldb(config: &Config, line: &str) -> bool {
if let Some(ref actual_version) = config.lldb_version {
if line.starts_with("min-lldb-version") {
let min_version = line
.trim_end()
.rsplit(' ')
.next()
.expect("Malformed lldb version directive");
if let Some(actual_version) = config.lldb_version {
if let Some(min_version) = line.strip_prefix("min-lldb-version:").map(str::trim) {
let min_version = min_version.parse().unwrap_or_else(|e| {
panic!(
"Unexpected format of LLDB version string: {}\n{:?}",
min_version, e
);
});
// Ignore if actual version is smaller the minimum required
// version
lldb_version_to_int(actual_version) < lldb_version_to_int(min_version)
actual_version < min_version
} else if line.starts_with("rust-lldb") && !config.lldb_native_rust {
true
} else {
Expand Down Expand Up @@ -944,12 +942,6 @@ impl Config {
}
}

pub fn lldb_version_to_int(version_string: &str) -> isize {
let error_string =
format!("Encountered LLDB version string with unexpected format: {}", version_string);
version_string.parse().expect(&error_string)
}

fn expand_variables(mut value: String, config: &Config) -> String {
const CWD: &'static str = "{{cwd}}";
const SRC_BASE: &'static str = "{{src-base}}";
Expand Down
191 changes: 63 additions & 128 deletions src/tools/compiletest/src/main.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -165,9 +165,13 @@ pub fn parse_config(args: Vec<String>) -> Config {
let cdb = analyze_cdb(matches.opt_str("cdb"), &target);
let (gdb, gdb_version, gdb_native_rust) =
analyze_gdb(matches.opt_str("gdb"), &target, &android_cross_path);
let (lldb_version, lldb_native_rust) = extract_lldb_version(matches.opt_str("lldb-version"));

let color = match matches.opt_str("color").as_ref().map(|x| &**x) {
let (lldb_version, lldb_native_rust) = matches
.opt_str("lldb-version")
.as_deref()
.and_then(extract_lldb_version)
.map(|(v, b)| (Some(v), b))
.unwrap_or((None, false));
let color = match matches.opt_str("color").as_deref() {
Some("auto") | None => ColorConfig::AutoColor,
Some("always") => ColorConfig::AlwaysColor,
Some("never") => ColorConfig::NeverColor,
Expand Down Expand Up @@ -251,7 +255,7 @@ pub fn log_config(config: &Config) {
logv(c, format!("stage_id: {}", config.stage_id));
logv(c, format!("mode: {}", config.mode));
logv(c, format!("run_ignored: {}", config.run_ignored));
logv(c, format!("filter: {}", opt_str(&config.filter.as_ref().map(|re| re.to_owned()))));
logv(c, format!("filter: {}", opt_str(&config.filter)));
logv(c, format!("filter_exact: {}", config.filter_exact));
logv(
c,
Expand Down Expand Up @@ -400,17 +404,14 @@ fn configure_lldb(config: &Config) -> Option<Config> {
return None;
}

if let Some(lldb_version) = config.lldb_version.as_ref() {
if lldb_version == "350" {
println!(
"WARNING: The used version of LLDB ({}) has a \
known issue that breaks debuginfo tests. See \
issue #32520 for more information. Skipping all \
LLDB-based tests!",
lldb_version
);
return None;
}
if let Some(350) = config.lldb_version {
println!(
"WARNING: The used version of LLDB (350) has a \
known issue that breaks debuginfo tests. See \
issue #32520 for more information. Skipping all \
LLDB-based tests!",
);
return None;
}

// Some older versions of LLDB seem to have problems with multiple
Expand Down Expand Up @@ -722,9 +723,7 @@ fn make_test_closure(
let config = config.clone();
let testpaths = testpaths.clone();
let revision = revision.cloned();
test::DynTestFn(Box::new(move || {
runtest::run(config, &testpaths, revision.as_ref().map(|s| s.as_str()))
}))
test::DynTestFn(Box::new(move || runtest::run(config, &testpaths, revision.as_deref())))
}

/// Returns `true` if the given target is an Android target for the
Expand Down Expand Up @@ -840,75 +839,40 @@ fn extract_gdb_version(full_version_line: &str) -> Option<u32> {
// This particular form is documented in the GNU coding standards:
// https://www.gnu.org/prep/standards/html_node/_002d_002dversion.html#g_t_002d_002dversion

// don't start parsing in the middle of a number
let mut prev_was_digit = false;
let mut in_parens = false;
for (pos, c) in full_version_line.char_indices() {
if in_parens {
if c == ')' {
in_parens = false;
}
continue;
} else if c == '(' {
in_parens = true;
continue;
}

if prev_was_digit || !c.is_digit(10) {
prev_was_digit = c.is_digit(10);
continue;
let mut splits = full_version_line.rsplit(' ');
let version_string = splits.next().unwrap();

let mut splits = version_string.split('.');
let major = splits.next().unwrap();
let minor = splits.next().unwrap();
let patch = splits.next();

let major: u32 = major.parse().unwrap();
let (minor, patch): (u32, u32) = match minor.find(not_a_digit) {
None => {
let minor = minor.parse().unwrap();
let patch: u32 = match patch {
Some(patch) => match patch.find(not_a_digit) {
None => patch.parse().unwrap(),
Some(idx) if idx > 3 => 0,
Some(idx) => patch[..idx].parse().unwrap(),
},
None => 0,
};
(minor, patch)
}

prev_was_digit = true;

let line = &full_version_line[pos..];

let next_split = match line.find(|c: char| !c.is_digit(10)) {
Some(idx) => idx,
None => continue, // no minor version
};

if line.as_bytes()[next_split] != b'.' {
continue; // no minor version
// There is no patch version after minor-date (e.g. "4-2012").
Some(idx) => {
let minor = minor[..idx].parse().unwrap();
(minor, 0)
}
};

let major = &line[..next_split];
let line = &line[next_split + 1..];

let (minor, patch) = match line.find(|c: char| !c.is_digit(10)) {
Some(idx) => {
if line.as_bytes()[idx] == b'.' {
let patch = &line[idx + 1..];

let patch_len =
patch.find(|c: char| !c.is_digit(10)).unwrap_or_else(|| patch.len());
let patch = &patch[..patch_len];
let patch = if patch_len > 3 || patch_len == 0 { None } else { Some(patch) };

(&line[..idx], patch)
} else {
(&line[..idx], None)
}
}
None => (line, None),
};

if minor.is_empty() {
continue;
}

let major: u32 = major.parse().unwrap();
let minor: u32 = minor.parse().unwrap();
let patch: u32 = patch.unwrap_or("0").parse().unwrap();

return Some(((major * 1000) + minor) * 1000 + patch);
}

None
Some(((major * 1000) + minor) * 1000 + patch)
}

/// Returns (LLDB version, LLDB is rust-enabled)
fn extract_lldb_version(full_version_line: Option<String>) -> (Option<String>, bool) {
fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> {
// Extract the major LLDB version from the given version string.
// LLDB version strings are different for Apple and non-Apple platforms.
// The Apple variant looks like this:
Expand All @@ -917,7 +881,7 @@ fn extract_lldb_version(full_version_line: Option<String>) -> (Option<String>, b
// lldb-300.2.51 (new versions)
//
// We are only interested in the major version number, so this function
// will return `Some("179")` and `Some("300")` respectively.
// will return `Some(179)` and `Some(300)` respectively.
//
// Upstream versions look like:
// lldb version 6.0.1
Expand All @@ -929,53 +893,24 @@ fn extract_lldb_version(full_version_line: Option<String>) -> (Option<String>, b
// normally fine because the only non-Apple version we test is
// rust-enabled.

if let Some(ref full_version_line) = full_version_line {
if !full_version_line.trim().is_empty() {
let full_version_line = full_version_line.trim();

for (pos, l) in full_version_line.char_indices() {
if l != 'l' && l != 'L' {
continue;
}
if pos + 5 >= full_version_line.len() {
continue;
}
let l = full_version_line[pos + 1..].chars().next().unwrap();
if l != 'l' && l != 'L' {
continue;
}
let d = full_version_line[pos + 2..].chars().next().unwrap();
if d != 'd' && d != 'D' {
continue;
}
let b = full_version_line[pos + 3..].chars().next().unwrap();
if b != 'b' && b != 'B' {
continue;
}
let dash = full_version_line[pos + 4..].chars().next().unwrap();
if dash != '-' {
continue;
}

let vers = full_version_line[pos + 5..]
.chars()
.take_while(|c| c.is_digit(10))
.collect::<String>();
if !vers.is_empty() {
return (Some(vers), full_version_line.contains("rust-enabled"));
}
}
let full_version_line = full_version_line.trim();

if full_version_line.starts_with("lldb version ") {
let vers = full_version_line[13..]
.chars()
.take_while(|c| c.is_digit(10))
.collect::<String>();
if !vers.is_empty() {
return (Some(vers + "00"), full_version_line.contains("rust-enabled"));
}
}
if let Some(apple_ver) =
full_version_line.strip_prefix("LLDB-").or_else(|| full_version_line.strip_prefix("lldb-"))
{
if let Some(idx) = apple_ver.find(not_a_digit) {
let version: u32 = apple_ver[..idx].parse().unwrap();
return Some((version, full_version_line.contains("rust-enabled")));
}
} else if let Some(lldb_ver) = full_version_line.strip_prefix("lldb version ") {
if let Some(idx) = lldb_ver.find(not_a_digit) {
let version: u32 = lldb_ver[..idx].parse().unwrap();
return Some((version * 100, full_version_line.contains("rust-enabled")));
}
}
(None, false)
None
}

fn not_a_digit(c: char) -> bool {
!c.is_digit(10)
}
13 changes: 12 additions & 1 deletion src/tools/compiletest/src/tests.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@ use super::*;

#[test]
fn test_extract_gdb_version() {
macro_rules! test { ($($expectation:tt: $input:tt,)*) => {{$(
macro_rules! test { ($($expectation:literal: $input:literal,)*) => {{$(
assert_eq!(extract_gdb_version($input), Some($expectation));
)*}}}

Expand Down Expand Up @@ -41,6 +41,17 @@ fn test_extract_gdb_version() {
}
}

#[test]
fn test_extract_lldb_version() {
// Apple variants
assert_eq!(extract_lldb_version("LLDB-179.5"), Some((179, false)));
assert_eq!(extract_lldb_version("lldb-300.2.51"), Some((300, false)));

// Upstream versions
assert_eq!(extract_lldb_version("lldb version 6.0.1"), Some((600, false)));
assert_eq!(extract_lldb_version("lldb version 9.0.0"), Some((900, false)));
}

#[test]
fn is_test_test() {
assert_eq!(true, is_test(&OsString::from("a_test.rs")));
Expand Down

0 comments on commit 89fdf3b

Please sign in to comment.