T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removes panic! from the debug crate. (#1261)

Browse Source
This commit is contained in:
Yury Delendik
2020-03-09 12:25:38 -05:00
committed by GitHub
parent 2ee35c9d3a
commit ba1f10f4d4
9 changed files with 96 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
crates/debug/src/read_debuginfo.rs
View File

@@ -1,3 +1,4 @@
use anyhow::{bail, Result};
use gimli::{
DebugAbbrev, DebugAddr, DebugInfo, DebugLine, DebugLineStr, DebugLoc, DebugLocLists,
DebugRanges, DebugRngLists, DebugStr, DebugStrOffsets, DebugTypes, EndianSlice, LittleEndian,
@@ -42,7 +43,7 @@ pub struct DebugInfoData<'a> {
pub wasm_file: WasmFileInfo,
}
fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Dwarf<'a> {
fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Result<Dwarf<'a>> {
const EMPTY_SECTION: &[u8] = &[];
let endian = LittleEndian;
@@ -61,20 +62,20 @@ fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Dwarf<'a> {
);
if sections.contains_key(".debug_addr") {
panic!("Unexpected .debug_addr");
bail!("Unexpected .debug_addr");
}
let debug_addr = DebugAddr::from(EndianSlice::new(EMPTY_SECTION, endian));
if sections.contains_key(".debug_line_str") {
panic!("Unexpected .debug_line_str");
bail!("Unexpected .debug_line_str");
}
let debug_line_str = DebugLineStr::from(EndianSlice::new(EMPTY_SECTION, endian));
let debug_str_sup = DebugStr::from(EndianSlice::new(EMPTY_SECTION, endian));
if sections.contains_key(".debug_rnglists") {
panic!("Unexpected .debug_rnglists");
bail!("Unexpected .debug_rnglists");
}
let debug_ranges = match sections.get(".debug_ranges") {
@@ -85,7 +86,7 @@ fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Dwarf<'a> {
let ranges = RangeLists::new(debug_ranges, debug_rnglists);
if sections.contains_key(".debug_loclists") {
panic!("Unexpected .debug_loclists");
bail!("Unexpected .debug_loclists");
}
let debug_loc = match sections.get(".debug_loc") {
@@ -96,18 +97,18 @@ fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Dwarf<'a> {
let locations = LocationLists::new(debug_loc, debug_loclists);
if sections.contains_key(".debug_str_offsets") {
panic!("Unexpected .debug_str_offsets");
bail!("Unexpected .debug_str_offsets");
}
let debug_str_offsets = DebugStrOffsets::from(EndianSlice::new(EMPTY_SECTION, endian));
if sections.contains_key(".debug_types") {
panic!("Unexpected .debug_types");
bail!("Unexpected .debug_types");
}
let debug_types = DebugTypes::from(EndianSlice::new(EMPTY_SECTION, endian));
Dwarf {
Ok(Dwarf {
debug_abbrev,
debug_addr,
debug_info,
@@ -119,7 +120,7 @@ fn convert_sections<'a>(sections: HashMap<&str, &'a [u8]>) -> Dwarf<'a> {
debug_types,
locations,
ranges,
}
})
}
fn read_name_section(reader: wasmparser::NameSectionReader) -> wasmparser::Result<NameSection> {
@@ -158,8 +159,8 @@ fn read_name_section(reader: wasmparser::NameSectionReader) -> wasmparser::Resul
Ok(result)
}
pub fn read_debuginfo(data: &[u8]) -> DebugInfoData {
let mut reader = ModuleReader::new(data).expect("reader");
pub fn read_debuginfo(data: &[u8]) -> Result<DebugInfoData> {
let mut reader = ModuleReader::new(data)?;
let mut sections = HashMap::new();
let mut name_section = None;
let mut code_section_offset = 0;
@@ -169,13 +170,13 @@ pub fn read_debuginfo(data: &[u8]) -> DebugInfoData {
let mut func_locals: Vec<Box<[(u32, WasmType)]>> = Vec::new();
while !reader.eof() {
let section = reader.read().expect("section");
let section = reader.read()?;
match section.code {
SectionCode::Custom { name, .. } => {
if name.starts_with(".debug_") {
let mut reader = section.get_binary_reader();
let len = reader.bytes_remaining();
sections.insert(name, reader.read_bytes(len).expect("bytes"));
sections.insert(name, reader.read_bytes(len)?);
}
if name == "name" {
if let Ok(reader) = section.get_name_section_reader() {
@@ -187,38 +188,31 @@ pub fn read_debuginfo(data: &[u8]) -> DebugInfoData {
}
SectionCode::Type => {
signatures_params = section
.get_type_section_reader()
.expect("type section")
.get_type_section_reader()?
.into_iter()
.map(|ft| ft.expect("type").params)
.collect::<Vec<_>>();
.map(|ft| Ok(ft?.params))
.collect::<Result<Vec<_>>>()?;
}
SectionCode::Function => {
func_params_refs = section
.get_function_section_reader()
.expect("function section")
.get_function_section_reader()?
.into_iter()
.map(|index| index.expect("func index") as usize)
.collect::<Vec<_>>();
.map(|index| Ok(index? as usize))
.collect::<Result<Vec<_>>>()?;
}
SectionCode::Code => {
code_section_offset = section.range().start as u64;
func_locals = section
.get_code_section_reader()
.expect("code section")
.get_code_section_reader()?
.into_iter()
.map(|body| {
let locals = body
.expect("body")
.get_locals_reader()
.expect("locals reader");
locals
let locals = body?.get_locals_reader()?;
Ok(locals
.into_iter()
.collect::<Result<Vec<_>, _>>()
.expect("locals data")
.into_boxed_slice()
.collect::<Result<Vec<_>, _>>()?
.into_boxed_slice())
})
.collect::<Vec<_>>();
.collect::<Result<Vec<_>>>()?;
}
_ => (),
}
@@ -233,13 +227,14 @@ pub fn read_debuginfo(data: &[u8]) -> DebugInfoData {
})
.collect::<Vec<_>>();
DebugInfoData {
dwarf: convert_sections(sections),
let dwarf = convert_sections(sections)?;
Ok(DebugInfoData {
dwarf,
name_section,
wasm_file: WasmFileInfo {
path: None,
code_section_offset,
funcs: func_meta.into_boxed_slice(),
},
}
})
}

14
crates/debug/src/transform/attr.rs
View File

@@ -3,7 +3,7 @@ use super::expression::{compile_expression, CompiledExpression, FunctionFrameInf
use super::range_info_builder::RangeInfoBuilder;
use super::refs::{PendingDebugInfoRefs, PendingUnitRefs};
use super::{DebugInputContext, Reader, TransformError};
use anyhow::Error;
use anyhow::{bail, Error};
use gimli::{write, AttributeValue, DebugLineOffset, DebugStr, DebuggingInformationEntry};
use wasmtime_environ::isa::TargetIsa;
@@ -143,7 +143,7 @@ where
addr_tr,
frame_info,
endian,
) {
)? {
if len == 0 {
// Ignore empty range
continue;
@@ -183,7 +183,7 @@ where
// Conversion to loclist is required.
if let Some(scope_ranges) = scope_ranges {
let exprs =
expr.build_with_locals(scope_ranges, addr_tr, frame_info, endian);
expr.build_with_locals(scope_ranges, addr_tr, frame_info, endian)?;
if exprs.is_empty() {
continue;
}
@@ -252,7 +252,7 @@ where
pending_di_refs.insert(current_scope_id, attr.name(), offset);
continue;
}
_ => panic!(), //write::AttributeValue::StringRef(out_strings.add("_")),
a => bail!("Unexpected attribute: {:?}", a),
};
let current_scope = out_unit.get_mut(current_scope_id);
current_scope.set(attr.name(), attr_value);
@@ -265,7 +265,7 @@ pub(crate) fn clone_attr_string<R>(
form: gimli::DwForm,
debug_str: &DebugStr<R>,
out_strings: &mut write::StringTable,
) -> Result<write::LineString, gimli::Error>
) -> Result<write::LineString, Error>
where
R: Reader,
{
@@ -274,7 +274,7 @@ where
debug_str.get_str(*str_offset)?.to_slice()?.to_vec()
}
AttributeValue::String(b) => b.to_slice()?.to_vec(),
_ => panic!("Unexpected attribute value"),
v => bail!("Unexpected attribute value: {:?}", v),
};
Ok(match form {
gimli::DW_FORM_strp => {
@@ -282,6 +282,6 @@ where
write::LineString::StringRef(id)
}
gimli::DW_FORM_string => write::LineString::String(content),
_ => panic!("DW_FORM_line_strp or other not supported"),
_ => bail!("DW_FORM_line_strp or other not supported"),
})
}

70
crates/debug/src/transform/expression.rs
View File

@@ -1,5 +1,5 @@
use super::address_transform::AddressTransform;
use anyhow::Error;
use anyhow::{bail, Context, Error, Result};
use gimli::{self, write, Expression, Operation, Reader, ReaderOffset, Register, X86_64};
use more_asserts::{assert_le, assert_lt};
use std::collections::{HashMap, HashSet};
@@ -70,7 +70,7 @@ impl<'a> CompiledExpression<'a> {
}
}
fn map_reg(isa: &dyn TargetIsa, reg: RegUnit) -> Register {
fn map_reg(isa: &dyn TargetIsa, reg: RegUnit) -> Result<Register> {
// TODO avoid duplication with fde.rs
assert!(isa.name() == "x86" && isa.pointer_bits() == 64);
// Mapping from https://github.com/bytecodealliance/cranelift/pull/902 by @iximeow
@@ -116,11 +116,11 @@ fn map_reg(isa: &dyn TargetIsa, reg: RegUnit) -> Register {
"IntRegs" => {
// x86 GP registers have a weird mapping to DWARF registers, so we use a
// lookup table.
X86_GP_REG_MAP[(reg - bank.first_unit) as usize]
Ok(X86_GP_REG_MAP[(reg - bank.first_unit) as usize])
}
"FloatRegs" => X86_XMM_REG_MAP[(reg - bank.first_unit) as usize],
_ => {
panic!("unsupported register bank: {}", bank.name);
"FloatRegs" => Ok(X86_XMM_REG_MAP[(reg - bank.first_unit) as usize]),
bank_name => {
bail!("unsupported register bank: {}", bank_name);
}
}
}
@@ -129,22 +129,18 @@ fn translate_loc(
loc: ValueLoc,
frame_info: Option<&FunctionFrameInfo>,
isa: &dyn TargetIsa,
) -> Option<Vec<u8>> {
) -> Result<Option<Vec<u8>>> {
use gimli::write::Writer;
match loc {
Ok(match loc {
ValueLoc::Reg(reg) => {
let machine_reg = map_reg(isa, reg).0 as u8;
let machine_reg = map_reg(isa, reg)?.0 as u8;
Some(if machine_reg < 32 {
vec![gimli::constants::DW_OP_reg0.0 + machine_reg]
} else {
let endian = gimli::RunTimeEndian::Little;
let mut writer = write::EndianVec::new(endian);
writer
.write_u8(gimli::constants::DW_OP_regx.0 as u8)
.expect("regx");
writer
.write_uleb128(machine_reg.into())
.expect("machine_reg");
writer.write_u8(gimli::constants::DW_OP_regx.0 as u8)?;
writer.write_uleb128(machine_reg.into())?;
writer.into_vec()
})
}
@@ -153,21 +149,17 @@ fn translate_loc(
if let Some(ss_offset) = frame_info.stack_slots[ss].offset {
let endian = gimli::RunTimeEndian::Little;
let mut writer = write::EndianVec::new(endian);
writer
.write_u8(gimli::constants::DW_OP_breg0.0 + X86_64::RBP.0 as u8)
.expect("bp wr");
writer.write_sleb128(ss_offset as i64 + 16).expect("ss wr");
writer
.write_u8(gimli::constants::DW_OP_deref.0 as u8)
.expect("bp wr");
writer.write_u8(gimli::constants::DW_OP_breg0.0 + X86_64::RBP.0 as u8)?;
writer.write_sleb128(ss_offset as i64 + 16)?;
writer.write_u8(gimli::constants::DW_OP_deref.0 as u8)?;
let buf = writer.into_vec();
return Some(buf);
return Ok(Some(buf));
}
}
None
}
_ => None,
}
})
}
fn append_memory_deref(
@@ -176,13 +168,13 @@ fn append_memory_deref(
vmctx_loc: ValueLoc,
endian: gimli::RunTimeEndian,
isa: &dyn TargetIsa,
) -> write::Result<bool> {
) -> Result<bool> {
use gimli::write::Writer;
let mut writer = write::EndianVec::new(endian);
// FIXME for imported memory
match vmctx_loc {
ValueLoc::Reg(vmctx_reg) => {
let reg = map_reg(isa, vmctx_reg);
let reg = map_reg(isa, vmctx_reg)?;
writer.write_u8(gimli::constants::DW_OP_breg0.0 + reg.0 as u8)?;
let memory_offset = match frame_info.vmctx_memory_offset() {
Some(offset) => offset,
@@ -248,9 +240,9 @@ impl<'a> CompiledExpression<'a> {
addr_tr: &AddressTransform,
frame_info: Option<&FunctionFrameInfo>,
endian: gimli::RunTimeEndian,
) -> Vec<(write::Address, u64, write::Expression)> {
) -> Result<Vec<(write::Address, u64, write::Expression)>> {
if scope.is_empty() {
return vec![];
return Ok(vec![]);
}
if let [CompiledExpressionPart::Code(code)] = self.parts.as_slice() {
@@ -260,7 +252,7 @@ impl<'a> CompiledExpression<'a> {
result_scope.push((addr, len, write::Expression(code.to_vec())));
}
}
return result_scope;
return Ok(result_scope);
}
let vmctx_label = get_vmctx_value_label();
@@ -295,8 +287,8 @@ impl<'a> CompiledExpression<'a> {
match part {
CompiledExpressionPart::Code(c) => code_buf.extend_from_slice(c.as_slice()),
CompiledExpressionPart::Local(label) => {
let loc = *label_location.get(&label).expect("loc");
if let Some(expr) = translate_loc(loc, frame_info, self.isa) {
let loc = *label_location.get(&label).context("label_location")?;
if let Some(expr) = translate_loc(loc, frame_info, self.isa)? {
code_buf.extend_from_slice(&expr)
} else {
continue 'range;
@@ -312,9 +304,7 @@ impl<'a> CompiledExpression<'a> {
*vmctx_loc,
endian,
self.isa,
)
.expect("append_memory_deref")
{
)? {
continue 'range;
}
} else {
@@ -327,9 +317,13 @@ impl<'a> CompiledExpression<'a> {
if let (Some(vmctx_loc), Some(frame_info)) =
(label_location.get(&vmctx_label), frame_info)
{
if !append_memory_deref(&mut code_buf, frame_info, *vmctx_loc, endian, self.isa)
.expect("append_memory_deref")
{
if !append_memory_deref(
&mut code_buf,
frame_info,
*vmctx_loc,
endian,
self.isa,
)? {
continue 'range;
}
} else {
@@ -346,7 +340,7 @@ impl<'a> CompiledExpression<'a> {
));
}
result
Ok(result)
}
}

6
crates/debug/src/transform/line_program.rs
View File

@@ -1,7 +1,7 @@
use super::address_transform::AddressTransform;
use super::attr::clone_attr_string;
use super::{Reader, TransformError};
use anyhow::Error;
use anyhow::{Context, Error};
use gimli::{
write, DebugLine, DebugLineOffset, DebugStr, DebuggingInformationEntry, LineEncoding, Unit,
};
@@ -56,13 +56,13 @@ where
let comp_dir = root.attr_value(gimli::DW_AT_comp_dir)?;
let comp_name = root.attr_value(gimli::DW_AT_name)?;
let out_comp_dir = clone_attr_string(
comp_dir.as_ref().expect("comp_dir"),
comp_dir.as_ref().context("comp_dir")?,
gimli::DW_FORM_strp,
debug_str,
out_strings,
)?;
let out_comp_name = clone_attr_string(
comp_name.as_ref().expect("comp_name"),
comp_name.as_ref().context("comp_name")?,
gimli::DW_FORM_strp,
debug_str,
out_strings,

25
crates/debug/src/transform/simulate.rs
View File

@@ -2,7 +2,7 @@ use super::expression::{CompiledExpression, FunctionFrameInfo};
use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
use super::AddressTransform;
use crate::read_debuginfo::WasmFileInfo;
use anyhow::Error;
use anyhow::{Context, Error};
use gimli::write;
use gimli::{self, LineEncoding};
use std::collections::{HashMap, HashSet};
@@ -177,7 +177,7 @@ fn generate_vars(
locals_names: Option<&HashMap<u32, String>>,
out_strings: &mut write::StringTable,
isa: &dyn TargetIsa,
) {
) -> Result<(), Error> {
let vmctx_label = get_vmctx_value_label();
// Normalize order of ValueLabelsRanges keys to have reproducable results.
@@ -195,8 +195,7 @@ fn generate_vars(
scope_ranges,
out_strings,
isa,
)
.expect("append_vmctx_info success");
)?;
} else {
let var_index = label.index();
let (type_die_id, is_param) =
@@ -213,7 +212,7 @@ fn generate_vars(
let expr = CompiledExpression::from_label(*label, isa);
let mut locs = Vec::new();
for (begin, length, data) in
expr.build_with_locals(scope_ranges, addr_tr, Some(frame_info), endian)
expr.build_with_locals(scope_ranges, addr_tr, Some(frame_info), endian)?
{
locs.push(write::Location::StartLength {
begin,
@@ -250,6 +249,7 @@ fn generate_vars(
);
}
}
Ok(())
}
pub fn generate_simulated_dwarf(
@@ -279,8 +279,17 @@ pub fn generate_simulated_dwarf(
};
let (unit, root_id, name_id) = {
let comp_dir_id = out_strings.add(path.parent().expect("path dir").to_str().unwrap());
let name = path.file_name().expect("path name").to_str().unwrap();
let comp_dir_id = out_strings.add(
path.parent()
.context("path dir")?
.to_str()
.context("path dir encoding")?,
);
let name = path
.file_name()
.context("path name")?
.to_str()
.context("path name encoding")?;
let name_id = out_strings.add(name);
let out_program = generate_line_info(
@@ -370,7 +379,7 @@ pub fn generate_simulated_dwarf(
locals_names.and_then(|m| m.get(&(index as u32))),
out_strings,
isa,
);
)?;
}
}

4
crates/debug/src/transform/unit.rs
View File

@@ -6,7 +6,7 @@ use super::range_info_builder::RangeInfoBuilder;
use super::refs::{PendingDebugInfoRefs, PendingUnitRefs, UnitRefsMap};
use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
use super::{DebugInputContext, Reader, TransformError};
use anyhow::Error;
use anyhow::{Context, Error};
use gimli::write;
use gimli::{AttributeValue, DebuggingInformationEntry, Unit};
use std::collections::HashSet;
@@ -356,7 +356,7 @@ where
vmctx_die_id,
addr_tr,
current_value_range.top(),
current_scope_ranges.top().expect("range"),
current_scope_ranges.top().context("range")?,
out_strings,
isa,
)?;

2
crates/debug/src/transform/utils.rs
View File

@@ -118,7 +118,7 @@ pub(crate) fn append_vmctx_info(
let expr = CompiledExpression::vmctx(isa);
let mut locs = Vec::new();
for (begin, length, data) in
expr.build_with_locals(scope_ranges, addr_tr, frame_info, endian)
expr.build_with_locals(scope_ranges, addr_tr, frame_info, endian)?
{
locs.push(write::Location::StartLength {
begin,

4
crates/jit/src/instantiate.rs
View File

@@ -71,7 +71,9 @@ impl<'data> RawCompiledModule<'data> {
.map_err(|error| SetupError::Compile(CompileError::Wasm(error)))?;
let debug_data = if debug_info {
Some(read_debuginfo(&data))
// TODO Do we want to ignore invalid DWARF data?
let debug_data = read_debuginfo(&data)?;
Some(debug_data)
} else {
None
};

2
src/obj.rs
View File

@@ -136,7 +136,7 @@ pub fn compile_to_obj(
.context("failed to emit module")?;
if debug_info {
let debug_data = read_debuginfo(wasm);
let debug_data = read_debuginfo(wasm).context("failed to emit DWARF")?;
emit_debugsections(
&mut obj,
&module_vmctx_info,