4e67e08efd
This switches from a custom list of architectures to use the target-lexicon crate. - "set is_64bit=1; isa x86" is replaced with "target x86_64", and similar for other architectures, and the `is_64bit` flag is removed entirely. - The `is_compressed` flag is removed too; it's no longer being used to control REX prefixes on x86-64, ARM and Thumb are separate architectures in target-lexicon, and we can figure out how to select RISC-V compressed encodings when we're ready.
84 lines
2.6 KiB
Rust
84 lines
2.6 KiB
Rust
extern crate cretonne_codegen;
|
|
extern crate cretonne_wasm;
|
|
#[macro_use]
|
|
extern crate target_lexicon;
|
|
extern crate wabt;
|
|
|
|
use cretonne_codegen::print_errors::pretty_verifier_error;
|
|
use cretonne_codegen::settings::{self, Configurable, Flags};
|
|
use cretonne_codegen::verifier;
|
|
use cretonne_wasm::{translate_module, DummyEnvironment};
|
|
use std::fs;
|
|
use std::fs::File;
|
|
use std::io;
|
|
use std::io::prelude::*;
|
|
use std::path::Path;
|
|
use std::str::FromStr;
|
|
use wabt::wat2wasm;
|
|
|
|
#[test]
|
|
fn testsuite() {
|
|
let mut paths: Vec<_> = fs::read_dir("../../wasmtests")
|
|
.unwrap()
|
|
.map(|r| r.unwrap())
|
|
.filter(|p| {
|
|
// Ignore files starting with `.`, which could be editor temporary files
|
|
if let Some(stem) = p.path().file_stem() {
|
|
if let Some(stemstr) = stem.to_str() {
|
|
return !stemstr.starts_with('.');
|
|
}
|
|
}
|
|
false
|
|
})
|
|
.collect();
|
|
paths.sort_by_key(|dir| dir.path());
|
|
let flags = Flags::new(settings::builder());
|
|
for path in paths {
|
|
let path = path.path();
|
|
handle_module(&path, &flags);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn return_at_end() {
|
|
let mut flag_builder = settings::builder();
|
|
flag_builder.enable("return_at_end").unwrap();
|
|
let flags = Flags::new(flag_builder);
|
|
handle_module(Path::new("../../wasmtests/return_at_end.wat"), &flags);
|
|
}
|
|
|
|
fn read_file(path: &Path) -> Result<Vec<u8>, io::Error> {
|
|
let mut buf: Vec<u8> = Vec::new();
|
|
let mut file = File::open(path)?;
|
|
file.read_to_end(&mut buf)?;
|
|
Ok(buf)
|
|
}
|
|
|
|
fn handle_module(path: &Path, flags: &Flags) {
|
|
let data = match path.extension() {
|
|
None => {
|
|
panic!("the file extension is not wasm or wat");
|
|
}
|
|
Some(ext) => match ext.to_str() {
|
|
Some("wasm") => read_file(path).expect("error reading wasm file"),
|
|
Some("wat") => {
|
|
let wat = read_file(path).expect("error reading wat file");
|
|
match wat2wasm(&wat) {
|
|
Ok(wasm) => wasm,
|
|
Err(e) => {
|
|
panic!("error converting wat to wasm: {:?}", e);
|
|
}
|
|
}
|
|
}
|
|
None | Some(&_) => panic!("the file extension for {:?} is not wasm or wat", path),
|
|
},
|
|
};
|
|
let mut dummy_environ = DummyEnvironment::with_triple_flags(triple!("riscv64"), flags.clone());
|
|
translate_module(&data, &mut dummy_environ).unwrap();
|
|
for func in &dummy_environ.info.function_bodies {
|
|
verifier::verify_function(func, flags)
|
|
.map_err(|err| panic!(pretty_verifier_error(func, None, &err)))
|
|
.unwrap();
|
|
}
|
|
}
|