Auto merge of #148789 - m-ou-se:new-fmt-args-alt, r=wafflelapkin,jdonszelmann
New format_args!() and fmt::Arguments implementation Part of https://github.com/rust-lang/rust/issues/99012 This is a new implementation of `format_args!()` and `fmt::Arguments`. With this implementation, `fmt::Arguments` is only two pointers in size. (Instead of six, before.) This makes it the same size as a `&str` and makes it fit in a register pair. --- This `fmt::Arguments` can store a `&'static str` _without any indirection_ or additional storage. This means that simple cases like `print_fmt(format_args!("hello"))` are now just as efficient for the caller as `print_str("hello")`, as shown by this example: > code: > ```rust > fn main() { > println!("Hello, world!"); > } > ``` > > before: > ```asm > main: > sub rsp, 56 > lea rax, [rip + .Lanon_hello_world] > mov qword ptr [rsp + 8], rax > mov qword ptr [rsp + 16], 1 > mov qword ptr [rsp + 24], 8 > xorps xmm0, xmm0 > movups xmmword ptr [rsp + 32], xmm0 > lea rdi, [rsp + 8] > call qword ptr [rip + std::io::stdio::_print] > add rsp, 56 > ret > ``` > > after: > ```asm > main: > lea rsi, [rip + .Lanon_hello_world] > mov edi, 29 > jmp qword ptr [rip + std::io::stdio::_print] > ``` (`panic!("Hello, world!");` shows a similar change.) --- This implementation stores all static information as just a single (byte) string, without any indirection: > code: > ```rust > format_args!("Hello, {name:-^20}!") > ``` > > lowering before: > ```rust > fmt::Arguments::new_v1_formatted( > &["Hello, ", "!\n"], > &args, > &[ > Placeholder { > position: 0usize, > flags: 3355443245u32, > precision: format_count::Implied, > width: format_count::Is(20u16), > }, > ], > ) > ``` > > lowering after: > ```rust > fmt::Arguments::new( > b"\x07Hello, \xc3-\x00\x00\xc8\x14\x00\x02!\n\x00", > &args, > ) > ``` This saves a ton of pointers and simplifies the expansion significantly, but does mean that individual pieces (e.g. `"Hello, "` and `"!\n"`) cannot be reused. (Those pieces are often smaller than a pointer to them, though, in which case reusing them is useless.) --- The details of the new representation are documented in [library/core/src/fmt/mod.rs](https://github.com/m-ou-se/rust/blob/new-fmt-args-alt/library/core/src/fmt/mod.rs#L609-L712).
This commit is contained in:
bors
commit
503dce33e2
58 changed files with 895 additions and 998 deletions
|
|
@ -13,7 +13,7 @@ use rustc_middle::span_bug;
|
|||
use rustc_middle::ty::TyCtxt;
|
||||
use rustc_session::errors::report_lit_error;
|
||||
use rustc_span::source_map::{Spanned, respan};
|
||||
use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
|
||||
use rustc_span::{ByteSymbol, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
|
||||
use thin_vec::{ThinVec, thin_vec};
|
||||
use visit::{Visitor, walk_expr};
|
||||
|
||||
|
|
@ -924,7 +924,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
arena_vec![self; new_unchecked, get_context],
|
||||
),
|
||||
};
|
||||
self.arena.alloc(self.expr_unsafe(call))
|
||||
self.arena.alloc(self.expr_unsafe(span, call))
|
||||
};
|
||||
|
||||
// `::std::task::Poll::Ready(result) => break result`
|
||||
|
|
@ -1832,7 +1832,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
arena_vec![self; iter],
|
||||
));
|
||||
// `unsafe { ... }`
|
||||
let iter = self.arena.alloc(self.expr_unsafe(iter));
|
||||
let iter = self.arena.alloc(self.expr_unsafe(head_span, iter));
|
||||
let kind = self.make_lowered_await(head_span, iter, FutureKind::AsyncIterator);
|
||||
self.arena.alloc(hir::Expr { hir_id: self.next_id(), kind, span: head_span })
|
||||
}
|
||||
|
|
@ -1887,7 +1887,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
arena_vec![self; iter],
|
||||
));
|
||||
// `unsafe { ... }`
|
||||
let iter = self.arena.alloc(self.expr_unsafe(iter));
|
||||
let iter = self.arena.alloc(self.expr_unsafe(head_span, iter));
|
||||
let inner_match_expr = self.arena.alloc(self.expr_match(
|
||||
for_span,
|
||||
iter,
|
||||
|
|
@ -2103,26 +2103,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
self.arena.alloc(self.expr(sp, hir::ExprKind::Tup(&[])))
|
||||
}
|
||||
|
||||
fn expr_uint(&mut self, sp: Span, ty: ast::UintTy, value: u128) -> hir::Expr<'hir> {
|
||||
let lit = hir::Lit {
|
||||
span: self.lower_span(sp),
|
||||
node: ast::LitKind::Int(value.into(), ast::LitIntType::Unsigned(ty)),
|
||||
};
|
||||
self.expr(sp, hir::ExprKind::Lit(lit))
|
||||
}
|
||||
|
||||
pub(super) fn expr_usize(&mut self, sp: Span, value: usize) -> hir::Expr<'hir> {
|
||||
self.expr_uint(sp, ast::UintTy::Usize, value as u128)
|
||||
}
|
||||
|
||||
pub(super) fn expr_u32(&mut self, sp: Span, value: u32) -> hir::Expr<'hir> {
|
||||
self.expr_uint(sp, ast::UintTy::U32, value as u128)
|
||||
}
|
||||
|
||||
pub(super) fn expr_u16(&mut self, sp: Span, value: u16) -> hir::Expr<'hir> {
|
||||
self.expr_uint(sp, ast::UintTy::U16, value as u128)
|
||||
}
|
||||
|
||||
pub(super) fn expr_str(&mut self, sp: Span, value: Symbol) -> hir::Expr<'hir> {
|
||||
let lit = hir::Lit {
|
||||
span: self.lower_span(sp),
|
||||
|
|
@ -2131,6 +2111,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
self.expr(sp, hir::ExprKind::Lit(lit))
|
||||
}
|
||||
|
||||
pub(super) fn expr_byte_str(&mut self, sp: Span, value: ByteSymbol) -> hir::Expr<'hir> {
|
||||
let lit = hir::Lit {
|
||||
span: self.lower_span(sp),
|
||||
node: ast::LitKind::ByteStr(value, ast::StrStyle::Cooked),
|
||||
};
|
||||
self.expr(sp, hir::ExprKind::Lit(lit))
|
||||
}
|
||||
|
||||
pub(super) fn expr_call_mut(
|
||||
&mut self,
|
||||
span: Span,
|
||||
|
|
@ -2262,9 +2250,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
self.expr(span, expr_path)
|
||||
}
|
||||
|
||||
fn expr_unsafe(&mut self, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
|
||||
pub(super) fn expr_unsafe(
|
||||
&mut self,
|
||||
span: Span,
|
||||
expr: &'hir hir::Expr<'hir>,
|
||||
) -> hir::Expr<'hir> {
|
||||
let hir_id = self.next_id();
|
||||
let span = expr.span;
|
||||
self.expr(
|
||||
span,
|
||||
hir::ExprKind::Block(
|
||||
|
|
@ -2302,15 +2293,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
self.arena.alloc(self.expr_block(b))
|
||||
}
|
||||
|
||||
pub(super) fn expr_array_ref(
|
||||
&mut self,
|
||||
span: Span,
|
||||
elements: &'hir [hir::Expr<'hir>],
|
||||
) -> hir::Expr<'hir> {
|
||||
let array = self.arena.alloc(self.expr(span, hir::ExprKind::Array(elements)));
|
||||
self.expr_ref(span, array)
|
||||
}
|
||||
|
||||
pub(super) fn expr_ref(&mut self, span: Span, expr: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> {
|
||||
self.expr(span, hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Not, expr))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ use rustc_ast::*;
|
|||
use rustc_data_structures::fx::FxIndexMap;
|
||||
use rustc_hir as hir;
|
||||
use rustc_session::config::FmtDebug;
|
||||
use rustc_span::{DesugaringKind, Ident, Span, Symbol, sym};
|
||||
use rustc_span::{ByteSymbol, DesugaringKind, Ident, Span, Symbol, sym};
|
||||
|
||||
use super::LoweringContext;
|
||||
|
||||
|
|
@ -90,20 +90,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
|
|||
let mut inlined_anything = false;
|
||||
|
||||
for i in 0..fmt.template.len() {
|
||||
let FormatArgsPiece::Placeholder(placeholder) = &fmt.template[i] else { continue };
|
||||
let Ok(arg_index) = placeholder.argument.index else { continue };
|
||||
|
||||
let mut literal = None;
|
||||
|
||||
if let FormatTrait::Display = placeholder.format_trait
|
||||
if let FormatArgsPiece::Placeholder(placeholder) = &fmt.template[i]
|
||||
&& let Ok(arg_index) = placeholder.argument.index
|
||||
&& let FormatTrait::Display = placeholder.format_trait
|
||||
&& placeholder.format_options == Default::default()
|
||||
&& let arg = fmt.arguments.all_args()[arg_index].expr.peel_parens_and_refs()
|
||||
&& let ExprKind::Lit(lit) = arg.kind
|
||||
&& let Some(literal) = self.try_inline_lit(lit)
|
||||
{
|
||||
literal = self.try_inline_lit(lit);
|
||||
}
|
||||
|
||||
if let Some(literal) = literal {
|
||||
// Now we need to mutate the outer FormatArgs.
|
||||
// If this is the first time, this clones the outer FormatArgs.
|
||||
let fmt = fmt.to_mut();
|
||||
|
|
@ -265,136 +259,21 @@ fn make_argument<'hir>(
|
|||
ctx.expr_call_mut(sp, new_fn, std::slice::from_ref(arg))
|
||||
}
|
||||
|
||||
/// Generate a hir expression for a format_args Count.
|
||||
/// Get the value for a `width` or `precision` field.
|
||||
///
|
||||
/// Generates:
|
||||
///
|
||||
/// ```text
|
||||
/// <core::fmt::rt::Count>::Is(…)
|
||||
/// ```
|
||||
///
|
||||
/// or
|
||||
///
|
||||
/// ```text
|
||||
/// <core::fmt::rt::Count>::Param(…)
|
||||
/// ```
|
||||
///
|
||||
/// or
|
||||
///
|
||||
/// ```text
|
||||
/// <core::fmt::rt::Count>::Implied
|
||||
/// ```
|
||||
fn make_count<'hir>(
|
||||
ctx: &mut LoweringContext<'_, 'hir>,
|
||||
sp: Span,
|
||||
count: &Option<FormatCount>,
|
||||
/// Returns the value and whether it is indirect (an indexed argument) or not.
|
||||
fn make_count(
|
||||
count: &FormatCount,
|
||||
argmap: &mut FxIndexMap<(usize, ArgumentType), Option<Span>>,
|
||||
) -> hir::Expr<'hir> {
|
||||
) -> (bool, u16) {
|
||||
match count {
|
||||
Some(FormatCount::Literal(n)) => {
|
||||
let count_is = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
sp,
|
||||
hir::LangItem::FormatCount,
|
||||
sym::Is,
|
||||
));
|
||||
let value = ctx.arena.alloc_from_iter([ctx.expr_u16(sp, *n)]);
|
||||
ctx.expr_call_mut(sp, count_is, value)
|
||||
}
|
||||
Some(FormatCount::Argument(arg)) => {
|
||||
if let Ok(arg_index) = arg.index {
|
||||
let (i, _) = argmap.insert_full((arg_index, ArgumentType::Usize), arg.span);
|
||||
let count_param = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
sp,
|
||||
hir::LangItem::FormatCount,
|
||||
sym::Param,
|
||||
));
|
||||
let value = ctx.arena.alloc_from_iter([ctx.expr_usize(sp, i)]);
|
||||
ctx.expr_call_mut(sp, count_param, value)
|
||||
} else {
|
||||
ctx.expr(
|
||||
sp,
|
||||
hir::ExprKind::Err(
|
||||
ctx.dcx().span_delayed_bug(sp, "lowered bad format_args count"),
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
None => ctx.expr_lang_item_type_relative(sp, hir::LangItem::FormatCount, sym::Implied),
|
||||
}
|
||||
}
|
||||
|
||||
/// Generate a hir expression for a format_args placeholder specification.
|
||||
///
|
||||
/// Generates
|
||||
///
|
||||
/// ```text
|
||||
/// <core::fmt::rt::Placeholder {
|
||||
/// position: …usize,
|
||||
/// flags: …u32,
|
||||
/// precision: <core::fmt::rt::Count::…>,
|
||||
/// width: <core::fmt::rt::Count::…>,
|
||||
/// }
|
||||
/// ```
|
||||
fn make_format_spec<'hir>(
|
||||
ctx: &mut LoweringContext<'_, 'hir>,
|
||||
sp: Span,
|
||||
placeholder: &FormatPlaceholder,
|
||||
argmap: &mut FxIndexMap<(usize, ArgumentType), Option<Span>>,
|
||||
) -> hir::Expr<'hir> {
|
||||
let position = match placeholder.argument.index {
|
||||
Ok(arg_index) => {
|
||||
let (i, _) = argmap.insert_full(
|
||||
(arg_index, ArgumentType::Format(placeholder.format_trait)),
|
||||
placeholder.span,
|
||||
);
|
||||
ctx.expr_usize(sp, i)
|
||||
}
|
||||
Err(_) => ctx.expr(
|
||||
sp,
|
||||
hir::ExprKind::Err(ctx.dcx().span_delayed_bug(sp, "lowered bad format_args count")),
|
||||
FormatCount::Literal(n) => (false, *n),
|
||||
FormatCount::Argument(arg) => (
|
||||
true,
|
||||
argmap.insert_full((arg.index.unwrap_or(usize::MAX), ArgumentType::Usize), arg.span).0
|
||||
as u16,
|
||||
),
|
||||
};
|
||||
let &FormatOptions {
|
||||
ref width,
|
||||
ref precision,
|
||||
alignment,
|
||||
fill,
|
||||
sign,
|
||||
alternate,
|
||||
zero_pad,
|
||||
debug_hex,
|
||||
} = &placeholder.format_options;
|
||||
let fill = fill.unwrap_or(' ');
|
||||
// These need to match the constants in library/core/src/fmt/rt.rs.
|
||||
let align = match alignment {
|
||||
Some(FormatAlignment::Left) => 0,
|
||||
Some(FormatAlignment::Right) => 1,
|
||||
Some(FormatAlignment::Center) => 2,
|
||||
None => 3,
|
||||
};
|
||||
// This needs to match the constants in library/core/src/fmt/rt.rs.
|
||||
let flags: u32 = fill as u32
|
||||
| ((sign == Some(FormatSign::Plus)) as u32) << 21
|
||||
| ((sign == Some(FormatSign::Minus)) as u32) << 22
|
||||
| (alternate as u32) << 23
|
||||
| (zero_pad as u32) << 24
|
||||
| ((debug_hex == Some(FormatDebugHex::Lower)) as u32) << 25
|
||||
| ((debug_hex == Some(FormatDebugHex::Upper)) as u32) << 26
|
||||
| (width.is_some() as u32) << 27
|
||||
| (precision.is_some() as u32) << 28
|
||||
| align << 29
|
||||
| 1 << 31; // Highest bit always set.
|
||||
let flags = ctx.expr_u32(sp, flags);
|
||||
let precision = make_count(ctx, sp, precision, argmap);
|
||||
let width = make_count(ctx, sp, width, argmap);
|
||||
let position = ctx.expr_field(Ident::new(sym::position, sp), ctx.arena.alloc(position), sp);
|
||||
let flags = ctx.expr_field(Ident::new(sym::flags, sp), ctx.arena.alloc(flags), sp);
|
||||
let precision = ctx.expr_field(Ident::new(sym::precision, sp), ctx.arena.alloc(precision), sp);
|
||||
let width = ctx.expr_field(Ident::new(sym::width, sp), ctx.arena.alloc(width), sp);
|
||||
let placeholder =
|
||||
ctx.arena.alloc(ctx.make_lang_item_qpath(hir::LangItem::FormatPlaceholder, sp, None));
|
||||
let fields = ctx.arena.alloc_from_iter([position, flags, precision, width]);
|
||||
ctx.expr(sp, hir::ExprKind::Struct(placeholder, fields, hir::StructTailExpr::None))
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_format_args<'hir>(
|
||||
|
|
@ -405,85 +284,152 @@ fn expand_format_args<'hir>(
|
|||
) -> hir::ExprKind<'hir> {
|
||||
let macsp = ctx.lower_span(macsp);
|
||||
|
||||
let mut incomplete_lit = String::new();
|
||||
let lit_pieces =
|
||||
ctx.arena.alloc_from_iter(fmt.template.iter().enumerate().filter_map(|(i, piece)| {
|
||||
match piece {
|
||||
&FormatArgsPiece::Literal(s) => {
|
||||
// Coalesce adjacent literal pieces.
|
||||
if let Some(FormatArgsPiece::Literal(_)) = fmt.template.get(i + 1) {
|
||||
incomplete_lit.push_str(s.as_str());
|
||||
None
|
||||
} else if !incomplete_lit.is_empty() {
|
||||
incomplete_lit.push_str(s.as_str());
|
||||
let s = Symbol::intern(&incomplete_lit);
|
||||
incomplete_lit.clear();
|
||||
Some(ctx.expr_str(fmt.span, s))
|
||||
} else {
|
||||
Some(ctx.expr_str(fmt.span, s))
|
||||
}
|
||||
}
|
||||
&FormatArgsPiece::Placeholder(_) => {
|
||||
// Inject empty string before placeholders when not already preceded by a literal piece.
|
||||
if i == 0 || matches!(fmt.template[i - 1], FormatArgsPiece::Placeholder(_)) {
|
||||
Some(ctx.expr_str(fmt.span, sym::empty))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}));
|
||||
let lit_pieces = ctx.expr_array_ref(fmt.span, lit_pieces);
|
||||
|
||||
// Whether we'll use the `Arguments::new_v1_formatted` form (true),
|
||||
// or the `Arguments::new_v1` form (false).
|
||||
let mut use_format_options = false;
|
||||
|
||||
// Create a list of all _unique_ (argument, format trait) combinations.
|
||||
// E.g. "{0} {0:x} {0} {1}" -> [(0, Display), (0, LowerHex), (1, Display)]
|
||||
//
|
||||
// We use usize::MAX for arguments that don't exist, because that can never be a valid index
|
||||
// into the arguments array.
|
||||
let mut argmap = FxIndexMap::default();
|
||||
for piece in &fmt.template {
|
||||
let FormatArgsPiece::Placeholder(placeholder) = piece else { continue };
|
||||
if placeholder.format_options != Default::default() {
|
||||
// Can't use basic form if there's any formatting options.
|
||||
use_format_options = true;
|
||||
}
|
||||
if let Ok(index) = placeholder.argument.index {
|
||||
if argmap
|
||||
.insert((index, ArgumentType::Format(placeholder.format_trait)), placeholder.span)
|
||||
.is_some()
|
||||
{
|
||||
// Duplicate (argument, format trait) combination,
|
||||
// which we'll only put once in the args array.
|
||||
use_format_options = true;
|
||||
|
||||
let mut incomplete_lit = String::new();
|
||||
|
||||
let mut implicit_arg_index = 0;
|
||||
|
||||
let mut bytecode = Vec::new();
|
||||
|
||||
let template = if fmt.template.is_empty() {
|
||||
// Treat empty templates as a single literal piece (with an empty string),
|
||||
// so we produce `from_str("")` for those.
|
||||
&[FormatArgsPiece::Literal(sym::empty)][..]
|
||||
} else {
|
||||
&fmt.template[..]
|
||||
};
|
||||
|
||||
// See library/core/src/fmt/mod.rs for the format string encoding format.
|
||||
|
||||
for (i, piece) in template.iter().enumerate() {
|
||||
match piece {
|
||||
&FormatArgsPiece::Literal(sym) => {
|
||||
// Coalesce adjacent literal pieces.
|
||||
if let Some(FormatArgsPiece::Literal(_)) = template.get(i + 1) {
|
||||
incomplete_lit.push_str(sym.as_str());
|
||||
continue;
|
||||
}
|
||||
let mut s = if incomplete_lit.is_empty() {
|
||||
sym.as_str()
|
||||
} else {
|
||||
incomplete_lit.push_str(sym.as_str());
|
||||
&incomplete_lit
|
||||
};
|
||||
|
||||
// If this is the last piece and was the only piece, that means
|
||||
// there are no placeholders and the entire format string is just a literal.
|
||||
//
|
||||
// In that case, we can just use `from_str`.
|
||||
if i + 1 == template.len() && bytecode.is_empty() {
|
||||
// Generate:
|
||||
// <core::fmt::Arguments>::from_str("meow")
|
||||
let from_str = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
macsp,
|
||||
hir::LangItem::FormatArguments,
|
||||
if allow_const { sym::from_str } else { sym::from_str_nonconst },
|
||||
));
|
||||
let sym = if incomplete_lit.is_empty() { sym } else { Symbol::intern(s) };
|
||||
let s = ctx.expr_str(fmt.span, sym);
|
||||
let args = ctx.arena.alloc_from_iter([s]);
|
||||
return hir::ExprKind::Call(from_str, args);
|
||||
}
|
||||
|
||||
// Encode the literal in chunks of up to u16::MAX bytes, split at utf-8 boundaries.
|
||||
while !s.is_empty() {
|
||||
let len = s.floor_char_boundary(usize::from(u16::MAX));
|
||||
if len < 0x80 {
|
||||
bytecode.push(len as u8);
|
||||
} else {
|
||||
bytecode.push(0x80);
|
||||
bytecode.extend_from_slice(&(len as u16).to_le_bytes());
|
||||
}
|
||||
bytecode.extend(&s.as_bytes()[..len]);
|
||||
s = &s[len..];
|
||||
}
|
||||
|
||||
incomplete_lit.clear();
|
||||
}
|
||||
FormatArgsPiece::Placeholder(p) => {
|
||||
// Push the start byte and remember its index so we can set the option bits later.
|
||||
let i = bytecode.len();
|
||||
bytecode.push(0xC0);
|
||||
|
||||
let position = argmap
|
||||
.insert_full(
|
||||
(
|
||||
p.argument.index.unwrap_or(usize::MAX),
|
||||
ArgumentType::Format(p.format_trait),
|
||||
),
|
||||
p.span,
|
||||
)
|
||||
.0 as u64;
|
||||
|
||||
// This needs to match the constants in library/core/src/fmt/mod.rs.
|
||||
let o = &p.format_options;
|
||||
let align = match o.alignment {
|
||||
Some(FormatAlignment::Left) => 0,
|
||||
Some(FormatAlignment::Right) => 1,
|
||||
Some(FormatAlignment::Center) => 2,
|
||||
None => 3,
|
||||
};
|
||||
let default_flags = 0x6000_0020;
|
||||
let flags: u32 = o.fill.unwrap_or(' ') as u32
|
||||
| ((o.sign == Some(FormatSign::Plus)) as u32) << 21
|
||||
| ((o.sign == Some(FormatSign::Minus)) as u32) << 22
|
||||
| (o.alternate as u32) << 23
|
||||
| (o.zero_pad as u32) << 24
|
||||
| ((o.debug_hex == Some(FormatDebugHex::Lower)) as u32) << 25
|
||||
| ((o.debug_hex == Some(FormatDebugHex::Upper)) as u32) << 26
|
||||
| (o.width.is_some() as u32) << 27
|
||||
| (o.precision.is_some() as u32) << 28
|
||||
| align << 29;
|
||||
if flags != default_flags {
|
||||
bytecode[i] |= 1;
|
||||
bytecode.extend_from_slice(&flags.to_le_bytes());
|
||||
if let Some(val) = &o.width {
|
||||
let (indirect, val) = make_count(val, &mut argmap);
|
||||
// Only encode if nonzero; zero is the default.
|
||||
if indirect || val != 0 {
|
||||
bytecode[i] |= 1 << 1 | (indirect as u8) << 4;
|
||||
bytecode.extend_from_slice(&val.to_le_bytes());
|
||||
}
|
||||
}
|
||||
if let Some(val) = &o.precision {
|
||||
let (indirect, val) = make_count(val, &mut argmap);
|
||||
// Only encode if nonzero; zero is the default.
|
||||
if indirect || val != 0 {
|
||||
bytecode[i] |= 1 << 2 | (indirect as u8) << 5;
|
||||
bytecode.extend_from_slice(&val.to_le_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
if implicit_arg_index != position {
|
||||
bytecode[i] |= 1 << 3;
|
||||
bytecode.extend_from_slice(&(position as u16).to_le_bytes());
|
||||
}
|
||||
implicit_arg_index = position + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let format_options = use_format_options.then(|| {
|
||||
// Generate:
|
||||
// &[format_spec_0, format_spec_1, format_spec_2]
|
||||
let elements = ctx.arena.alloc_from_iter(fmt.template.iter().filter_map(|piece| {
|
||||
let FormatArgsPiece::Placeholder(placeholder) = piece else { return None };
|
||||
Some(make_format_spec(ctx, macsp, placeholder, &mut argmap))
|
||||
}));
|
||||
ctx.expr_array_ref(macsp, elements)
|
||||
});
|
||||
assert!(incomplete_lit.is_empty());
|
||||
|
||||
// Zero terminator.
|
||||
bytecode.push(0);
|
||||
|
||||
// Ensure all argument indexes actually fit in 16 bits, as we truncated them to 16 bits before.
|
||||
if argmap.len() > u16::MAX as usize {
|
||||
ctx.dcx().span_err(macsp, "too many format arguments");
|
||||
}
|
||||
|
||||
let arguments = fmt.arguments.all_args();
|
||||
|
||||
if allow_const && arguments.is_empty() && argmap.is_empty() {
|
||||
// Generate:
|
||||
// <core::fmt::Arguments>::new_const(lit_pieces)
|
||||
let new = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
macsp,
|
||||
hir::LangItem::FormatArguments,
|
||||
sym::new_const,
|
||||
));
|
||||
let new_args = ctx.arena.alloc_from_iter([lit_pieces]);
|
||||
return hir::ExprKind::Call(new, new_args);
|
||||
}
|
||||
|
||||
let (let_statements, args) = if arguments.is_empty() {
|
||||
// Generate:
|
||||
// []
|
||||
|
|
@ -512,22 +458,30 @@ fn expand_format_args<'hir>(
|
|||
// ];
|
||||
let args = ctx.arena.alloc_from_iter(argmap.iter().map(
|
||||
|(&(arg_index, ty), &placeholder_span)| {
|
||||
let arg = &arguments[arg_index];
|
||||
let placeholder_span =
|
||||
placeholder_span.unwrap_or(arg.expr.span).with_ctxt(macsp.ctxt());
|
||||
let arg_span = match arg.kind {
|
||||
FormatArgumentKind::Captured(_) => placeholder_span,
|
||||
_ => arg.expr.span.with_ctxt(macsp.ctxt()),
|
||||
};
|
||||
let args_ident_expr = ctx.expr_ident(macsp, args_ident, args_hir_id);
|
||||
let arg = ctx.arena.alloc(ctx.expr(
|
||||
arg_span,
|
||||
hir::ExprKind::Field(
|
||||
args_ident_expr,
|
||||
Ident::new(sym::integer(arg_index), macsp),
|
||||
),
|
||||
));
|
||||
make_argument(ctx, placeholder_span, arg, ty)
|
||||
if let Some(arg) = arguments.get(arg_index) {
|
||||
let placeholder_span =
|
||||
placeholder_span.unwrap_or(arg.expr.span).with_ctxt(macsp.ctxt());
|
||||
let arg_span = match arg.kind {
|
||||
FormatArgumentKind::Captured(_) => placeholder_span,
|
||||
_ => arg.expr.span.with_ctxt(macsp.ctxt()),
|
||||
};
|
||||
let args_ident_expr = ctx.expr_ident(macsp, args_ident, args_hir_id);
|
||||
let arg = ctx.arena.alloc(ctx.expr(
|
||||
arg_span,
|
||||
hir::ExprKind::Field(
|
||||
args_ident_expr,
|
||||
Ident::new(sym::integer(arg_index), macsp),
|
||||
),
|
||||
));
|
||||
make_argument(ctx, placeholder_span, arg, ty)
|
||||
} else {
|
||||
ctx.expr(
|
||||
macsp,
|
||||
hir::ExprKind::Err(
|
||||
ctx.dcx().span_delayed_bug(macsp, "missing format_args argument"),
|
||||
),
|
||||
)
|
||||
}
|
||||
},
|
||||
));
|
||||
let args = ctx.arena.alloc(ctx.expr(macsp, hir::ExprKind::Array(args)));
|
||||
|
|
@ -540,58 +494,38 @@ fn expand_format_args<'hir>(
|
|||
};
|
||||
|
||||
// Generate:
|
||||
// &args
|
||||
let args = ctx.expr_ref(macsp, args);
|
||||
|
||||
let call = if let Some(format_options) = format_options {
|
||||
// Generate:
|
||||
// unsafe {
|
||||
// <core::fmt::Arguments>::new_v1_formatted(
|
||||
// lit_pieces,
|
||||
// args,
|
||||
// format_options,
|
||||
// )
|
||||
// }
|
||||
let new_v1_formatted = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
// unsafe {
|
||||
// <core::fmt::Arguments>::new(b"…", &args)
|
||||
// }
|
||||
let template = ctx.expr_byte_str(macsp, ByteSymbol::intern(&bytecode));
|
||||
let call = {
|
||||
let new = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
macsp,
|
||||
hir::LangItem::FormatArguments,
|
||||
sym::new_v1_formatted,
|
||||
sym::new,
|
||||
));
|
||||
let args = ctx.arena.alloc_from_iter([lit_pieces, args, format_options]);
|
||||
let call = ctx.expr_call(macsp, new_v1_formatted, args);
|
||||
let hir_id = ctx.next_id();
|
||||
hir::ExprKind::Block(
|
||||
ctx.arena.alloc(hir::Block {
|
||||
stmts: &[],
|
||||
expr: Some(call),
|
||||
hir_id,
|
||||
rules: hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::CompilerGenerated),
|
||||
span: macsp,
|
||||
targeted_by_break: false,
|
||||
}),
|
||||
None,
|
||||
)
|
||||
} else {
|
||||
// Generate:
|
||||
// <core::fmt::Arguments>::new_v1(
|
||||
// lit_pieces,
|
||||
// args,
|
||||
// )
|
||||
let new_v1 = ctx.arena.alloc(ctx.expr_lang_item_type_relative(
|
||||
macsp,
|
||||
hir::LangItem::FormatArguments,
|
||||
sym::new_v1,
|
||||
));
|
||||
let new_args = ctx.arena.alloc_from_iter([lit_pieces, args]);
|
||||
hir::ExprKind::Call(new_v1, new_args)
|
||||
let args = ctx.expr_ref(macsp, args);
|
||||
let new_args = ctx.arena.alloc_from_iter([template, args]);
|
||||
ctx.expr_call(macsp, new, new_args)
|
||||
};
|
||||
let call = hir::ExprKind::Block(
|
||||
ctx.arena.alloc(hir::Block {
|
||||
stmts: &[],
|
||||
expr: Some(call),
|
||||
hir_id: ctx.next_id(),
|
||||
rules: hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::CompilerGenerated),
|
||||
span: macsp,
|
||||
targeted_by_break: false,
|
||||
}),
|
||||
None,
|
||||
);
|
||||
|
||||
if !let_statements.is_empty() {
|
||||
// Generate:
|
||||
// {
|
||||
// super let …
|
||||
// super let …
|
||||
// <core::fmt::Arguments>::new_…(…)
|
||||
// <core::fmt::Arguments>::new(…)
|
||||
// }
|
||||
let call = ctx.arena.alloc(ctx.expr(macsp, call));
|
||||
let block = ctx.block_all(macsp, ctx.arena.alloc_from_iter(let_statements), Some(call));
|
||||
|
|
|
|||
|
|
@ -329,9 +329,6 @@ language_item_table! {
|
|||
// Lang items needed for `format_args!()`.
|
||||
FormatArgument, sym::format_argument, format_argument, Target::Struct, GenericRequirement::None;
|
||||
FormatArguments, sym::format_arguments, format_arguments, Target::Struct, GenericRequirement::None;
|
||||
FormatCount, sym::format_count, format_count, Target::Enum, GenericRequirement::None;
|
||||
FormatPlaceholder, sym::format_placeholder, format_placeholder, Target::Struct, GenericRequirement::None;
|
||||
FormatUnsafeArg, sym::format_unsafe_arg, format_unsafe_arg, Target::Struct, GenericRequirement::None;
|
||||
|
||||
ExchangeMalloc, sym::exchange_malloc, exchange_malloc_fn, Target::Fn, GenericRequirement::None;
|
||||
DropInPlace, sym::drop_in_place, drop_in_place_fn, Target::Fn, GenericRequirement::Minimum(1);
|
||||
|
|
|
|||
|
|
@ -1096,10 +1096,7 @@ symbols! {
|
|||
format_args_nl,
|
||||
format_argument,
|
||||
format_arguments,
|
||||
format_count,
|
||||
format_macro,
|
||||
format_placeholder,
|
||||
format_unsafe_arg,
|
||||
framework,
|
||||
freeze,
|
||||
freeze_impls,
|
||||
|
|
@ -1114,7 +1111,9 @@ symbols! {
|
|||
from_output,
|
||||
from_residual,
|
||||
from_size_align_unchecked,
|
||||
from_str,
|
||||
from_str_method,
|
||||
from_str_nonconst,
|
||||
from_u16,
|
||||
from_usize,
|
||||
from_yeet,
|
||||
|
|
|
|||
|
|
@ -4,10 +4,12 @@
|
|||
|
||||
use crate::cell::{Cell, Ref, RefCell, RefMut, SyncUnsafeCell, UnsafeCell};
|
||||
use crate::char::{EscapeDebugExtArgs, MAX_LEN_UTF8};
|
||||
use crate::hint::assert_unchecked;
|
||||
use crate::marker::{PhantomData, PointeeSized};
|
||||
use crate::num::fmt as numfmt;
|
||||
use crate::ops::Deref;
|
||||
use crate::{iter, result, str};
|
||||
use crate::ptr::NonNull;
|
||||
use crate::{iter, mem, result, str};
|
||||
|
||||
mod builders;
|
||||
#[cfg(not(no_fp_fmt_parse))]
|
||||
|
|
@ -288,7 +290,7 @@ pub struct FormattingOptions {
|
|||
/// ```text
|
||||
/// 31 30 29 28 27 26 25 24 23 22 21 20 0
|
||||
/// ┌───┬───────┬───┬───┬───┬───┬───┬───┬───┬───┬──────────────────────────────────┐
|
||||
/// │ 1 │ align │ p │ w │ X?│ x?│'0'│ # │ - │ + │ fill │
|
||||
/// │ 0 │ align │ p │ w │ X?│ x?│'0'│ # │ - │ + │ fill │
|
||||
/// └───┴───────┴───┴───┴───┴───┴───┴───┴───┴───┴──────────────────────────────────┘
|
||||
/// │ │ │ │ └─┬───────────────────┘ └─┬──────────────────────────────┘
|
||||
/// │ │ │ │ │ └─ The fill character (21 bits char).
|
||||
|
|
@ -299,12 +301,9 @@ pub struct FormattingOptions {
|
|||
/// │ ├─ 1: Align right. (>)
|
||||
/// │ ├─ 2: Align center. (^)
|
||||
/// │ └─ 3: Alignment not set. (default)
|
||||
/// └─ Always set.
|
||||
/// This makes it possible to distinguish formatting flags from
|
||||
/// a &str size when stored in (the upper bits of) the same field.
|
||||
/// (fmt::Arguments will make use of this property in the future.)
|
||||
/// └─ Always zero.
|
||||
/// ```
|
||||
// Note: This could use a special niche type with range 0x8000_0000..=0xfdd0ffff.
|
||||
// Note: This could use a pattern type with range 0x0000_0000..=0x7dd0ffff.
|
||||
// It's unclear if that's useful, though.
|
||||
flags: u32,
|
||||
/// Width if width flag (bit 27) above is set. Otherwise, always 0.
|
||||
|
|
@ -328,7 +327,6 @@ mod flags {
|
|||
pub(super) const ALIGN_RIGHT: u32 = 1 << 29;
|
||||
pub(super) const ALIGN_CENTER: u32 = 2 << 29;
|
||||
pub(super) const ALIGN_UNKNOWN: u32 = 3 << 29;
|
||||
pub(super) const ALWAYS_SET: u32 = 1 << 31;
|
||||
}
|
||||
|
||||
impl FormattingOptions {
|
||||
|
|
@ -344,11 +342,7 @@ impl FormattingOptions {
|
|||
/// - no [`DebugAsHex`] output mode.
|
||||
#[unstable(feature = "formatting_options", issue = "118117")]
|
||||
pub const fn new() -> Self {
|
||||
Self {
|
||||
flags: ' ' as u32 | flags::ALIGN_UNKNOWN | flags::ALWAYS_SET,
|
||||
width: 0,
|
||||
precision: 0,
|
||||
}
|
||||
Self { flags: ' ' as u32 | flags::ALIGN_UNKNOWN, width: 0, precision: 0 }
|
||||
}
|
||||
|
||||
/// Sets or removes the sign (the `+` or the `-` flag).
|
||||
|
|
@ -612,19 +606,152 @@ impl<'a> Formatter<'a> {
|
|||
/// ```
|
||||
///
|
||||
/// [`format()`]: ../../std/fmt/fn.format.html
|
||||
//
|
||||
// Internal representation:
|
||||
//
|
||||
// fmt::Arguments is represented in one of two ways:
|
||||
//
|
||||
// 1) String literal representation (e.g. format_args!("hello"))
|
||||
// ┌────────────────────────────────┐
|
||||
// template: │ *const u8 │ ─▷ "hello"
|
||||
// ├──────────────────────────────┬─┤
|
||||
// args: │ len │1│ (lowest bit is 1; field contains `len << 1 | 1`)
|
||||
// └──────────────────────────────┴─┘
|
||||
// In this representation, there are no placeholders and `fmt::Arguments::as_str()` returns Some.
|
||||
// The pointer points to the start of a static `str`. The length is given by `args as usize >> 1`.
|
||||
// (The length of a `&str` is isize::MAX at most, so it always fits in a usize minus one bit.)
|
||||
//
|
||||
// `fmt::Arguments::from_str()` constructs this representation from a `&'static str`.
|
||||
//
|
||||
// 2) Placeholders representation (e.g. format_args!("hello {name}\n"))
|
||||
// ┌────────────────────────────────┐
|
||||
// template: │ *const u8 │ ─▷ b"\x06hello \x80\x01\n\x00"
|
||||
// ├────────────────────────────────┤
|
||||
// args: │ &'a [Argument<'a>; _] 0│ (lower bit is 0 due to alignment of Argument type)
|
||||
// └────────────────────────────────┘
|
||||
// In this representation, the template is a byte sequence encoding both the literal string pieces
|
||||
// and the placeholders (including their options/flags).
|
||||
//
|
||||
// The `args` pointer points to an array of `fmt::Argument<'a>` values, of sufficient length to
|
||||
// match the placeholders in the template.
|
||||
//
|
||||
// `fmt::Arguments::new()` constructs this representation from a template byte slice and a slice
|
||||
// of arguments. This function is unsafe, as the template is assumed to be valid and the args
|
||||
// slice is assumed to have elements matching the template.
|
||||
//
|
||||
// The template byte sequence is the concatenation of parts of the following types:
|
||||
//
|
||||
// - Literal string piece:
|
||||
// Pieces that must be formatted verbatim (e.g. "hello " and "\n" in "hello {name}\n")
|
||||
// appear literally in the template byte sequence, prefixed by their length.
|
||||
//
|
||||
// For pieces of up to 127 bytes, these are represented as a single byte containing the
|
||||
// length followed directly by the bytes of the string:
|
||||
// ┌───┬────────────────────────────┐
|
||||
// │len│ `len` bytes (utf-8) │ (e.g. b"\x06hello ")
|
||||
// └───┴────────────────────────────┘
|
||||
//
|
||||
// For larger pieces up to u16::MAX bytes, these are represented as a 0x80 followed by
|
||||
// their length in 16-bit little endian, followed by the bytes of the string:
|
||||
// ┌────┬─────────┬───────────────────────────┐
|
||||
// │0x80│ len │ `len` bytes (utf-8) │ (e.g. b"\x80\x00\x01hello … ")
|
||||
// └────┴─────────┴───────────────────────────┘
|
||||
//
|
||||
// Longer pieces are split into multiple pieces of max u16::MAX bytes (at utf-8 boundaries).
|
||||
//
|
||||
// - Placeholder:
|
||||
// Placeholders (e.g. `{name}` in "hello {name}") are represented as a byte with the highest
|
||||
// two bits set, followed by zero or more fields depending on the flags in the first byte:
|
||||
// ┌──────────┬┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┬┄┄┄┄┄┄┄┄┄┄┄┬┄┄┄┄┄┄┄┄┄┄┄┬┄┄┄┄┄┄┄┄┄┄┄┐
|
||||
// │0b11______│ flags ┊ width ┊ precision ┊ arg_index ┊ (e.g. b"\xC2\x05\0")
|
||||
// └────││││││┴┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┴┄┄┄┄┄┄┄┄┄┄┄┴┄┄┄┄┄┄┄┄┄┄┄┴┄┄┄┄┄┄┄┄┄┄┄┘
|
||||
// ││││││ 32 bit 16 bit 16 bit 16 bit
|
||||
// │││││└─ flags present
|
||||
// ││││└─ width present
|
||||
// │││└─ precision present
|
||||
// ││└─ arg_index present
|
||||
// │└─ width indirect
|
||||
// └─ precision indirect
|
||||
//
|
||||
// All fields other than the first byte are optional and only present when their
|
||||
// corresponding flag is set in the first byte.
|
||||
//
|
||||
// So, a fully default placeholder without any options is just a single byte:
|
||||
// ┌──────────┐
|
||||
// │0b11000000│ (b"\xC0")
|
||||
// └──────────┘
|
||||
//
|
||||
// The fields are stored as little endian.
|
||||
//
|
||||
// The `flags` fields corresponds to the `flags` field of `FormattingOptions`.
|
||||
// See doc comment of `FormattingOptions::flags` for details.
|
||||
//
|
||||
// The `width` and `precision` fields correspond to their respective fields in
|
||||
// `FormattingOptions`. However, if their "indirect" flag is set, the field contains the
|
||||
// index in the `args` array where the dynamic width or precision is stored, rather than the
|
||||
// value directly.
|
||||
//
|
||||
// The `arg_index` field is the index into the `args` array for the argument to be
|
||||
// formatted.
|
||||
//
|
||||
// If omitted, the flags, width and precision of the default FormattingOptions::new() are
|
||||
// used.
|
||||
//
|
||||
// If the `arg_index` is omitted, the next argument in the `args` array is used (starting
|
||||
// at 0).
|
||||
//
|
||||
// - End:
|
||||
// A single zero byte marks the end of the template:
|
||||
// ┌───┐
|
||||
// │ 0 │ ("\0")
|
||||
// └───┘
|
||||
//
|
||||
// (Note that a zero byte may also occur naturally as part of the string pieces or flags,
|
||||
// width, precision and arg_index fields above. That is, the template byte sequence ends
|
||||
// with a 0 byte, but isn't terminated by the first 0 byte.)
|
||||
//
|
||||
#[lang = "format_arguments"]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Arguments<'a> {
|
||||
// Format string pieces to print.
|
||||
pieces: &'a [&'static str],
|
||||
template: NonNull<u8>,
|
||||
args: NonNull<rt::Argument<'a>>,
|
||||
}
|
||||
|
||||
// Placeholder specs, or `None` if all specs are default (as in "{}{}").
|
||||
fmt: Option<&'a [rt::Placeholder]>,
|
||||
/// Used by the format_args!() macro to create a fmt::Arguments object.
|
||||
#[doc(hidden)]
|
||||
#[rustc_diagnostic_item = "FmtArgumentsNew"]
|
||||
#[unstable(feature = "fmt_internals", issue = "none")]
|
||||
impl<'a> Arguments<'a> {
|
||||
// SAFETY: The caller must ensure that the provided template and args encode a valid
|
||||
// fmt::Arguments, as documented above.
|
||||
#[inline]
|
||||
pub unsafe fn new<const N: usize, const M: usize>(
|
||||
template: &'a [u8; N],
|
||||
args: &'a [rt::Argument<'a>; M],
|
||||
) -> Arguments<'a> {
|
||||
// SAFETY: Responsibility of the caller.
|
||||
unsafe { Arguments { template: mem::transmute(template), args: mem::transmute(args) } }
|
||||
}
|
||||
|
||||
// Dynamic arguments for interpolation, to be interleaved with string
|
||||
// pieces. (Every argument is preceded by a string piece.)
|
||||
args: &'a [rt::Argument<'a>],
|
||||
#[inline]
|
||||
pub const fn from_str(s: &'static str) -> Arguments<'a> {
|
||||
// SAFETY: This is the "static str" representation of fmt::Arguments; see above.
|
||||
unsafe {
|
||||
Arguments {
|
||||
template: mem::transmute(s.as_ptr()),
|
||||
args: mem::transmute(s.len() << 1 | 1),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Same as `from_str`, but not const.
|
||||
// Used by format_args!() expansion when arguments are inlined,
|
||||
// e.g. format_args!("{}", 123), which is not allowed in const.
|
||||
#[inline]
|
||||
pub fn from_str_nonconst(s: &'static str) -> Arguments<'a> {
|
||||
Arguments::from_str(s)
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
|
|
@ -636,20 +763,56 @@ impl<'a> Arguments<'a> {
|
|||
/// when using `format!`. Note: this is neither the lower nor upper bound.
|
||||
#[inline]
|
||||
pub fn estimated_capacity(&self) -> usize {
|
||||
let pieces_length: usize = self.pieces.iter().map(|x| x.len()).sum();
|
||||
if let Some(s) = self.as_str() {
|
||||
return s.len();
|
||||
}
|
||||
// Iterate over the template, counting the length of literal pieces.
|
||||
let mut length = 0usize;
|
||||
let mut starts_with_placeholder = false;
|
||||
let mut template = self.template;
|
||||
loop {
|
||||
// SAFETY: We can assume the template is valid.
|
||||
unsafe {
|
||||
let n = template.read();
|
||||
template = template.add(1);
|
||||
if n == 0 {
|
||||
// End of template.
|
||||
break;
|
||||
} else if n < 128 {
|
||||
// Short literal string piece.
|
||||
length += n as usize;
|
||||
template = template.add(n as usize);
|
||||
} else if n == 128 {
|
||||
// Long literal string piece.
|
||||
let len = usize::from(u16::from_le_bytes(template.cast_array().read()));
|
||||
length += len;
|
||||
template = template.add(2 + len);
|
||||
} else {
|
||||
assert_unchecked(n >= 0xC0);
|
||||
// Placeholder piece.
|
||||
if length == 0 {
|
||||
starts_with_placeholder = true;
|
||||
}
|
||||
// Skip remainder of placeholder:
|
||||
let skip = (n & 1 != 0) as usize * 4 // flags (32 bit)
|
||||
+ (n & 2 != 0) as usize * 2 // width (16 bit)
|
||||
+ (n & 4 != 0) as usize * 2 // precision (16 bit)
|
||||
+ (n & 8 != 0) as usize * 2; // arg_index (16 bit)
|
||||
template = template.add(skip as usize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if self.args.is_empty() {
|
||||
pieces_length
|
||||
} else if !self.pieces.is_empty() && self.pieces[0].is_empty() && pieces_length < 16 {
|
||||
// If the format string starts with an argument,
|
||||
if starts_with_placeholder && length < 16 {
|
||||
// If the format string starts with a placeholder,
|
||||
// don't preallocate anything, unless length
|
||||
// of pieces is significant.
|
||||
// of literal pieces is significant.
|
||||
0
|
||||
} else {
|
||||
// There are some arguments, so any additional push
|
||||
// There are some placeholders, so any additional push
|
||||
// will reallocate the string. To avoid that,
|
||||
// we're "pre-doubling" the capacity here.
|
||||
pieces_length.checked_mul(2).unwrap_or(0)
|
||||
length.wrapping_mul(2)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -702,10 +865,22 @@ impl<'a> Arguments<'a> {
|
|||
#[must_use]
|
||||
#[inline]
|
||||
pub const fn as_str(&self) -> Option<&'static str> {
|
||||
match (self.pieces, self.args) {
|
||||
([], []) => Some(""),
|
||||
([s], []) => Some(s),
|
||||
_ => None,
|
||||
// SAFETY: During const eval, `self.args` must have come from a usize,
|
||||
// not a pointer, because that's the only way to create a fmt::Arguments in const.
|
||||
// (I.e. only fmt::Arguments::from_str is const, fmt::Arguments::new is not.)
|
||||
//
|
||||
// Outside const eval, transmuting a pointer to a usize is fine.
|
||||
let bits: usize = unsafe { mem::transmute(self.args) };
|
||||
if bits & 1 == 1 {
|
||||
// SAFETY: This fmt::Arguments stores a &'static str. See encoding documentation above.
|
||||
Some(unsafe {
|
||||
str::from_utf8_unchecked(crate::slice::from_raw_parts(
|
||||
self.template.as_ptr(),
|
||||
bits >> 1,
|
||||
))
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1448,86 +1623,113 @@ pub trait UpperExp: PointeeSized {
|
|||
///
|
||||
/// [`write!`]: crate::write!
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result {
|
||||
let mut formatter = Formatter::new(output, FormattingOptions::new());
|
||||
let mut idx = 0;
|
||||
pub fn write(output: &mut dyn Write, fmt: Arguments<'_>) -> Result {
|
||||
if let Some(s) = fmt.as_str() {
|
||||
return output.write_str(s);
|
||||
}
|
||||
|
||||
match args.fmt {
|
||||
None => {
|
||||
// We can use default formatting parameters for all arguments.
|
||||
for (i, arg) in args.args.iter().enumerate() {
|
||||
// SAFETY: args.args and args.pieces come from the same Arguments,
|
||||
// which guarantees the indexes are always within bounds.
|
||||
let piece = unsafe { args.pieces.get_unchecked(i) };
|
||||
if !piece.is_empty() {
|
||||
formatter.buf.write_str(*piece)?;
|
||||
let mut template = fmt.template;
|
||||
let args = fmt.args;
|
||||
|
||||
let mut arg_index = 0;
|
||||
|
||||
// See comment on `fmt::Arguments` for the details of how the template is encoded.
|
||||
|
||||
// This must match the encoding from `expand_format_args` in
|
||||
// compiler/rustc_ast_lowering/src/format.rs.
|
||||
loop {
|
||||
// SAFETY: We can assume the template is valid.
|
||||
let n = unsafe {
|
||||
let n = template.read();
|
||||
template = template.add(1);
|
||||
n
|
||||
};
|
||||
|
||||
if n == 0 {
|
||||
// End of template.
|
||||
return Ok(());
|
||||
} else if n < 0x80 {
|
||||
// Literal string piece of length `n`.
|
||||
|
||||
// SAFETY: We can assume the strings in the template are valid.
|
||||
let s = unsafe {
|
||||
let s = crate::str::from_raw_parts(template.as_ptr(), n as usize);
|
||||
template = template.add(n as usize);
|
||||
s
|
||||
};
|
||||
output.write_str(s)?;
|
||||
} else if n == 0x80 {
|
||||
// Literal string piece with a 16-bit length.
|
||||
|
||||
// SAFETY: We can assume the strings in the template are valid.
|
||||
let s = unsafe {
|
||||
let len = usize::from(u16::from_le_bytes(template.cast_array().read()));
|
||||
template = template.add(2);
|
||||
let s = crate::str::from_raw_parts(template.as_ptr(), len);
|
||||
template = template.add(len);
|
||||
s
|
||||
};
|
||||
output.write_str(s)?;
|
||||
} else if n == 0xC0 {
|
||||
// Placeholder for next argument with default options.
|
||||
//
|
||||
// Having this as a separate case improves performance for the common case.
|
||||
|
||||
// SAFETY: We can assume the template only refers to arguments that exist.
|
||||
unsafe {
|
||||
args.add(arg_index)
|
||||
.as_ref()
|
||||
.fmt(&mut Formatter::new(output, FormattingOptions::new()))?;
|
||||
}
|
||||
arg_index += 1;
|
||||
} else {
|
||||
// SAFETY: We can assume the template is valid.
|
||||
unsafe { assert_unchecked(n > 0xC0) };
|
||||
|
||||
// Placeholder with custom options.
|
||||
|
||||
let mut opt = FormattingOptions::new();
|
||||
|
||||
// SAFETY: We can assume the template is valid.
|
||||
unsafe {
|
||||
if n & 1 != 0 {
|
||||
opt.flags = u32::from_le_bytes(template.cast_array().read());
|
||||
template = template.add(4);
|
||||
}
|
||||
|
||||
// SAFETY: There are no formatting parameters and hence no
|
||||
// count arguments.
|
||||
if n & 2 != 0 {
|
||||
opt.width = u16::from_le_bytes(template.cast_array().read());
|
||||
template = template.add(2);
|
||||
}
|
||||
if n & 4 != 0 {
|
||||
opt.precision = u16::from_le_bytes(template.cast_array().read());
|
||||
template = template.add(2);
|
||||
}
|
||||
if n & 8 != 0 {
|
||||
arg_index = usize::from(u16::from_le_bytes(template.cast_array().read()));
|
||||
template = template.add(2);
|
||||
}
|
||||
}
|
||||
if n & 16 != 0 {
|
||||
// Dynamic width from a usize argument.
|
||||
// SAFETY: We can assume the template only refers to arguments that exist.
|
||||
unsafe {
|
||||
arg.fmt(&mut formatter)?;
|
||||
opt.width = args.add(opt.width as usize).as_ref().as_u16().unwrap_unchecked();
|
||||
}
|
||||
idx += 1;
|
||||
}
|
||||
}
|
||||
Some(fmt) => {
|
||||
// Every spec has a corresponding argument that is preceded by
|
||||
// a string piece.
|
||||
for (i, arg) in fmt.iter().enumerate() {
|
||||
// SAFETY: fmt and args.pieces come from the same Arguments,
|
||||
// which guarantees the indexes are always within bounds.
|
||||
let piece = unsafe { args.pieces.get_unchecked(i) };
|
||||
if !piece.is_empty() {
|
||||
formatter.buf.write_str(*piece)?;
|
||||
if n & 32 != 0 {
|
||||
// Dynamic precision from a usize argument.
|
||||
// SAFETY: We can assume the template only refers to arguments that exist.
|
||||
unsafe {
|
||||
opt.precision =
|
||||
args.add(opt.precision as usize).as_ref().as_u16().unwrap_unchecked();
|
||||
}
|
||||
// SAFETY: arg and args.args come from the same Arguments,
|
||||
// which guarantees the indexes are always within bounds.
|
||||
unsafe { run(&mut formatter, arg, args.args) }?;
|
||||
idx += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// There can be only one trailing string piece left.
|
||||
if let Some(piece) = args.pieces.get(idx) {
|
||||
formatter.buf.write_str(*piece)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn run(fmt: &mut Formatter<'_>, arg: &rt::Placeholder, args: &[rt::Argument<'_>]) -> Result {
|
||||
let (width, precision) =
|
||||
// SAFETY: arg and args come from the same Arguments,
|
||||
// which guarantees the indexes are always within bounds.
|
||||
unsafe { (getcount(args, &arg.width), getcount(args, &arg.precision)) };
|
||||
|
||||
let options = FormattingOptions { flags: arg.flags, width, precision };
|
||||
|
||||
// Extract the correct argument
|
||||
debug_assert!(arg.position < args.len());
|
||||
// SAFETY: arg and args come from the same Arguments,
|
||||
// which guarantees its index is always within bounds.
|
||||
let value = unsafe { args.get_unchecked(arg.position) };
|
||||
|
||||
// Set all the formatting options.
|
||||
fmt.options = options;
|
||||
|
||||
// Then actually do some printing
|
||||
// SAFETY: this is a placeholder argument.
|
||||
unsafe { value.fmt(fmt) }
|
||||
}
|
||||
|
||||
unsafe fn getcount(args: &[rt::Argument<'_>], cnt: &rt::Count) -> u16 {
|
||||
match *cnt {
|
||||
rt::Count::Is(n) => n,
|
||||
rt::Count::Implied => 0,
|
||||
rt::Count::Param(i) => {
|
||||
debug_assert!(i < args.len());
|
||||
// SAFETY: cnt and args come from the same Arguments,
|
||||
// which guarantees this index is always within bounds.
|
||||
unsafe { args.get_unchecked(i).as_u16().unwrap_unchecked() }
|
||||
// SAFETY: We can assume the template only refers to arguments that exist.
|
||||
unsafe {
|
||||
args.add(arg_index).as_ref().fmt(&mut Formatter::new(output, opt))?;
|
||||
}
|
||||
arg_index += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,28 +10,6 @@ use super::*;
|
|||
use crate::hint::unreachable_unchecked;
|
||||
use crate::ptr::NonNull;
|
||||
|
||||
#[lang = "format_placeholder"]
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Placeholder {
|
||||
pub position: usize,
|
||||
pub flags: u32,
|
||||
pub precision: Count,
|
||||
pub width: Count,
|
||||
}
|
||||
|
||||
/// Used by [width](https://doc.rust-lang.org/std/fmt/#width)
|
||||
/// and [precision](https://doc.rust-lang.org/std/fmt/#precision) specifiers.
|
||||
#[lang = "format_count"]
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum Count {
|
||||
/// Specified with a literal number, stores the value
|
||||
Is(u16),
|
||||
/// Specified using `$` and `*` syntaxes, stores the index into `args`
|
||||
Param(usize),
|
||||
/// Not specified
|
||||
Implied,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
enum ArgumentType<'a> {
|
||||
Placeholder {
|
||||
|
|
@ -56,6 +34,7 @@ enum ArgumentType<'a> {
|
|||
/// precision and width.
|
||||
#[lang = "format_argument"]
|
||||
#[derive(Copy, Clone)]
|
||||
#[repr(align(2))] // To ensure pointers to this struct always have their lowest bit cleared.
|
||||
pub struct Argument<'a> {
|
||||
ty: ArgumentType<'a>,
|
||||
}
|
||||
|
|
@ -184,55 +163,3 @@ impl Argument<'_> {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Used by the format_args!() macro to create a fmt::Arguments object.
|
||||
#[doc(hidden)]
|
||||
#[unstable(feature = "fmt_internals", issue = "none")]
|
||||
#[rustc_diagnostic_item = "FmtArgumentsNew"]
|
||||
impl<'a> Arguments<'a> {
|
||||
#[inline]
|
||||
pub const fn new_const<const N: usize>(pieces: &'a [&'static str; N]) -> Self {
|
||||
const { assert!(N <= 1) };
|
||||
Arguments { pieces, fmt: None, args: &[] }
|
||||
}
|
||||
|
||||
/// When using the format_args!() macro, this function is used to generate the
|
||||
/// Arguments structure.
|
||||
///
|
||||
/// This function should _not_ be const, to make sure we don't accept
|
||||
/// format_args!() and panic!() with arguments in const, even when not evaluated:
|
||||
///
|
||||
/// ```compile_fail,E0015
|
||||
/// const _: () = if false { panic!("a {}", "a") };
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn new_v1<const P: usize, const A: usize>(
|
||||
pieces: &'a [&'static str; P],
|
||||
args: &'a [rt::Argument<'a>; A],
|
||||
) -> Arguments<'a> {
|
||||
const { assert!(P >= A && P <= A + 1, "invalid args") }
|
||||
Arguments { pieces, fmt: None, args }
|
||||
}
|
||||
|
||||
/// Specifies nonstandard formatting parameters.
|
||||
///
|
||||
/// SAFETY: the following invariants must be held:
|
||||
/// 1. The `pieces` slice must be at least as long as `fmt`.
|
||||
/// 2. Every `rt::Placeholder::position` value within `fmt` must be a valid index of `args`.
|
||||
/// 3. Every `rt::Count::Param` within `fmt` must contain a valid index of `args`.
|
||||
///
|
||||
/// This function should _not_ be const, to make sure we don't accept
|
||||
/// format_args!() and panic!() with arguments in const, even when not evaluated:
|
||||
///
|
||||
/// ```compile_fail,E0015
|
||||
/// const _: () = if false { panic!("a {:1}", "a") };
|
||||
/// ```
|
||||
#[inline]
|
||||
pub unsafe fn new_v1_formatted(
|
||||
pieces: &'a [&'static str],
|
||||
args: &'a [rt::Argument<'a>],
|
||||
fmt: &'a [rt::Placeholder],
|
||||
) -> Arguments<'a> {
|
||||
Arguments { pieces, fmt: Some(fmt), args }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -136,18 +136,18 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo
|
|||
#[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
|
||||
#[lang = "panic"] // used by lints and miri for panics
|
||||
pub const fn panic(expr: &'static str) -> ! {
|
||||
// Use Arguments::new_const instead of format_args!("{expr}") to potentially
|
||||
// Use Arguments::from_str instead of format_args!("{expr}") to potentially
|
||||
// reduce size overhead. The format_args! macro uses str's Display trait to
|
||||
// write expr, which calls Formatter::pad, which must accommodate string
|
||||
// truncation and padding (even though none is used here). Using
|
||||
// Arguments::new_const may allow the compiler to omit Formatter::pad from the
|
||||
// Arguments::from_str may allow the compiler to omit Formatter::pad from the
|
||||
// output binary, saving up to a few kilobytes.
|
||||
// However, this optimization only works for `'static` strings: `new_const` also makes this
|
||||
// However, this optimization only works for `'static` strings: `from_str` also makes this
|
||||
// message return `Some` from `Arguments::as_str`, which means it can become part of the panic
|
||||
// payload without any allocation or copying. Shorter-lived strings would become invalid as
|
||||
// stack frames get popped during unwinding, and couldn't be directly referenced from the
|
||||
// payload.
|
||||
panic_fmt(fmt::Arguments::new_const(&[expr]));
|
||||
panic_fmt(fmt::Arguments::from_str(expr));
|
||||
}
|
||||
|
||||
// We generate functions for usage by compiler-generated assertions.
|
||||
|
|
@ -171,13 +171,8 @@ macro_rules! panic_const {
|
|||
#[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
|
||||
#[lang = stringify!($lang)]
|
||||
pub const fn $lang() -> ! {
|
||||
// Use Arguments::new_const instead of format_args!("{expr}") to potentially
|
||||
// reduce size overhead. The format_args! macro uses str's Display trait to
|
||||
// write expr, which calls Formatter::pad, which must accommodate string
|
||||
// truncation and padding (even though none is used here). Using
|
||||
// Arguments::new_const may allow the compiler to omit Formatter::pad from the
|
||||
// output binary, saving up to a few kilobytes.
|
||||
panic_fmt(fmt::Arguments::new_const(&[$message]));
|
||||
// See the comment in `panic(&'static str)` for why we use `Arguments::from_str` here.
|
||||
panic_fmt(fmt::Arguments::from_str($message));
|
||||
}
|
||||
)+
|
||||
}
|
||||
|
|
@ -227,7 +222,7 @@ pub mod panic_const {
|
|||
#[rustc_nounwind]
|
||||
#[rustc_const_stable_indirect] // must follow stable const rules since it is exposed to stable
|
||||
pub const fn panic_nounwind(expr: &'static str) -> ! {
|
||||
panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), /* force_no_backtrace */ false);
|
||||
panic_nounwind_fmt(fmt::Arguments::from_str(expr), /* force_no_backtrace */ false);
|
||||
}
|
||||
|
||||
/// Like `panic_nounwind`, but also inhibits showing a backtrace.
|
||||
|
|
@ -235,7 +230,7 @@ pub const fn panic_nounwind(expr: &'static str) -> ! {
|
|||
#[cfg_attr(panic = "immediate-abort", inline)]
|
||||
#[rustc_nounwind]
|
||||
pub fn panic_nounwind_nobacktrace(expr: &'static str) -> ! {
|
||||
panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), /* force_no_backtrace */ true);
|
||||
panic_nounwind_fmt(fmt::Arguments::from_str(expr), /* force_no_backtrace */ true);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ macro_rules! assert_unsafe_precondition {
|
|||
let msg = concat!("unsafe precondition(s) violated: ", $message,
|
||||
"\n\nThis indicates a bug in the program. \
|
||||
This Undefined Behavior check is optional, and cannot be relied on for safety.");
|
||||
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::new_const(&[msg]), false);
|
||||
::core::panicking::panic_nounwind_fmt(::core::fmt::Arguments::from_str(msg), false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -166,7 +166,6 @@ generate! {
|
|||
from_ne_bytes,
|
||||
from_ptr,
|
||||
from_raw,
|
||||
from_str,
|
||||
from_str_radix,
|
||||
fs,
|
||||
fuse,
|
||||
|
|
|
|||
|
|
@ -30,19 +30,16 @@ if let StmtKind::Let(local) = stmt.kind
|
|||
&& let PatKind::Binding(BindingMode::NONE, _, name1, None) = local2.pat.kind
|
||||
&& name1.as_str() == "args"
|
||||
&& let Some(trailing_expr) = block1.expr
|
||||
&& let ExprKind::Call(func2, args2) = trailing_expr.kind
|
||||
&& paths::CORE_FMT_RT_NEW_V1.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
|
||||
&& let ExprKind::Block(block2, None) = trailing_expr.kind
|
||||
&& block2.stmts.is_empty()
|
||||
&& let Some(trailing_expr1) = block2.expr
|
||||
&& let ExprKind::Call(func2, args2) = trailing_expr1.kind
|
||||
&& paths::CORE_FMT_ARGUMENTS_NEW.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
|
||||
&& args2.len() == 2
|
||||
&& let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[0].kind
|
||||
&& let ExprKind::Array(elements2) = inner1.kind
|
||||
&& elements2.len() == 2
|
||||
&& let ExprKind::Lit(ref lit) = elements2[0].kind
|
||||
&& let LitKind::Str(s, _) = lit.node
|
||||
&& s.as_str() == ""
|
||||
&& let ExprKind::Lit(ref lit1) = elements2[1].kind
|
||||
&& let LitKind::Str(s1, _) = lit1.node
|
||||
&& s1.as_str() == "\n"
|
||||
&& let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[1].kind
|
||||
&& let ExprKind::Lit(ref lit) = args2[0].kind
|
||||
&& let LitKind::ByteStr(ref vec) = lit.node
|
||||
&& let [[192, 1, 10, 0]] = **vec
|
||||
&& let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[1].kind
|
||||
&& block.expr.is_none()
|
||||
&& let PatKind::Binding(BindingMode::NONE, _, name2, None) = local.pat.kind
|
||||
&& name2.as_str() == "print_text"
|
||||
|
|
|
|||
|
|
@ -41,19 +41,16 @@ if let Some(higher::ForLoop { pat: pat, arg: arg, body: body, .. }) = higher::Fo
|
|||
&& let PatKind::Binding(BindingMode::NONE, _, name2, None) = local1.pat.kind
|
||||
&& name2.as_str() == "args"
|
||||
&& let Some(trailing_expr) = block2.expr
|
||||
&& let ExprKind::Call(func2, args2) = trailing_expr.kind
|
||||
&& paths::CORE_FMT_RT_NEW_V1.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
|
||||
&& let ExprKind::Block(block3, None) = trailing_expr.kind
|
||||
&& block3.stmts.is_empty()
|
||||
&& let Some(trailing_expr1) = block3.expr
|
||||
&& let ExprKind::Call(func2, args2) = trailing_expr1.kind
|
||||
&& paths::CORE_FMT_ARGUMENTS_NEW.matches_path(cx, func2) // Add the path to `clippy_utils::paths` if needed
|
||||
&& args2.len() == 2
|
||||
&& let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[0].kind
|
||||
&& let ExprKind::Array(elements2) = inner1.kind
|
||||
&& elements2.len() == 2
|
||||
&& let ExprKind::Lit(ref lit2) = elements2[0].kind
|
||||
&& let LitKind::Str(s, _) = lit2.node
|
||||
&& s.as_str() == ""
|
||||
&& let ExprKind::Lit(ref lit3) = elements2[1].kind
|
||||
&& let LitKind::Str(s1, _) = lit3.node
|
||||
&& s1.as_str() == "\n"
|
||||
&& let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner2) = args2[1].kind
|
||||
&& let ExprKind::Lit(ref lit2) = args2[0].kind
|
||||
&& let LitKind::ByteStr(ref vec) = lit2.node
|
||||
&& let [[192, 1, 10, 0]] = **vec
|
||||
&& let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner1) = args2[1].kind
|
||||
&& block1.expr.is_none()
|
||||
&& block.expr.is_none()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -86,4 +86,4 @@ pub fn foo3() -> Box<dyn Iterator<Item = usize>> {
|
|||
//~ MONO_ITEM fn foo3
|
||||
//~ MONO_ITEM fn std::boxed::Box::<Counter>::new
|
||||
//~ MONO_ITEM fn Counter::new
|
||||
//~ MONO_ITEM fn core::fmt::rt::<impl std::fmt::Arguments<'_>>::new_const::<1>
|
||||
//~ MONO_ITEM fn std::fmt::Arguments::<'_>::from_str
|
||||
|
|
|
|||
|
|
@ -37,16 +37,15 @@ Number of file 0 mappings: 16
|
|||
Highest counter ID seen: c4
|
||||
|
||||
Function name: abort::might_abort
|
||||
Raw bytes (41): 0x[01, 01, 01, 01, 05, 07, 01, 03, 01, 00, 2e, 01, 01, 08, 00, 14, 05, 01, 09, 00, 11, 05, 00, 12, 00, 1f, 05, 01, 09, 00, 0f, 02, 01, 0c, 02, 06, 02, 03, 01, 00, 02]
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 03, 01, 00, 2e, 01, 01, 08, 00, 14, 05, 01, 09, 00, 11, 05, 01, 09, 00, 0f, 02, 01, 0c, 02, 06, 02, 03, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/abort.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 7
|
||||
Number of file 0 mappings: 6
|
||||
- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 46)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 20)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 31)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 15)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 12) to (start + 2, 6)
|
||||
= (c0 - c1)
|
||||
|
|
|
|||
|
|
@ -29,18 +29,14 @@ Number of file 0 mappings: 12
|
|||
Highest counter ID seen: c3
|
||||
|
||||
Function name: assert::might_fail_assert
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 04, 01, 00, 28, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 20, 01, 01, 05, 00, 0f, 02, 00, 25, 00, 3d, 05, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 04, 01, 00, 28, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 05, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/assert.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 6
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 4, 1) to (start + 0, 40)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 32)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 37) to (start + 0, 61)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(1)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@
|
|||
LL| 4|fn might_fail_assert(one_plus_one: u32) {
|
||||
LL| 4| println!("does 1 + 1 = {}?", one_plus_one);
|
||||
LL| 4| assert_eq!(1 + 1, one_plus_one, "the argument was wrong");
|
||||
^1
|
||||
LL| 3|}
|
||||
LL| |
|
||||
LL| 1|fn main() -> Result<(), u8> {
|
||||
|
|
|
|||
|
|
@ -8,14 +8,13 @@ Number of file 0 mappings: 1
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: async2::async_func::{closure#0}
|
||||
Raw bytes (49): 0x[01, 01, 00, 09, 01, 0f, 17, 00, 18, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 26, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 11, 01, 01, 08, 00, 09, 01, 00, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Raw bytes (44): 0x[01, 01, 00, 08, 01, 0f, 17, 00, 18, 01, 01, 05, 00, 0d, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 11, 01, 01, 08, 00, 09, 01, 00, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/async2.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 9
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 15, 23) to (start + 0, 24)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 9)
|
||||
|
|
@ -34,26 +33,24 @@ Number of file 0 mappings: 1
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: async2::async_func_just_println::{closure#0}
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 17, 24, 00, 25, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 33, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 17, 24, 00, 25, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/async2.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 23, 36) to (start + 0, 37)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 51)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: async2::main
|
||||
Raw bytes (49): 0x[01, 01, 00, 09, 01, 1b, 01, 00, 0a, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 23, 01, 02, 05, 00, 13, 01, 02, 05, 00, 17, 01, 00, 18, 00, 22, 01, 01, 05, 00, 17, 01, 00, 18, 00, 2f, 01, 01, 01, 00, 02]
|
||||
Raw bytes (44): 0x[01, 01, 00, 08, 01, 1b, 01, 00, 0a, 01, 01, 05, 00, 0d, 01, 02, 05, 00, 13, 01, 02, 05, 00, 17, 01, 00, 18, 00, 22, 01, 01, 05, 00, 17, 01, 00, 18, 00, 2f, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/async2.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 9
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 35)
|
||||
- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 19)
|
||||
- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 0, 24) to (start + 0, 34)
|
||||
|
|
@ -63,14 +60,13 @@ Number of file 0 mappings: 9
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: async2::non_async_func
|
||||
Raw bytes (49): 0x[01, 01, 00, 09, 01, 07, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 2a, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 11, 01, 01, 08, 00, 09, 01, 00, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Raw bytes (44): 0x[01, 01, 00, 08, 01, 07, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 01, 09, 00, 0a, 01, 00, 0d, 00, 11, 01, 01, 08, 00, 09, 01, 00, 0a, 02, 06, 00, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/async2.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 9
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 42)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 9)
|
||||
|
|
|
|||
|
|
@ -1,12 +1,11 @@
|
|||
Function name: <trait_impl_inherit::S as trait_impl_inherit::T>::f
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 11, 05, 00, 10, 01, 01, 09, 00, 11, 01, 00, 12, 00, 1a, 01, 01, 05, 00, 06]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 11, 05, 00, 10, 01, 01, 09, 00, 11, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/trait-impl-inherit.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 17, 5) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 26)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,108 +1,96 @@
|
|||
Function name: bad_counter_ids::eq_bad
|
||||
Raw bytes (29): 0x[01, 01, 00, 05, 01, 24, 01, 00, 0c, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 00, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 24, 01, 00, 0c, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 00, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 5
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 36, 1) to (start + 0, 12)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::eq_bad_message
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 29, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 01, 00, 20, 00, 2b, 00, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 29, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 00, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 41, 1) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 0, 32) to (start + 0, 43)
|
||||
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::eq_good
|
||||
Raw bytes (29): 0x[01, 01, 00, 05, 01, 10, 01, 00, 0d, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 01, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 10, 01, 00, 0d, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 5
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 16, 1) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::eq_good_message
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 15, 01, 00, 15, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 00, 00, 20, 00, 2b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 15, 01, 00, 15, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 21, 1) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 0, 32) to (start + 0, 43)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::ne_bad
|
||||
Raw bytes (29): 0x[01, 01, 00, 05, 01, 2e, 01, 00, 0c, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 00, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 2e, 01, 00, 0c, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 00, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 5
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 46, 1) to (start + 0, 12)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::ne_bad_message
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 33, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 01, 00, 20, 00, 2b, 00, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 33, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 00, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 51, 1) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 0, 32) to (start + 0, 43)
|
||||
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::ne_good
|
||||
Raw bytes (29): 0x[01, 01, 00, 05, 01, 1a, 01, 00, 0d, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 01, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 1a, 01, 00, 0d, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 5
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 26, 1) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: bad_counter_ids::ne_good_message
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 1f, 01, 00, 15, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 11, 01, 01, 05, 00, 0f, 00, 00, 20, 00, 2b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 1f, 01, 00, 15, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0f, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/bad_counter_ids.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 31, 1) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 0, 32) to (start + 0, 43)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@
|
|||
LL| 1|fn eq_good_message() {
|
||||
LL| 1| println!("b");
|
||||
LL| 1| assert_eq!(Foo(1), Foo(1), "message b");
|
||||
^0
|
||||
LL| 1|}
|
||||
LL| |
|
||||
LL| 1|fn ne_good() {
|
||||
|
|
@ -32,7 +31,6 @@
|
|||
LL| 1|fn ne_good_message() {
|
||||
LL| 1| println!("d");
|
||||
LL| 1| assert_ne!(Foo(1), Foo(3), "message d");
|
||||
^0
|
||||
LL| 1|}
|
||||
LL| |
|
||||
LL| 1|fn eq_bad() {
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
Function name: closure::main
|
||||
Raw bytes (336): 0x[01, 01, 01, 01, 05, 42, 01, 09, 01, 00, 0a, 01, 04, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 01, 09, 00, 11, 01, 00, 14, 00, 1c, 01, 02, 09, 00, 18, 01, 00, 1b, 00, 43, 01, 01, 05, 00, 0d, 01, 01, 09, 00, 20, 01, 02, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 0d, 05, 00, 10, 01, 00, 13, 00, 3b, 01, 02, 09, 00, 0a, 01, 0a, 05, 00, 0d, 01, 01, 09, 00, 20, 01, 02, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 02, 0d, 00, 0e, 01, 04, 05, 00, 10, 01, 00, 13, 00, 17, 01, 01, 05, 00, 0d, 01, 01, 09, 00, 20, 01, 02, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 0d, 05, 00, 10, 01, 00, 13, 00, 17, 01, 02, 09, 00, 0a, 01, 0a, 05, 00, 0d, 01, 01, 09, 00, 20, 01, 02, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 02, 0d, 00, 0e, 01, 05, 09, 00, 16, 01, 0a, 05, 00, 0d, 01, 01, 09, 00, 28, 01, 02, 09, 00, 1a, 01, 01, 0e, 00, 12, 01, 01, 0e, 00, 11, 01, 02, 0d, 00, 1a, 01, 02, 0e, 00, 15, 01, 04, 09, 00, 18, 01, 0c, 09, 00, 16, 01, 00, 19, 00, 1b, 01, 01, 09, 00, 1e, 01, 03, 09, 00, 29, 01, 01, 09, 00, 2d, 01, 01, 09, 00, 24, 01, 05, 09, 00, 24, 01, 02, 09, 00, 21, 01, 04, 09, 00, 21, 01, 04, 09, 00, 28, 01, 09, 09, 00, 32, 01, 04, 09, 00, 33, 01, 07, 09, 00, 4b, 01, 08, 09, 00, 48, 01, 0a, 09, 00, 47, 01, 08, 09, 00, 44, 01, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 05, 01, 09, 00, 30, 02, 03, 05, 00, 06, 01, 01, 05, 00, 28, 01, 01, 05, 00, 46, 01, 01, 05, 00, 43, 01, 01, 01, 00, 02]
|
||||
Raw bytes (311): 0x[01, 01, 01, 01, 05, 3d, 01, 09, 01, 00, 0a, 01, 04, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 01, 09, 00, 11, 01, 00, 14, 00, 1c, 01, 02, 09, 00, 18, 01, 00, 1b, 00, 43, 01, 01, 05, 00, 0d, 01, 03, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 0d, 05, 00, 10, 01, 00, 13, 00, 3b, 01, 02, 09, 00, 0a, 01, 0a, 05, 00, 0d, 01, 03, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 02, 0d, 00, 0e, 01, 04, 05, 00, 10, 01, 00, 13, 00, 17, 01, 01, 05, 00, 0d, 01, 03, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 0d, 05, 00, 10, 01, 00, 13, 00, 17, 01, 02, 09, 00, 0a, 01, 0a, 05, 00, 0d, 01, 03, 09, 00, 14, 01, 02, 0d, 00, 1b, 01, 02, 0d, 00, 0e, 01, 05, 09, 00, 16, 01, 0a, 05, 00, 0d, 01, 03, 09, 00, 1a, 01, 01, 0e, 00, 12, 01, 01, 0e, 00, 11, 01, 02, 0d, 00, 1a, 01, 02, 0e, 00, 15, 01, 04, 09, 00, 18, 01, 0c, 09, 00, 16, 01, 00, 19, 00, 1b, 01, 01, 09, 00, 1e, 01, 03, 09, 00, 29, 01, 01, 09, 00, 2d, 01, 01, 09, 00, 24, 01, 05, 09, 00, 24, 01, 02, 09, 00, 21, 01, 04, 09, 00, 21, 01, 04, 09, 00, 28, 01, 09, 09, 00, 32, 01, 04, 09, 00, 33, 01, 07, 09, 00, 4b, 01, 08, 09, 00, 48, 01, 0a, 09, 00, 47, 01, 08, 09, 00, 44, 01, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 05, 01, 09, 00, 30, 02, 03, 05, 00, 06, 01, 01, 05, 00, 28, 01, 01, 05, 00, 46, 01, 01, 05, 00, 43, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 66
|
||||
Number of file 0 mappings: 61
|
||||
- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 46)
|
||||
|
|
@ -13,35 +13,30 @@ Number of file 0 mappings: 66
|
|||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 24)
|
||||
- Code(Counter(0)) at (prev + 0, 27) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 32)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 13, 5) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 59)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 10, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 32)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 4, 5) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 32)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 13, 5) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 10, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 32)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 5, 9) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 10, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 40)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 26)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 26)
|
||||
- Code(Counter(0)) at (prev + 1, 14) to (start + 0, 18)
|
||||
- Code(Counter(0)) at (prev + 1, 14) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 26)
|
||||
|
|
@ -94,74 +89,68 @@ Number of file 0 mappings: 9
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure::main::{closure#10} (unused)
|
||||
Raw bytes (25): 0x[01, 01, 00, 04, 00, 9b, 01, 07, 00, 08, 00, 00, 09, 00, 11, 00, 00, 12, 00, 1e, 00, 00, 20, 00, 21]
|
||||
Raw bytes (20): 0x[01, 01, 00, 03, 00, 9b, 01, 07, 00, 08, 00, 00, 09, 00, 11, 00, 00, 20, 00, 21]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 155, 7) to (start + 0, 8)
|
||||
- Code(Zero) at (prev + 0, 9) to (start + 0, 17)
|
||||
- Code(Zero) at (prev + 0, 18) to (start + 0, 30)
|
||||
- Code(Zero) at (prev + 0, 32) to (start + 0, 33)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#11} (unused)
|
||||
Raw bytes (25): 0x[01, 01, 00, 04, 00, 9f, 01, 07, 00, 08, 00, 00, 09, 00, 11, 00, 00, 12, 00, 1e, 00, 00, 20, 00, 21]
|
||||
Raw bytes (20): 0x[01, 01, 00, 03, 00, 9f, 01, 07, 00, 08, 00, 00, 09, 00, 11, 00, 00, 20, 00, 21]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 159, 7) to (start + 0, 8)
|
||||
- Code(Zero) at (prev + 0, 9) to (start + 0, 17)
|
||||
- Code(Zero) at (prev + 0, 18) to (start + 0, 30)
|
||||
- Code(Zero) at (prev + 0, 32) to (start + 0, 33)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#12} (unused)
|
||||
Raw bytes (15): 0x[01, 01, 00, 02, 00, a7, 01, 01, 00, 09, 00, 00, 0a, 00, 16]
|
||||
Raw bytes (10): 0x[01, 01, 00, 01, 00, a7, 01, 01, 00, 09]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 2
|
||||
Number of file 0 mappings: 1
|
||||
- Code(Zero) at (prev + 167, 1) to (start + 0, 9)
|
||||
- Code(Zero) at (prev + 0, 10) to (start + 0, 22)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#13} (unused)
|
||||
Raw bytes (15): 0x[01, 01, 00, 02, 00, ac, 01, 0d, 00, 15, 00, 01, 11, 00, 1d]
|
||||
Raw bytes (10): 0x[01, 01, 00, 01, 00, ac, 01, 0d, 00, 15]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 2
|
||||
Number of file 0 mappings: 1
|
||||
- Code(Zero) at (prev + 172, 13) to (start + 0, 21)
|
||||
- Code(Zero) at (prev + 1, 17) to (start + 0, 29)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#14}
|
||||
Raw bytes (27): 0x[01, 01, 01, 01, 05, 04, 01, b4, 01, 11, 00, 21, 01, 01, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33]
|
||||
Raw bytes (22): 0x[01, 01, 01, 01, 05, 03, 01, b5, 01, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 180, 17) to (start + 0, 33)
|
||||
- Code(Counter(0)) at (prev + 1, 20) to (start + 0, 27)
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 181, 20) to (start + 0, 27)
|
||||
- Code(Counter(1)) at (prev + 0, 30) to (start + 0, 37)
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51)
|
||||
= (c0 - c1)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure::main::{closure#15}
|
||||
Raw bytes (42): 0x[01, 01, 01, 01, 05, 07, 01, bb, 01, 09, 00, 0a, 01, 01, 0d, 00, 15, 01, 01, 11, 00, 21, 01, 01, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33, 01, 02, 09, 00, 0a]
|
||||
Raw bytes (37): 0x[01, 01, 01, 01, 05, 06, 01, bb, 01, 09, 00, 0a, 01, 01, 0d, 00, 15, 01, 02, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33, 01, 02, 09, 00, 0a]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 7
|
||||
Number of file 0 mappings: 6
|
||||
- Code(Counter(0)) at (prev + 187, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 17) to (start + 0, 33)
|
||||
- Code(Counter(0)) at (prev + 1, 20) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 2, 20) to (start + 0, 27)
|
||||
- Code(Counter(1)) at (prev + 0, 30) to (start + 0, 37)
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51)
|
||||
= (c0 - c1)
|
||||
|
|
@ -169,30 +158,28 @@ Number of file 0 mappings: 7
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure::main::{closure#16}
|
||||
Raw bytes (27): 0x[01, 01, 01, 01, 05, 04, 01, c6, 01, 11, 00, 21, 01, 01, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33]
|
||||
Raw bytes (22): 0x[01, 01, 01, 01, 05, 03, 01, c7, 01, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 4
|
||||
- Code(Counter(0)) at (prev + 198, 17) to (start + 0, 33)
|
||||
- Code(Counter(0)) at (prev + 1, 20) to (start + 0, 27)
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 199, 20) to (start + 0, 27)
|
||||
- Code(Counter(1)) at (prev + 0, 30) to (start + 0, 37)
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51)
|
||||
= (c0 - c1)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure::main::{closure#17}
|
||||
Raw bytes (42): 0x[01, 01, 01, 01, 05, 07, 01, cd, 01, 09, 00, 0a, 01, 01, 0d, 00, 15, 01, 01, 11, 00, 21, 01, 01, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33, 01, 02, 09, 00, 0a]
|
||||
Raw bytes (37): 0x[01, 01, 01, 01, 05, 06, 01, cd, 01, 09, 00, 0a, 01, 01, 0d, 00, 15, 01, 02, 14, 00, 1b, 05, 00, 1e, 00, 25, 02, 00, 2f, 00, 33, 01, 02, 09, 00, 0a]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 7
|
||||
Number of file 0 mappings: 6
|
||||
- Code(Counter(0)) at (prev + 205, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 17) to (start + 0, 33)
|
||||
- Code(Counter(0)) at (prev + 1, 20) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 2, 20) to (start + 0, 27)
|
||||
- Code(Counter(1)) at (prev + 0, 30) to (start + 0, 37)
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51)
|
||||
= (c0 - c1)
|
||||
|
|
@ -257,12 +244,12 @@ Number of file 0 mappings: 9
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure::main::{closure#2}
|
||||
Raw bytes (51): 0x[01, 01, 01, 01, 05, 09, 01, 68, 05, 00, 06, 01, 01, 0d, 00, 1a, 01, 00, 1d, 00, 1e, 01, 01, 0c, 00, 14, 05, 00, 15, 02, 0a, 02, 02, 09, 00, 0a, 01, 01, 09, 00, 10, 01, 00, 11, 00, 17, 01, 01, 05, 00, 06]
|
||||
Raw bytes (46): 0x[01, 01, 01, 01, 05, 08, 01, 68, 05, 00, 06, 01, 01, 0d, 00, 1a, 01, 00, 1d, 00, 1e, 01, 01, 0c, 00, 14, 05, 00, 15, 02, 0a, 02, 02, 09, 00, 0a, 01, 01, 09, 00, 10, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 9
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 104, 5) to (start + 0, 6)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 26)
|
||||
- Code(Counter(0)) at (prev + 0, 29) to (start + 0, 30)
|
||||
|
|
@ -271,7 +258,6 @@ Number of file 0 mappings: 9
|
|||
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 10)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
|
|
@ -291,56 +277,51 @@ Number of file 0 mappings: 7
|
|||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#5}
|
||||
Raw bytes (15): 0x[01, 01, 00, 02, 01, 8c, 01, 3d, 00, 45, 01, 00, 46, 00, 4e]
|
||||
Raw bytes (10): 0x[01, 01, 00, 01, 01, 8c, 01, 3d, 00, 45]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 2
|
||||
Number of file 0 mappings: 1
|
||||
- Code(Counter(0)) at (prev + 140, 61) to (start + 0, 69)
|
||||
- Code(Counter(0)) at (prev + 0, 70) to (start + 0, 78)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: closure::main::{closure#6}
|
||||
Raw bytes (15): 0x[01, 01, 00, 02, 01, 8d, 01, 41, 00, 49, 01, 00, 4a, 00, 56]
|
||||
Raw bytes (10): 0x[01, 01, 00, 01, 01, 8d, 01, 41, 00, 49]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 2
|
||||
Number of file 0 mappings: 1
|
||||
- Code(Counter(0)) at (prev + 141, 65) to (start + 0, 73)
|
||||
- Code(Counter(0)) at (prev + 0, 74) to (start + 0, 86)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: closure::main::{closure#7} (unused)
|
||||
Raw bytes (15): 0x[01, 01, 00, 02, 00, 8e, 01, 3b, 00, 43, 00, 00, 44, 00, 50]
|
||||
Raw bytes (10): 0x[01, 01, 00, 01, 00, 8e, 01, 3b, 00, 43]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 2
|
||||
Number of file 0 mappings: 1
|
||||
- Code(Zero) at (prev + 142, 59) to (start + 0, 67)
|
||||
- Code(Zero) at (prev + 0, 68) to (start + 0, 80)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#8} (unused)
|
||||
Raw bytes (25): 0x[01, 01, 00, 04, 00, 93, 01, 3b, 00, 3c, 00, 00, 3d, 00, 45, 00, 00, 46, 00, 52, 00, 00, 54, 00, 55]
|
||||
Raw bytes (20): 0x[01, 01, 00, 03, 00, 93, 01, 3b, 00, 3c, 00, 00, 3d, 00, 45, 00, 00, 54, 00, 55]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 147, 59) to (start + 0, 60)
|
||||
- Code(Zero) at (prev + 0, 61) to (start + 0, 69)
|
||||
- Code(Zero) at (prev + 0, 70) to (start + 0, 82)
|
||||
- Code(Zero) at (prev + 0, 84) to (start + 0, 85)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
Function name: closure::main::{closure#9} (unused)
|
||||
Raw bytes (25): 0x[01, 01, 00, 04, 00, 95, 01, 38, 00, 39, 00, 01, 09, 00, 11, 00, 00, 12, 00, 1e, 00, 01, 05, 00, 06]
|
||||
Raw bytes (20): 0x[01, 01, 00, 03, 00, 95, 01, 38, 00, 39, 00, 01, 09, 00, 11, 00, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 149, 56) to (start + 0, 57)
|
||||
- Code(Zero) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Zero) at (prev + 0, 18) to (start + 0, 30)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
LL| |
|
||||
LL| 1| let mut some_string = Some(String::from("the string content"));
|
||||
LL| 1| println!(
|
||||
LL| 1| "The string or alt: {}"
|
||||
LL| | "The string or alt: {}"
|
||||
LL| | ,
|
||||
LL| 1| some_string
|
||||
LL| | .
|
||||
|
|
@ -45,7 +45,7 @@
|
|||
LL| 0| "alt string 2".to_owned()
|
||||
LL| 0| };
|
||||
LL| 1| println!(
|
||||
LL| 1| "The string or alt: {}"
|
||||
LL| | "The string or alt: {}"
|
||||
LL| | ,
|
||||
LL| 1| some_string
|
||||
LL| | .
|
||||
|
|
@ -57,7 +57,7 @@
|
|||
LL| |
|
||||
LL| 1| some_string = None;
|
||||
LL| 1| println!(
|
||||
LL| 1| "The string or alt: {}"
|
||||
LL| | "The string or alt: {}"
|
||||
LL| | ,
|
||||
LL| 1| some_string
|
||||
LL| | .
|
||||
|
|
@ -87,7 +87,7 @@
|
|||
LL| 1| "alt string 4".to_owned()
|
||||
LL| 1| };
|
||||
LL| 1| println!(
|
||||
LL| 1| "The string or alt: {}"
|
||||
LL| | "The string or alt: {}"
|
||||
LL| | ,
|
||||
LL| 1| some_string
|
||||
LL| | .
|
||||
|
|
@ -109,7 +109,7 @@
|
|||
LL| 5| format!("'{}'", val)
|
||||
LL| 5| };
|
||||
LL| 1| println!(
|
||||
LL| 1| "Repeated, quoted string: {:?}"
|
||||
LL| | "Repeated, quoted string: {:?}"
|
||||
LL| | ,
|
||||
LL| 1| std::iter::repeat("repeat me")
|
||||
LL| 1| .take(5)
|
||||
|
|
@ -139,15 +139,15 @@
|
|||
LL| |
|
||||
LL| 1| let short_used_covered_closure_macro = | used_arg: u8 | println!("called");
|
||||
LL| 1| let short_used_not_covered_closure_macro = | used_arg: u8 | println!("not called");
|
||||
^0 ^0
|
||||
^0
|
||||
LL| 1| let _short_unused_closure_macro = | _unused_arg: u8 | println!("not called");
|
||||
^0 ^0
|
||||
^0
|
||||
LL| |
|
||||
LL| |
|
||||
LL| |
|
||||
LL| |
|
||||
LL| 1| let _short_unused_closure_block = | _unused_arg: u8 | { println!("not called") };
|
||||
^0^0 ^0 ^0
|
||||
^0^0 ^0
|
||||
LL| |
|
||||
LL| 1| let _shortish_unused_closure = | _unused_arg: u8 | {
|
||||
^0
|
||||
|
|
@ -174,14 +174,14 @@
|
|||
LL| 1| let _short_unused_closure_line_break_no_block2 =
|
||||
LL| | | _unused_arg: u8 |
|
||||
LL| 0| println!(
|
||||
LL| 0| "not called"
|
||||
LL| | "not called"
|
||||
LL| | )
|
||||
LL| | ;
|
||||
LL| |
|
||||
LL| 1| let short_used_not_covered_closure_line_break_no_block_embedded_branch =
|
||||
LL| | | _unused_arg: u8 |
|
||||
LL| | println!(
|
||||
LL| 0| "not called: {}",
|
||||
LL| | "not called: {}",
|
||||
LL| 0| if is_true { "check" } else { "me" }
|
||||
LL| | )
|
||||
LL| | ;
|
||||
|
|
@ -190,7 +190,7 @@
|
|||
LL| | | _unused_arg: u8 |
|
||||
LL| 0| {
|
||||
LL| 0| println!(
|
||||
LL| 0| "not called: {}",
|
||||
LL| | "not called: {}",
|
||||
LL| 0| if is_true { "check" } else { "me" }
|
||||
LL| | )
|
||||
LL| 0| }
|
||||
|
|
@ -199,7 +199,7 @@
|
|||
LL| 1| let short_used_covered_closure_line_break_no_block_embedded_branch =
|
||||
LL| | | _unused_arg: u8 |
|
||||
LL| | println!(
|
||||
LL| 1| "not called: {}",
|
||||
LL| | "not called: {}",
|
||||
LL| 1| if is_true { "check" } else { "me" }
|
||||
^0
|
||||
LL| | )
|
||||
|
|
@ -209,7 +209,7 @@
|
|||
LL| | | _unused_arg: u8 |
|
||||
LL| 1| {
|
||||
LL| 1| println!(
|
||||
LL| 1| "not called: {}",
|
||||
LL| | "not called: {}",
|
||||
LL| 1| if is_true { "check" } else { "me" }
|
||||
^0
|
||||
LL| | )
|
||||
|
|
|
|||
|
|
@ -10,15 +10,14 @@ Number of file 0 mappings: 3
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: closure_macro::main
|
||||
Raw bytes (66): 0x[01, 01, 01, 01, 05, 0c, 01, 21, 01, 00, 24, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 20, 02, 01, 09, 00, 0f, 01, 00, 12, 00, 1b, 01, 00, 1c, 00, 34, 05, 00, 54, 00, 55, 02, 02, 09, 00, 1f, 02, 00, 22, 00, 2e, 02, 01, 0d, 00, 2d, 02, 01, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (61): 0x[01, 01, 01, 01, 05, 0b, 01, 21, 01, 00, 24, 01, 01, 05, 00, 0d, 02, 01, 09, 00, 0f, 01, 00, 12, 00, 1b, 01, 00, 1c, 00, 34, 05, 00, 54, 00, 55, 02, 02, 09, 00, 1f, 02, 00, 22, 00, 2e, 02, 01, 0d, 00, 2d, 02, 01, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure_macro.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 12
|
||||
Number of file 0 mappings: 11
|
||||
- Code(Counter(0)) at (prev + 33, 1) to (start + 0, 36)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 32)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 27)
|
||||
|
|
@ -36,25 +35,22 @@ Number of file 0 mappings: 12
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure_macro::main::{closure#0}
|
||||
Raw bytes (60): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 0a, 01, 10, 1c, 00, 1d, 01, 02, 11, 00, 18, 01, 00, 1b, 00, 22, 01, 01, 10, 00, 21, 05, 01, 11, 00, 19, 05, 00, 1a, 00, 1e, 05, 01, 11, 00, 27, 02, 02, 11, 00, 16, 06, 00, 17, 00, 1e, 01, 02, 09, 00, 0a]
|
||||
Raw bytes (51): 0x[01, 01, 01, 01, 05, 09, 01, 10, 1c, 00, 1d, 01, 02, 11, 00, 18, 01, 00, 1b, 00, 22, 01, 01, 10, 00, 21, 05, 01, 11, 00, 19, 05, 01, 11, 00, 27, 02, 02, 11, 00, 16, 02, 00, 17, 00, 1e, 01, 02, 09, 00, 0a]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure_macro.rs
|
||||
Number of expressions: 3
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
- expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
|
||||
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
|
||||
Number of file 0 mappings: 10
|
||||
Number of file 0 mappings: 9
|
||||
- Code(Counter(0)) at (prev + 16, 28) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 2, 17) to (start + 0, 24)
|
||||
- Code(Counter(0)) at (prev + 0, 27) to (start + 0, 34)
|
||||
- Code(Counter(0)) at (prev + 1, 16) to (start + 0, 33)
|
||||
- Code(Counter(1)) at (prev + 1, 17) to (start + 0, 25)
|
||||
- Code(Counter(1)) at (prev + 0, 26) to (start + 0, 30)
|
||||
- Code(Counter(1)) at (prev + 1, 17) to (start + 0, 39)
|
||||
- Code(Expression(0, Sub)) at (prev + 2, 17) to (start + 0, 22)
|
||||
= (c0 - c1)
|
||||
- Code(Expression(1, Sub)) at (prev + 0, 23) to (start + 0, 30)
|
||||
= (c0 - (c1 + c2))
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 30)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 10)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
|
|
|
|||
|
|
@ -19,15 +19,14 @@ Number of file 0 mappings: 1
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: closure_macro_async::test::{closure#0}
|
||||
Raw bytes (66): 0x[01, 01, 01, 01, 05, 0c, 01, 25, 2b, 00, 2c, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 20, 02, 01, 09, 00, 0f, 01, 00, 12, 00, 1b, 01, 00, 1c, 00, 34, 05, 00, 54, 00, 55, 02, 02, 09, 00, 1f, 02, 00, 22, 00, 2e, 02, 01, 0d, 00, 2d, 02, 01, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (61): 0x[01, 01, 01, 01, 05, 0b, 01, 25, 2b, 00, 2c, 01, 01, 05, 00, 0d, 02, 01, 09, 00, 0f, 01, 00, 12, 00, 1b, 01, 00, 1c, 00, 34, 05, 00, 54, 00, 55, 02, 02, 09, 00, 1f, 02, 00, 22, 00, 2e, 02, 01, 0d, 00, 2d, 02, 01, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure_macro_async.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 12
|
||||
Number of file 0 mappings: 11
|
||||
- Code(Counter(0)) at (prev + 37, 43) to (start + 0, 44)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 32)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 27)
|
||||
|
|
@ -45,25 +44,22 @@ Number of file 0 mappings: 12
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: closure_macro_async::test::{closure#0}::{closure#0}
|
||||
Raw bytes (60): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 0a, 01, 14, 1c, 00, 1d, 01, 02, 11, 00, 18, 01, 00, 1b, 00, 22, 01, 01, 10, 00, 21, 05, 01, 11, 00, 19, 05, 00, 1a, 00, 1e, 05, 01, 11, 00, 27, 02, 02, 11, 00, 16, 06, 00, 17, 00, 1e, 01, 02, 09, 00, 0a]
|
||||
Raw bytes (51): 0x[01, 01, 01, 01, 05, 09, 01, 14, 1c, 00, 1d, 01, 02, 11, 00, 18, 01, 00, 1b, 00, 22, 01, 01, 10, 00, 21, 05, 01, 11, 00, 19, 05, 01, 11, 00, 27, 02, 02, 11, 00, 16, 02, 00, 17, 00, 1e, 01, 02, 09, 00, 0a]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/closure_macro_async.rs
|
||||
Number of expressions: 3
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
- expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
|
||||
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
|
||||
Number of file 0 mappings: 10
|
||||
Number of file 0 mappings: 9
|
||||
- Code(Counter(0)) at (prev + 20, 28) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 2, 17) to (start + 0, 24)
|
||||
- Code(Counter(0)) at (prev + 0, 27) to (start + 0, 34)
|
||||
- Code(Counter(0)) at (prev + 1, 16) to (start + 0, 33)
|
||||
- Code(Counter(1)) at (prev + 1, 17) to (start + 0, 25)
|
||||
- Code(Counter(1)) at (prev + 0, 26) to (start + 0, 30)
|
||||
- Code(Counter(1)) at (prev + 1, 17) to (start + 0, 39)
|
||||
- Code(Expression(0, Sub)) at (prev + 2, 17) to (start + 0, 22)
|
||||
= (c0 - c1)
|
||||
- Code(Expression(1, Sub)) at (prev + 0, 23) to (start + 0, 30)
|
||||
= (c0 - (c1 + c2))
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 30)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 10)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
Function name: conditions::main
|
||||
Raw bytes (656): 0x[01, 01, 57, 05, 09, 01, 05, 09, 5d, 09, 27, 5d, 61, 27, 65, 5d, 61, 09, 23, 27, 65, 5d, 61, 01, 03, 03, 0d, 11, 51, 11, 4f, 51, 55, 4f, 59, 51, 55, 11, 4b, 4f, 59, 51, 55, 03, 9f, 01, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 9f, 01, 15, 0d, 11, 19, 45, 19, 97, 01, 45, 49, 97, 01, 4d, 45, 49, 19, 93, 01, 97, 01, 4d, 45, 49, 9f, 01, 9b, 02, 0d, 11, 15, 19, 15, 19, 15, 19, 15, 19, 15, 19, 1d, 21, 15, 19, 9b, 02, 1d, 15, 19, 21, 39, 21, e3, 01, 39, 3d, e3, 01, 41, 39, 3d, 21, df, 01, e3, 01, 41, 39, 3d, 9b, 02, d7, 02, 15, 19, 1d, 21, 9b, 02, d7, 02, 15, 19, 1d, 21, 9b, 02, d7, 02, 15, 19, 1d, 21, 9b, 02, d7, 02, 15, 19, 1d, 21, 9b, 02, d7, 02, 15, 19, 1d, 21, 25, 29, 1d, 21, d7, 02, 25, 1d, 21, 29, 2d, 29, cf, 02, 2d, 31, cf, 02, 35, 2d, 31, 29, cb, 02, cf, 02, 35, 2d, 31, d7, 02, db, 02, 1d, 21, 25, 29, 53, 01, 03, 01, 00, 0a, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1a, 01, 01, 08, 00, 0c, 01, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 03, 09, 00, 0a, 01, 00, 10, 00, 1d, 05, 01, 09, 00, 17, 05, 01, 09, 00, 0a, 06, 01, 0f, 00, 1c, 09, 01, 0c, 00, 19, 0a, 00, 1d, 00, 2a, 0e, 00, 2e, 00, 3c, 23, 00, 3d, 02, 0a, 1e, 02, 09, 00, 0a, 09, 01, 09, 00, 17, 09, 01, 09, 00, 12, 2a, 02, 09, 00, 0f, 03, 03, 09, 00, 16, 03, 00, 19, 00, 1a, 03, 01, 08, 00, 0c, 03, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 02, 08, 00, 15, 0d, 00, 16, 02, 06, 2e, 02, 0f, 00, 1c, 11, 01, 0c, 00, 19, 32, 00, 1d, 00, 2a, 36, 00, 2e, 00, 3c, 4b, 00, 3d, 02, 0a, 46, 02, 09, 00, 0a, 11, 01, 09, 00, 17, 52, 02, 09, 00, 0f, 9f, 01, 03, 08, 00, 0c, 9f, 01, 01, 0d, 00, 1a, 9f, 01, 00, 1d, 00, 1e, 9f, 01, 01, 0c, 00, 10, 9f, 01, 00, 11, 02, 0a, 00, 02, 09, 00, 0a, 9f, 01, 02, 0c, 00, 19, 15, 00, 1a, 02, 0a, 72, 04, 11, 00, 1e, 19, 01, 10, 00, 1d, 7a, 00, 21, 00, 2e, 7e, 00, 32, 00, 40, 93, 01, 00, 41, 02, 0e, 8e, 01, 02, 0d, 00, 0e, 19, 01, 0d, 00, 1b, 9a, 01, 02, 0d, 00, 13, 00, 02, 05, 00, 06, 9b, 02, 02, 09, 00, 16, 9b, 02, 00, 19, 00, 1a, 9b, 02, 01, 08, 00, 0c, 9b, 02, 00, 0d, 02, 06, 00, 02, 05, 00, 06, d7, 02, 02, 09, 00, 0a, 9b, 02, 00, 10, 00, 1d, 1d, 00, 1e, 02, 06, be, 01, 02, 0f, 00, 1c, 21, 01, 0c, 00, 19, c6, 01, 00, 1d, 00, 2a, ca, 01, 00, 2e, 00, 3c, df, 01, 00, 3d, 02, 0a, da, 01, 02, 09, 00, 0a, 21, 01, 09, 00, 17, 96, 02, 02, 0d, 00, 20, 96, 02, 00, 23, 00, 2c, 96, 02, 01, 09, 00, 11, 96, 02, 00, 12, 00, 1b, 96, 02, 01, 09, 00, 0f, db, 02, 03, 09, 00, 0a, d7, 02, 00, 10, 00, 1d, 25, 00, 1e, 02, 06, aa, 02, 02, 0f, 00, 1c, 29, 01, 0c, 00, 19, b2, 02, 00, 1d, 00, 2a, b6, 02, 00, 2e, 00, 3c, cb, 02, 00, 3d, 02, 0a, c6, 02, 02, 09, 00, 0a, 29, 01, 09, 00, 17, d2, 02, 02, 09, 00, 0f, 01, 02, 01, 00, 02]
|
||||
Raw bytes (642): 0x[01, 01, 54, 05, 09, 01, 05, 09, 5d, 09, 27, 5d, 61, 27, 65, 5d, 61, 09, 23, 27, 65, 5d, 61, 01, 03, 03, 0d, 11, 51, 11, 4f, 51, 55, 4f, 59, 51, 55, 11, 4b, 4f, 59, 51, 55, 03, 9f, 01, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 0d, 11, 9f, 01, 15, 0d, 11, 19, 45, 19, 97, 01, 45, 49, 97, 01, 4d, 45, 49, 19, 93, 01, 97, 01, 4d, 45, 49, 9f, 01, 8f, 02, 0d, 11, 15, 19, 15, 19, 15, 19, 15, 19, 15, 19, 1d, 21, 15, 19, 8f, 02, 1d, 15, 19, 21, 39, 21, e3, 01, 39, 3d, e3, 01, 41, 39, 3d, 21, df, 01, e3, 01, 41, 39, 3d, 8f, 02, cb, 02, 15, 19, 1d, 21, 8f, 02, cb, 02, 15, 19, 1d, 21, 8f, 02, cb, 02, 15, 19, 1d, 21, 8f, 02, cb, 02, 15, 19, 1d, 21, 25, 29, 1d, 21, cb, 02, 25, 1d, 21, 29, 2d, 29, c3, 02, 2d, 31, c3, 02, 35, 2d, 31, 29, bf, 02, c3, 02, 35, 2d, 31, cb, 02, cf, 02, 1d, 21, 25, 29, 52, 01, 03, 01, 00, 0a, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1a, 01, 01, 08, 00, 0c, 01, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 03, 09, 00, 0a, 01, 00, 10, 00, 1d, 05, 01, 09, 00, 17, 05, 01, 09, 00, 0a, 06, 01, 0f, 00, 1c, 09, 01, 0c, 00, 19, 0a, 00, 1d, 00, 2a, 0e, 00, 2e, 00, 3c, 23, 00, 3d, 02, 0a, 1e, 02, 09, 00, 0a, 09, 01, 09, 00, 17, 09, 01, 09, 00, 12, 2a, 02, 09, 00, 0f, 03, 03, 09, 00, 16, 03, 00, 19, 00, 1a, 03, 01, 08, 00, 0c, 03, 00, 0d, 02, 06, 00, 02, 05, 00, 06, 03, 02, 08, 00, 15, 0d, 00, 16, 02, 06, 2e, 02, 0f, 00, 1c, 11, 01, 0c, 00, 19, 32, 00, 1d, 00, 2a, 36, 00, 2e, 00, 3c, 4b, 00, 3d, 02, 0a, 46, 02, 09, 00, 0a, 11, 01, 09, 00, 17, 52, 02, 09, 00, 0f, 9f, 01, 03, 08, 00, 0c, 9f, 01, 01, 0d, 00, 1a, 9f, 01, 00, 1d, 00, 1e, 9f, 01, 01, 0c, 00, 10, 9f, 01, 00, 11, 02, 0a, 00, 02, 09, 00, 0a, 9f, 01, 02, 0c, 00, 19, 15, 00, 1a, 02, 0a, 72, 04, 11, 00, 1e, 19, 01, 10, 00, 1d, 7a, 00, 21, 00, 2e, 7e, 00, 32, 00, 40, 93, 01, 00, 41, 02, 0e, 8e, 01, 02, 0d, 00, 0e, 19, 01, 0d, 00, 1b, 9a, 01, 02, 0d, 00, 13, 00, 02, 05, 00, 06, 8f, 02, 02, 09, 00, 16, 8f, 02, 00, 19, 00, 1a, 8f, 02, 01, 08, 00, 0c, 8f, 02, 00, 0d, 02, 06, 00, 02, 05, 00, 06, cb, 02, 02, 09, 00, 0a, 8f, 02, 00, 10, 00, 1d, 1d, 00, 1e, 02, 06, be, 01, 02, 0f, 00, 1c, 21, 01, 0c, 00, 19, c6, 01, 00, 1d, 00, 2a, ca, 01, 00, 2e, 00, 3c, df, 01, 00, 3d, 02, 0a, da, 01, 02, 09, 00, 0a, 21, 01, 09, 00, 17, 8a, 02, 02, 0d, 00, 20, 8a, 02, 00, 23, 00, 2c, 8a, 02, 01, 09, 00, 11, 8a, 02, 01, 09, 00, 0f, cf, 02, 03, 09, 00, 0a, cb, 02, 00, 10, 00, 1d, 25, 00, 1e, 02, 06, 9e, 02, 02, 0f, 00, 1c, 29, 01, 0c, 00, 19, a6, 02, 00, 1d, 00, 2a, aa, 02, 00, 2e, 00, 3c, bf, 02, 00, 3d, 02, 0a, ba, 02, 02, 09, 00, 0a, 29, 01, 09, 00, 17, c6, 02, 02, 09, 00, 0f, 01, 02, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/conditions.rs
|
||||
Number of expressions: 87
|
||||
Number of expressions: 84
|
||||
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
|
||||
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
- expression 2 operands: lhs = Counter(2), rhs = Counter(23)
|
||||
|
|
@ -41,7 +41,7 @@ Number of expressions: 87
|
|||
- expression 35 operands: lhs = Counter(6), rhs = Expression(36, Add)
|
||||
- expression 36 operands: lhs = Expression(37, Add), rhs = Counter(19)
|
||||
- expression 37 operands: lhs = Counter(17), rhs = Counter(18)
|
||||
- expression 38 operands: lhs = Expression(39, Add), rhs = Expression(70, Add)
|
||||
- expression 38 operands: lhs = Expression(39, Add), rhs = Expression(67, Add)
|
||||
- expression 39 operands: lhs = Counter(3), rhs = Counter(4)
|
||||
- expression 40 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 41 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
|
|
@ -50,7 +50,7 @@ Number of expressions: 87
|
|||
- expression 44 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 45 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 46 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 47 operands: lhs = Expression(70, Add), rhs = Counter(7)
|
||||
- expression 47 operands: lhs = Expression(67, Add), rhs = Counter(7)
|
||||
- expression 48 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 49 operands: lhs = Counter(8), rhs = Counter(14)
|
||||
- expression 50 operands: lhs = Counter(8), rhs = Expression(56, Add)
|
||||
|
|
@ -60,37 +60,34 @@ Number of expressions: 87
|
|||
- expression 54 operands: lhs = Counter(8), rhs = Expression(55, Add)
|
||||
- expression 55 operands: lhs = Expression(56, Add), rhs = Counter(16)
|
||||
- expression 56 operands: lhs = Counter(14), rhs = Counter(15)
|
||||
- expression 57 operands: lhs = Expression(70, Add), rhs = Expression(85, Add)
|
||||
- expression 57 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
|
||||
- expression 58 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 59 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 60 operands: lhs = Expression(70, Add), rhs = Expression(85, Add)
|
||||
- expression 60 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
|
||||
- expression 61 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 62 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 63 operands: lhs = Expression(70, Add), rhs = Expression(85, Add)
|
||||
- expression 63 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
|
||||
- expression 64 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 65 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 66 operands: lhs = Expression(70, Add), rhs = Expression(85, Add)
|
||||
- expression 66 operands: lhs = Expression(67, Add), rhs = Expression(82, Add)
|
||||
- expression 67 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 68 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 69 operands: lhs = Expression(70, Add), rhs = Expression(85, Add)
|
||||
- expression 70 operands: lhs = Counter(5), rhs = Counter(6)
|
||||
- expression 71 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 72 operands: lhs = Counter(9), rhs = Counter(10)
|
||||
- expression 73 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 74 operands: lhs = Expression(85, Add), rhs = Counter(9)
|
||||
- expression 75 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 76 operands: lhs = Counter(10), rhs = Counter(11)
|
||||
- expression 77 operands: lhs = Counter(10), rhs = Expression(83, Add)
|
||||
- expression 78 operands: lhs = Counter(11), rhs = Counter(12)
|
||||
- expression 79 operands: lhs = Expression(83, Add), rhs = Counter(13)
|
||||
- expression 69 operands: lhs = Counter(9), rhs = Counter(10)
|
||||
- expression 70 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 71 operands: lhs = Expression(82, Add), rhs = Counter(9)
|
||||
- expression 72 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 73 operands: lhs = Counter(10), rhs = Counter(11)
|
||||
- expression 74 operands: lhs = Counter(10), rhs = Expression(80, Add)
|
||||
- expression 75 operands: lhs = Counter(11), rhs = Counter(12)
|
||||
- expression 76 operands: lhs = Expression(80, Add), rhs = Counter(13)
|
||||
- expression 77 operands: lhs = Counter(11), rhs = Counter(12)
|
||||
- expression 78 operands: lhs = Counter(10), rhs = Expression(79, Add)
|
||||
- expression 79 operands: lhs = Expression(80, Add), rhs = Counter(13)
|
||||
- expression 80 operands: lhs = Counter(11), rhs = Counter(12)
|
||||
- expression 81 operands: lhs = Counter(10), rhs = Expression(82, Add)
|
||||
- expression 82 operands: lhs = Expression(83, Add), rhs = Counter(13)
|
||||
- expression 83 operands: lhs = Counter(11), rhs = Counter(12)
|
||||
- expression 84 operands: lhs = Expression(85, Add), rhs = Expression(86, Add)
|
||||
- expression 85 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 86 operands: lhs = Counter(9), rhs = Counter(10)
|
||||
Number of file 0 mappings: 83
|
||||
- expression 81 operands: lhs = Expression(82, Add), rhs = Expression(83, Add)
|
||||
- expression 82 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
- expression 83 operands: lhs = Counter(9), rhs = Counter(10)
|
||||
Number of file 0 mappings: 82
|
||||
- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 0, 25) to (start + 0, 26)
|
||||
|
|
@ -172,18 +169,18 @@ Number of file 0 mappings: 83
|
|||
- Code(Expression(38, Sub)) at (prev + 2, 13) to (start + 0, 19)
|
||||
= ((c3 + c4) - (c5 + c6))
|
||||
- Code(Zero) at (prev + 2, 5) to (start + 0, 6)
|
||||
- Code(Expression(70, Add)) at (prev + 2, 9) to (start + 0, 22)
|
||||
- Code(Expression(67, Add)) at (prev + 2, 9) to (start + 0, 22)
|
||||
= (c5 + c6)
|
||||
- Code(Expression(70, Add)) at (prev + 0, 25) to (start + 0, 26)
|
||||
- Code(Expression(67, Add)) at (prev + 0, 25) to (start + 0, 26)
|
||||
= (c5 + c6)
|
||||
- Code(Expression(70, Add)) at (prev + 1, 8) to (start + 0, 12)
|
||||
- Code(Expression(67, Add)) at (prev + 1, 8) to (start + 0, 12)
|
||||
= (c5 + c6)
|
||||
- Code(Expression(70, Add)) at (prev + 0, 13) to (start + 2, 6)
|
||||
- Code(Expression(67, Add)) at (prev + 0, 13) to (start + 2, 6)
|
||||
= (c5 + c6)
|
||||
- Code(Zero) at (prev + 2, 5) to (start + 0, 6)
|
||||
- Code(Expression(85, Add)) at (prev + 2, 9) to (start + 0, 10)
|
||||
- Code(Expression(82, Add)) at (prev + 2, 9) to (start + 0, 10)
|
||||
= (c7 + c8)
|
||||
- Code(Expression(70, Add)) at (prev + 0, 16) to (start + 0, 29)
|
||||
- Code(Expression(67, Add)) at (prev + 0, 16) to (start + 0, 29)
|
||||
= (c5 + c6)
|
||||
- Code(Counter(7)) at (prev + 0, 30) to (start + 2, 6)
|
||||
- Code(Expression(47, Sub)) at (prev + 2, 15) to (start + 0, 28)
|
||||
|
|
@ -198,34 +195,32 @@ Number of file 0 mappings: 83
|
|||
- Code(Expression(54, Sub)) at (prev + 2, 9) to (start + 0, 10)
|
||||
= (c8 - ((c14 + c15) + c16))
|
||||
- Code(Counter(8)) at (prev + 1, 9) to (start + 0, 23)
|
||||
- Code(Expression(69, Sub)) at (prev + 2, 13) to (start + 0, 32)
|
||||
- Code(Expression(66, Sub)) at (prev + 2, 13) to (start + 0, 32)
|
||||
= ((c5 + c6) - (c7 + c8))
|
||||
- Code(Expression(69, Sub)) at (prev + 0, 35) to (start + 0, 44)
|
||||
- Code(Expression(66, Sub)) at (prev + 0, 35) to (start + 0, 44)
|
||||
= ((c5 + c6) - (c7 + c8))
|
||||
- Code(Expression(69, Sub)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Expression(66, Sub)) at (prev + 1, 9) to (start + 0, 17)
|
||||
= ((c5 + c6) - (c7 + c8))
|
||||
- Code(Expression(69, Sub)) at (prev + 0, 18) to (start + 0, 27)
|
||||
- Code(Expression(66, Sub)) at (prev + 1, 9) to (start + 0, 15)
|
||||
= ((c5 + c6) - (c7 + c8))
|
||||
- Code(Expression(69, Sub)) at (prev + 1, 9) to (start + 0, 15)
|
||||
= ((c5 + c6) - (c7 + c8))
|
||||
- Code(Expression(86, Add)) at (prev + 3, 9) to (start + 0, 10)
|
||||
- Code(Expression(83, Add)) at (prev + 3, 9) to (start + 0, 10)
|
||||
= (c9 + c10)
|
||||
- Code(Expression(85, Add)) at (prev + 0, 16) to (start + 0, 29)
|
||||
- Code(Expression(82, Add)) at (prev + 0, 16) to (start + 0, 29)
|
||||
= (c7 + c8)
|
||||
- Code(Counter(9)) at (prev + 0, 30) to (start + 2, 6)
|
||||
- Code(Expression(74, Sub)) at (prev + 2, 15) to (start + 0, 28)
|
||||
- Code(Expression(71, Sub)) at (prev + 2, 15) to (start + 0, 28)
|
||||
= ((c7 + c8) - c9)
|
||||
- Code(Counter(10)) at (prev + 1, 12) to (start + 0, 25)
|
||||
- Code(Expression(76, Sub)) at (prev + 0, 29) to (start + 0, 42)
|
||||
- Code(Expression(73, Sub)) at (prev + 0, 29) to (start + 0, 42)
|
||||
= (c10 - c11)
|
||||
- Code(Expression(77, Sub)) at (prev + 0, 46) to (start + 0, 60)
|
||||
- Code(Expression(74, Sub)) at (prev + 0, 46) to (start + 0, 60)
|
||||
= (c10 - (c11 + c12))
|
||||
- Code(Expression(82, Add)) at (prev + 0, 61) to (start + 2, 10)
|
||||
- Code(Expression(79, Add)) at (prev + 0, 61) to (start + 2, 10)
|
||||
= ((c11 + c12) + c13)
|
||||
- Code(Expression(81, Sub)) at (prev + 2, 9) to (start + 0, 10)
|
||||
- Code(Expression(78, Sub)) at (prev + 2, 9) to (start + 0, 10)
|
||||
= (c10 - ((c11 + c12) + c13))
|
||||
- Code(Counter(10)) at (prev + 1, 9) to (start + 0, 23)
|
||||
- Code(Expression(84, Sub)) at (prev + 2, 9) to (start + 0, 15)
|
||||
- Code(Expression(81, Sub)) at (prev + 2, 9) to (start + 0, 15)
|
||||
= ((c7 + c8) - (c9 + c10))
|
||||
- Code(Counter(0)) at (prev + 2, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c10
|
||||
|
|
|
|||
|
|
@ -1,24 +1,22 @@
|
|||
Function name: coverage_attr_closure::GLOBAL_CLOSURE_ON::{closure#0}
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 06, 0f, 00, 10, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 17, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 06, 0f, 00, 10, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/coverage_attr_closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 6, 15) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: coverage_attr_closure::contains_closures_off::{closure#0} (unused)
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 00, 1d, 13, 00, 14, 00, 01, 09, 00, 11, 00, 00, 12, 00, 1b, 00, 01, 05, 00, 06]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 00, 1d, 13, 00, 14, 00, 01, 09, 00, 11, 00, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/coverage_attr_closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 29, 19) to (start + 0, 20)
|
||||
- Code(Zero) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Zero) at (prev + 0, 18) to (start + 0, 27)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
|
|
@ -35,14 +33,13 @@ Number of file 0 mappings: 4
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: coverage_attr_closure::contains_closures_on::{closure#0} (unused)
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 00, 11, 13, 00, 14, 00, 01, 09, 00, 11, 00, 00, 12, 00, 1b, 00, 01, 05, 00, 06]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 00, 11, 13, 00, 14, 00, 01, 09, 00, 11, 00, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/coverage_attr_closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 17, 19) to (start + 0, 20)
|
||||
- Code(Zero) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Zero) at (prev + 0, 18) to (start + 0, 27)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,21 +1,20 @@
|
|||
Function name: <drop_trait::Firework as core::ops::drop::Drop>::drop
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 09, 05, 00, 17, 01, 01, 09, 00, 11, 01, 00, 12, 00, 24, 01, 01, 05, 00, 06]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 09, 05, 00, 17, 01, 01, 09, 00, 11, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/drop_trait.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 9, 5) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 36)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: drop_trait::main
|
||||
Raw bytes (69): 0x[01, 01, 00, 0d, 01, 0e, 01, 00, 1c, 01, 01, 09, 00, 15, 01, 00, 18, 00, 30, 01, 02, 09, 00, 0d, 01, 00, 10, 00, 2a, 01, 02, 08, 00, 0c, 01, 01, 09, 00, 11, 01, 00, 12, 00, 29, 01, 01, 10, 00, 16, 00, 01, 05, 00, 06, 00, 02, 0d, 00, 28, 00, 02, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (64): 0x[01, 01, 00, 0c, 01, 0e, 01, 00, 1c, 01, 01, 09, 00, 15, 01, 00, 18, 00, 30, 01, 02, 09, 00, 0d, 01, 00, 10, 00, 2a, 01, 02, 08, 00, 0c, 01, 01, 09, 00, 11, 01, 01, 10, 00, 16, 00, 01, 05, 00, 06, 00, 02, 0d, 00, 28, 00, 02, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/drop_trait.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 13
|
||||
Number of file 0 mappings: 12
|
||||
- Code(Counter(0)) at (prev + 14, 1) to (start + 0, 28)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 0, 24) to (start + 0, 48)
|
||||
|
|
@ -23,7 +22,6 @@ Number of file 0 mappings: 13
|
|||
- Code(Counter(0)) at (prev + 0, 16) to (start + 0, 42)
|
||||
- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 12)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 41)
|
||||
- Code(Counter(0)) at (prev + 1, 16) to (start + 0, 22)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 6)
|
||||
- Code(Zero) at (prev + 2, 13) to (start + 0, 40)
|
||||
|
|
|
|||
|
|
@ -1,12 +1,11 @@
|
|||
Function name: <generics::Firework<f64> as core::ops::drop::Drop>::drop
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 11, 05, 00, 17, 01, 01, 09, 00, 11, 01, 00, 12, 00, 24, 01, 01, 05, 00, 06]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 11, 05, 00, 17, 01, 01, 09, 00, 11, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/generics.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 17, 5) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 36)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
@ -22,14 +21,13 @@ Number of file 0 mappings: 3
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: <generics::Firework<i32> as core::ops::drop::Drop>::drop
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 11, 05, 00, 17, 01, 01, 09, 00, 11, 01, 00, 12, 00, 24, 01, 01, 05, 00, 06]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 11, 05, 00, 17, 01, 01, 09, 00, 11, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/generics.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 17, 5) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 36)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
@ -45,11 +43,11 @@ Number of file 0 mappings: 3
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: generics::main
|
||||
Raw bytes (99): 0x[01, 01, 00, 13, 01, 16, 01, 00, 1c, 01, 01, 09, 00, 18, 01, 00, 1b, 00, 33, 01, 01, 05, 00, 10, 01, 00, 11, 00, 1d, 01, 02, 09, 00, 10, 01, 00, 13, 00, 2f, 01, 01, 05, 00, 08, 01, 00, 09, 00, 15, 01, 01, 05, 00, 08, 01, 00, 09, 00, 15, 01, 02, 08, 00, 0c, 01, 01, 09, 00, 11, 01, 00, 12, 00, 29, 01, 01, 10, 00, 16, 00, 01, 05, 00, 06, 00, 02, 0d, 00, 28, 00, 02, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (94): 0x[01, 01, 00, 12, 01, 16, 01, 00, 1c, 01, 01, 09, 00, 18, 01, 00, 1b, 00, 33, 01, 01, 05, 00, 10, 01, 00, 11, 00, 1d, 01, 02, 09, 00, 10, 01, 00, 13, 00, 2f, 01, 01, 05, 00, 08, 01, 00, 09, 00, 15, 01, 01, 05, 00, 08, 01, 00, 09, 00, 15, 01, 02, 08, 00, 0c, 01, 01, 09, 00, 11, 01, 01, 10, 00, 16, 00, 01, 05, 00, 06, 00, 02, 0d, 00, 28, 00, 02, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/generics.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 19
|
||||
Number of file 0 mappings: 18
|
||||
- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 28)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 24)
|
||||
- Code(Counter(0)) at (prev + 0, 27) to (start + 0, 51)
|
||||
|
|
@ -63,7 +61,6 @@ Number of file 0 mappings: 19
|
|||
- Code(Counter(0)) at (prev + 0, 9) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 12)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 41)
|
||||
- Code(Counter(0)) at (prev + 1, 16) to (start + 0, 22)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 6)
|
||||
- Code(Zero) at (prev + 2, 13) to (start + 0, 40)
|
||||
|
|
|
|||
|
|
@ -25,14 +25,13 @@ Number of file 0 mappings: 5
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: inline_dead::main
|
||||
Raw bytes (39): 0x[01, 01, 00, 07, 01, 04, 01, 00, 0a, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 12, 01, 00, 14, 00, 21, 01, 02, 09, 00, 0a, 01, 03, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 04, 01, 00, 0a, 01, 01, 05, 00, 0d, 01, 00, 14, 00, 21, 01, 02, 09, 00, 0a, 01, 03, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/inline-dead.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 7
|
||||
Number of file 0 mappings: 6
|
||||
- Code(Counter(0)) at (prev + 4, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 18)
|
||||
- Code(Counter(0)) at (prev + 0, 20) to (start + 0, 33)
|
||||
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 13)
|
||||
|
|
|
|||
|
|
@ -53,18 +53,17 @@ Number of file 0 mappings: 16
|
|||
Highest counter ID seen: c2
|
||||
|
||||
Function name: inner_items::main::in_func
|
||||
Raw bytes (44): 0x[01, 01, 00, 08, 01, 12, 05, 00, 17, 01, 01, 0d, 00, 0e, 01, 00, 11, 00, 12, 01, 01, 0d, 00, 0e, 01, 00, 11, 00, 16, 01, 01, 09, 00, 11, 01, 00, 12, 00, 1a, 01, 01, 05, 00, 06]
|
||||
Raw bytes (39): 0x[01, 01, 00, 07, 01, 12, 05, 00, 17, 01, 01, 0d, 00, 0e, 01, 00, 11, 00, 12, 01, 01, 0d, 00, 0e, 01, 00, 11, 00, 16, 01, 01, 09, 00, 11, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/inner_items.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 8
|
||||
Number of file 0 mappings: 7
|
||||
- Code(Counter(0)) at (prev + 18, 5) to (start + 0, 23)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 18)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 0, 17) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 26)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
Function name: issue_83601::main
|
||||
Raw bytes (74): 0x[01, 01, 00, 0e, 01, 06, 01, 00, 0a, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 01, 00, 02]
|
||||
Raw bytes (59): 0x[01, 01, 00, 0b, 01, 06, 01, 00, 0a, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/issue-83601.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 14
|
||||
Number of file 0 mappings: 11
|
||||
- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 12)
|
||||
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
|
||||
|
|
@ -12,11 +12,8 @@ Number of file 0 mappings: 14
|
|||
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,14 +1,13 @@
|
|||
Function name: <issue_84561::Foo as core::fmt::Debug>::fmt
|
||||
Raw bytes (42): 0x[01, 01, 01, 01, 05, 07, 01, 8a, 01, 05, 00, 43, 01, 01, 09, 00, 0f, 01, 00, 10, 00, 11, 01, 00, 13, 00, 24, 05, 00, 25, 00, 26, 02, 01, 09, 00, 0f, 01, 01, 05, 00, 06]
|
||||
Raw bytes (37): 0x[01, 01, 01, 01, 05, 06, 01, 8a, 01, 05, 00, 43, 01, 01, 09, 00, 0f, 01, 00, 10, 00, 11, 05, 00, 25, 00, 26, 02, 01, 09, 00, 0f, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/issue-84561.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 7
|
||||
Number of file 0 mappings: 6
|
||||
- Code(Counter(0)) at (prev + 138, 5) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 0, 16) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 36)
|
||||
- Code(Counter(1)) at (prev + 0, 37) to (start + 0, 38)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15)
|
||||
= (c0 - c1)
|
||||
|
|
@ -29,54 +28,48 @@ Number of file 0 mappings: 5
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: issue_84561::test1
|
||||
Raw bytes (65): 0x[01, 01, 00, 0c, 01, 9a, 01, 01, 00, 0b, 01, 01, 05, 00, 0b, 05, 00, 0c, 00, 1e, 01, 01, 05, 00, 0b, 09, 00, 0c, 00, 1e, 01, 01, 0d, 00, 0e, 01, 01, 05, 00, 0b, 0d, 00, 0c, 00, 1e, 01, 01, 05, 02, 06, 01, 03, 05, 00, 0b, 11, 00, 0c, 00, 1e, 01, 01, 01, 00, 02]
|
||||
Raw bytes (45): 0x[01, 01, 00, 08, 01, 9a, 01, 01, 00, 0b, 01, 01, 05, 00, 0b, 01, 01, 05, 00, 0b, 01, 01, 0d, 00, 0e, 01, 01, 05, 00, 0b, 01, 01, 05, 02, 06, 01, 03, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/issue-84561.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 12
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 154, 1) to (start + 0, 11)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 11)
|
||||
- Code(Counter(1)) at (prev + 0, 12) to (start + 0, 30)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 11)
|
||||
- Code(Counter(2)) at (prev + 0, 12) to (start + 0, 30)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 11)
|
||||
- Code(Counter(3)) at (prev + 0, 12) to (start + 0, 30)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 2, 6)
|
||||
- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 11)
|
||||
- Code(Counter(4)) at (prev + 0, 12) to (start + 0, 30)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c4
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: issue_84561::test2
|
||||
Raw bytes (25): 0x[01, 01, 00, 04, 01, b0, 01, 01, 00, 0b, 01, 01, 05, 00, 10, 05, 00, 11, 00, 23, 01, 01, 01, 00, 02]
|
||||
Raw bytes (20): 0x[01, 01, 00, 03, 01, b0, 01, 01, 00, 0b, 01, 01, 05, 00, 10, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/issue-84561.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 176, 1) to (start + 0, 11)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 16)
|
||||
- Code(Counter(1)) at (prev + 0, 17) to (start + 0, 35)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: issue_84561::test2::call_print
|
||||
Raw bytes (25): 0x[01, 01, 00, 04, 01, a7, 01, 09, 00, 1f, 01, 01, 0d, 00, 13, 01, 00, 14, 00, 18, 01, 01, 09, 00, 0a]
|
||||
Raw bytes (20): 0x[01, 01, 00, 03, 01, a7, 01, 09, 00, 1f, 01, 01, 0d, 00, 13, 01, 01, 09, 00, 0a]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/issue-84561.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 167, 9) to (start + 0, 31)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 19)
|
||||
- Code(Counter(0)) at (prev + 0, 20) to (start + 0, 24)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 10)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: issue_84561::test3
|
||||
Raw bytes (409): 0x[01, 01, 0a, 01, 05, 01, 09, 01, 0d, 11, 15, 1d, 21, 19, 1d, 19, 1d, 19, 1d, 27, 25, 1d, 21, 4d, 01, 08, 01, 00, 0b, 01, 01, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 02, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 00, 00, 20, 00, 30, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 02, 05, 00, 0f, 00, 00, 20, 00, 24, 00, 00, 29, 00, 30, 00, 00, 33, 00, 41, 00, 00, 4b, 00, 5a, 01, 01, 05, 00, 0f, 00, 05, 09, 00, 0d, 00, 03, 09, 00, 10, 00, 02, 0d, 00, 1b, 00, 02, 0d, 00, 1c, 01, 04, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 02, 05, 00, 0f, 01, 04, 05, 00, 0f, 01, 04, 05, 00, 0f, 01, 04, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 04, 08, 00, 0f, 05, 01, 09, 00, 13, 02, 05, 09, 00, 13, 01, 05, 08, 00, 0f, 09, 01, 09, 00, 13, 00, 03, 0d, 00, 1d, 06, 03, 09, 00, 13, 00, 03, 0d, 00, 1d, 01, 03, 05, 00, 0f, 01, 01, 0c, 00, 13, 0d, 01, 0d, 00, 13, 0a, 02, 0d, 00, 13, 11, 04, 05, 00, 0f, 11, 02, 0c, 00, 13, 15, 01, 0d, 00, 13, 0e, 02, 0d, 00, 13, 27, 03, 05, 00, 0f, 19, 01, 0c, 00, 13, 1d, 01, 0d, 00, 17, 1d, 04, 0d, 00, 13, 1e, 02, 0d, 00, 17, 1e, 01, 14, 00, 1b, 00, 01, 15, 00, 1b, 1e, 02, 15, 00, 1b, 21, 04, 0d, 00, 13, 22, 03, 09, 00, 19, 25, 02, 05, 00, 0f, 25, 03, 09, 00, 22, 00, 02, 05, 00, 0f, 00, 03, 09, 00, 2c, 00, 02, 01, 00, 02]
|
||||
Raw bytes (340): 0x[01, 01, 08, 01, 05, 01, 09, 01, 0d, 11, 15, 1d, 21, 19, 1d, 19, 1d, 19, 1d, 40, 01, 08, 01, 00, 0b, 01, 01, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0d, 01, 02, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0f, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0d, 01, 02, 05, 00, 0f, 00, 00, 29, 00, 30, 00, 00, 33, 00, 41, 00, 00, 4b, 00, 5a, 01, 01, 05, 00, 0f, 00, 08, 09, 00, 10, 00, 02, 0d, 00, 1b, 00, 02, 0d, 00, 1c, 01, 04, 09, 00, 10, 01, 00, 13, 00, 2e, 01, 02, 05, 00, 0f, 01, 04, 05, 00, 0f, 01, 04, 05, 00, 0f, 01, 04, 09, 00, 0c, 01, 00, 0f, 00, 15, 01, 01, 05, 00, 0f, 01, 04, 08, 00, 0f, 05, 01, 09, 00, 13, 02, 05, 09, 00, 13, 01, 05, 08, 00, 0f, 09, 01, 09, 00, 13, 06, 06, 09, 00, 13, 01, 06, 05, 00, 0f, 01, 01, 0c, 00, 13, 0d, 01, 0d, 00, 13, 0a, 02, 0d, 00, 13, 11, 04, 05, 00, 0f, 11, 02, 0c, 00, 13, 15, 01, 0d, 00, 13, 0e, 02, 0d, 00, 13, 13, 03, 05, 00, 0f, 19, 01, 0c, 00, 13, 1d, 01, 0d, 00, 17, 1d, 04, 0d, 00, 13, 1e, 02, 0d, 00, 17, 1e, 01, 14, 00, 1b, 00, 01, 15, 00, 1b, 1e, 02, 15, 00, 1b, 21, 04, 0d, 00, 13, 25, 05, 05, 00, 0f, 00, 05, 05, 00, 0f, 00, 05, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/issue-84561.rs
|
||||
Number of expressions: 10
|
||||
Number of expressions: 8
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
- expression 1 operands: lhs = Counter(0), rhs = Counter(2)
|
||||
- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
|
||||
|
|
@ -85,9 +78,7 @@ Number of expressions: 10
|
|||
- expression 5 operands: lhs = Counter(6), rhs = Counter(7)
|
||||
- expression 6 operands: lhs = Counter(6), rhs = Counter(7)
|
||||
- expression 7 operands: lhs = Counter(6), rhs = Counter(7)
|
||||
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(9)
|
||||
- expression 9 operands: lhs = Counter(7), rhs = Counter(8)
|
||||
Number of file 0 mappings: 77
|
||||
Number of file 0 mappings: 64
|
||||
- Code(Counter(0)) at (prev + 8, 1) to (start + 0, 11)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 0, 19) to (start + 0, 46)
|
||||
|
|
@ -98,11 +89,8 @@ Number of file 0 mappings: 77
|
|||
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
|
|
@ -111,19 +99,14 @@ Number of file 0 mappings: 77
|
|||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 0, 32) to (start + 0, 48)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 0, 32) to (start + 0, 36)
|
||||
- Code(Zero) at (prev + 0, 41) to (start + 0, 48)
|
||||
- Code(Zero) at (prev + 0, 51) to (start + 0, 65)
|
||||
- Code(Zero) at (prev + 0, 75) to (start + 0, 90)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 5, 9) to (start + 0, 13)
|
||||
- Code(Zero) at (prev + 3, 9) to (start + 0, 16)
|
||||
- Code(Zero) at (prev + 8, 9) to (start + 0, 16)
|
||||
- Code(Zero) at (prev + 2, 13) to (start + 0, 27)
|
||||
- Code(Zero) at (prev + 2, 13) to (start + 0, 28)
|
||||
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 16)
|
||||
|
|
@ -140,11 +123,9 @@ Number of file 0 mappings: 77
|
|||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 5, 8) to (start + 0, 15)
|
||||
- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 19)
|
||||
- Code(Zero) at (prev + 3, 13) to (start + 0, 29)
|
||||
- Code(Expression(1, Sub)) at (prev + 3, 9) to (start + 0, 19)
|
||||
- Code(Expression(1, Sub)) at (prev + 6, 9) to (start + 0, 19)
|
||||
= (c0 - c2)
|
||||
- Code(Zero) at (prev + 3, 13) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 3, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 6, 5) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 1, 12) to (start + 0, 19)
|
||||
- Code(Counter(3)) at (prev + 1, 13) to (start + 0, 19)
|
||||
- Code(Expression(2, Sub)) at (prev + 2, 13) to (start + 0, 19)
|
||||
|
|
@ -154,7 +135,7 @@ Number of file 0 mappings: 77
|
|||
- Code(Counter(5)) at (prev + 1, 13) to (start + 0, 19)
|
||||
- Code(Expression(3, Sub)) at (prev + 2, 13) to (start + 0, 19)
|
||||
= (c4 - c5)
|
||||
- Code(Expression(9, Add)) at (prev + 3, 5) to (start + 0, 15)
|
||||
- Code(Expression(4, Add)) at (prev + 3, 5) to (start + 0, 15)
|
||||
= (c7 + c8)
|
||||
- Code(Counter(6)) at (prev + 1, 12) to (start + 0, 19)
|
||||
- Code(Counter(7)) at (prev + 1, 13) to (start + 0, 23)
|
||||
|
|
@ -167,12 +148,8 @@ Number of file 0 mappings: 77
|
|||
- Code(Expression(7, Sub)) at (prev + 2, 21) to (start + 0, 27)
|
||||
= (c6 - c7)
|
||||
- Code(Counter(8)) at (prev + 4, 13) to (start + 0, 19)
|
||||
- Code(Expression(8, Sub)) at (prev + 3, 9) to (start + 0, 25)
|
||||
= ((c7 + c8) - c9)
|
||||
- Code(Counter(9)) at (prev + 2, 5) to (start + 0, 15)
|
||||
- Code(Counter(9)) at (prev + 3, 9) to (start + 0, 34)
|
||||
- Code(Zero) at (prev + 2, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 3, 9) to (start + 0, 44)
|
||||
- Code(Zero) at (prev + 2, 1) to (start + 0, 2)
|
||||
- Code(Counter(9)) at (prev + 5, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 5, 5) to (start + 0, 15)
|
||||
- Code(Zero) at (prev + 5, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c9
|
||||
|
||||
|
|
|
|||
|
|
@ -22,18 +22,17 @@
|
|||
LL| 1| assert_ne!(bar, Foo(3));
|
||||
LL| 1| assert_ne!(Foo(0), Foo(4));
|
||||
LL| 1| assert_eq!(Foo(3), Foo(3), "with a message");
|
||||
^0
|
||||
LL| 1| println!("{:?}", bar);
|
||||
LL| 1| println!("{:?}", Foo(1));
|
||||
LL| |
|
||||
LL| 1| assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" });
|
||||
^0 ^0 ^0 ^0
|
||||
^0 ^0 ^0
|
||||
LL| 1| assert_ne!(
|
||||
LL| | Foo(0)
|
||||
LL| | ,
|
||||
LL| | Foo(5)
|
||||
LL| | ,
|
||||
LL| 0| "{}"
|
||||
LL| | "{}"
|
||||
LL| | ,
|
||||
LL| | if
|
||||
LL| 0| is_true
|
||||
|
|
@ -78,13 +77,13 @@
|
|||
LL| 1| assert_ne!(
|
||||
LL| | Foo(0),
|
||||
LL| | Foo(4),
|
||||
LL| 0| "with a message"
|
||||
LL| | "with a message"
|
||||
LL| | );
|
||||
LL| | } else {
|
||||
LL| 0| assert_eq!(
|
||||
LL| | Foo(3),
|
||||
LL| | Foo(3),
|
||||
LL| 0| "with a message"
|
||||
LL| | "with a message"
|
||||
LL| | );
|
||||
LL| | }
|
||||
LL| 1| assert_ne!(
|
||||
|
|
@ -122,17 +121,17 @@
|
|||
LL| 0| Foo(1)
|
||||
LL| | },
|
||||
LL| | Foo(5),
|
||||
LL| 0| "with a message"
|
||||
LL| | "with a message"
|
||||
LL| | );
|
||||
LL| 1| assert_eq!(
|
||||
LL| | Foo(1),
|
||||
LL| | Foo(3),
|
||||
LL| 1| "this assert should fail"
|
||||
LL| | "this assert should fail"
|
||||
LL| | );
|
||||
LL| 0| assert_eq!(
|
||||
LL| | Foo(3),
|
||||
LL| | Foo(3),
|
||||
LL| 0| "this assert should not be reached"
|
||||
LL| | "this assert should not be reached"
|
||||
LL| | );
|
||||
LL| 0|}
|
||||
LL| |
|
||||
|
|
@ -156,12 +155,9 @@
|
|||
LL| |
|
||||
LL| 1|fn test1() {
|
||||
LL| 1| debug!("debug is enabled");
|
||||
^0
|
||||
LL| 1| debug!("debug is enabled");
|
||||
^0
|
||||
LL| 1| let _ = 0;
|
||||
LL| 1| debug!("debug is enabled");
|
||||
^0
|
||||
LL| 1| unsafe {
|
||||
LL| 1| DEBUG_LEVEL_ENABLED = true;
|
||||
LL| 1| }
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
Function name: <loops_branches::DebugTest as core::fmt::Debug>::fmt
|
||||
Raw bytes (139): 0x[01, 01, 05, 01, 05, 0b, 0f, 01, 09, 05, 0d, 0d, 09, 19, 01, 09, 05, 00, 43, 01, 01, 0c, 00, 10, 01, 01, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 01, 01, 0d, 00, 0e, 01, 01, 0d, 00, 13, 01, 00, 14, 00, 15, 01, 00, 17, 00, 1d, 05, 00, 1e, 00, 1f, 00, 01, 10, 01, 0a, 09, 03, 0d, 00, 0e, 02, 00, 12, 00, 17, 09, 01, 10, 00, 14, 09, 01, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 09, 01, 11, 00, 12, 09, 01, 11, 00, 17, 09, 00, 18, 00, 19, 09, 00, 1b, 00, 21, 06, 00, 22, 00, 23, 00, 01, 14, 01, 0e, 12, 03, 09, 00, 0f, 01, 01, 05, 00, 06]
|
||||
Raw bytes (129): 0x[01, 01, 05, 01, 05, 0b, 0f, 01, 09, 05, 0d, 0d, 09, 17, 01, 09, 05, 00, 43, 01, 01, 0c, 00, 10, 01, 01, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 01, 01, 0d, 00, 0e, 01, 01, 0d, 00, 13, 01, 00, 14, 00, 15, 05, 00, 1e, 00, 1f, 00, 01, 10, 01, 0a, 09, 03, 0d, 00, 0e, 02, 00, 12, 00, 17, 09, 01, 10, 00, 14, 09, 01, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 09, 01, 11, 00, 12, 09, 01, 11, 00, 17, 09, 00, 18, 00, 19, 06, 00, 22, 00, 23, 00, 01, 14, 01, 0e, 12, 03, 09, 00, 0f, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/loops_branches.rs
|
||||
Number of expressions: 5
|
||||
|
|
@ -8,7 +8,7 @@ Number of expressions: 5
|
|||
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
|
||||
- expression 3 operands: lhs = Counter(1), rhs = Counter(3)
|
||||
- expression 4 operands: lhs = Counter(3), rhs = Counter(2)
|
||||
Number of file 0 mappings: 25
|
||||
Number of file 0 mappings: 23
|
||||
- Code(Counter(0)) at (prev + 9, 5) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 12) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 1, 16) to (start + 0, 21)
|
||||
|
|
@ -17,7 +17,6 @@ Number of file 0 mappings: 25
|
|||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 19)
|
||||
- Code(Counter(0)) at (prev + 0, 20) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 0, 23) to (start + 0, 29)
|
||||
- Code(Counter(1)) at (prev + 0, 30) to (start + 0, 31)
|
||||
- Code(Zero) at (prev + 1, 16) to (start + 1, 10)
|
||||
- Code(Counter(2)) at (prev + 3, 13) to (start + 0, 14)
|
||||
|
|
@ -30,7 +29,6 @@ Number of file 0 mappings: 25
|
|||
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 18)
|
||||
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 23)
|
||||
- Code(Counter(2)) at (prev + 0, 24) to (start + 0, 25)
|
||||
- Code(Counter(2)) at (prev + 0, 27) to (start + 0, 33)
|
||||
- Code(Expression(1, Sub)) at (prev + 0, 34) to (start + 0, 35)
|
||||
= ((c0 + c2) - (c1 + c3))
|
||||
- Code(Zero) at (prev + 1, 20) to (start + 1, 14)
|
||||
|
|
@ -40,7 +38,7 @@ Number of file 0 mappings: 25
|
|||
Highest counter ID seen: c2
|
||||
|
||||
Function name: <loops_branches::DisplayTest as core::fmt::Display>::fmt
|
||||
Raw bytes (139): 0x[01, 01, 05, 01, 05, 0b, 0f, 01, 09, 0d, 05, 0d, 09, 19, 01, 22, 05, 00, 43, 01, 01, 0c, 00, 11, 00, 00, 12, 01, 0a, 01, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 01, 01, 0d, 00, 0e, 01, 01, 0d, 00, 13, 01, 00, 14, 00, 15, 01, 00, 17, 00, 1d, 05, 00, 1e, 00, 1f, 09, 02, 0d, 00, 0e, 02, 00, 12, 00, 17, 09, 01, 10, 00, 15, 00, 00, 16, 01, 0e, 09, 02, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 09, 01, 11, 00, 12, 09, 01, 11, 00, 17, 09, 00, 18, 00, 19, 09, 00, 1b, 00, 21, 06, 00, 22, 00, 23, 12, 03, 09, 00, 0f, 01, 01, 05, 00, 06]
|
||||
Raw bytes (129): 0x[01, 01, 05, 01, 05, 0b, 0f, 01, 09, 0d, 05, 0d, 09, 17, 01, 22, 05, 00, 43, 01, 01, 0c, 00, 11, 00, 00, 12, 01, 0a, 01, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 01, 01, 0d, 00, 0e, 01, 01, 0d, 00, 13, 01, 00, 14, 00, 15, 05, 00, 1e, 00, 1f, 09, 02, 0d, 00, 0e, 02, 00, 12, 00, 17, 09, 01, 10, 00, 15, 00, 00, 16, 01, 0e, 09, 02, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 09, 01, 11, 00, 12, 09, 01, 11, 00, 17, 09, 00, 18, 00, 19, 06, 00, 22, 00, 23, 12, 03, 09, 00, 0f, 01, 01, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/loops_branches.rs
|
||||
Number of expressions: 5
|
||||
|
|
@ -49,7 +47,7 @@ Number of expressions: 5
|
|||
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
|
||||
- expression 3 operands: lhs = Counter(3), rhs = Counter(1)
|
||||
- expression 4 operands: lhs = Counter(3), rhs = Counter(2)
|
||||
Number of file 0 mappings: 25
|
||||
Number of file 0 mappings: 23
|
||||
- Code(Counter(0)) at (prev + 34, 5) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 12) to (start + 0, 17)
|
||||
- Code(Zero) at (prev + 0, 18) to (start + 1, 10)
|
||||
|
|
@ -59,7 +57,6 @@ Number of file 0 mappings: 25
|
|||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 1, 13) to (start + 0, 19)
|
||||
- Code(Counter(0)) at (prev + 0, 20) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 0, 23) to (start + 0, 29)
|
||||
- Code(Counter(1)) at (prev + 0, 30) to (start + 0, 31)
|
||||
- Code(Counter(2)) at (prev + 2, 13) to (start + 0, 14)
|
||||
- Code(Expression(0, Sub)) at (prev + 0, 18) to (start + 0, 23)
|
||||
|
|
@ -72,7 +69,6 @@ Number of file 0 mappings: 25
|
|||
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 18)
|
||||
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 23)
|
||||
- Code(Counter(2)) at (prev + 0, 24) to (start + 0, 25)
|
||||
- Code(Counter(2)) at (prev + 0, 27) to (start + 0, 33)
|
||||
- Code(Expression(1, Sub)) at (prev + 0, 34) to (start + 0, 35)
|
||||
= ((c0 + c2) - (c3 + c1))
|
||||
- Code(Expression(4, Sub)) at (prev + 3, 9) to (start + 0, 15)
|
||||
|
|
@ -81,20 +77,18 @@ Number of file 0 mappings: 25
|
|||
Highest counter ID seen: c2
|
||||
|
||||
Function name: loops_branches::main
|
||||
Raw bytes (54): 0x[01, 01, 00, 0a, 01, 37, 01, 00, 0a, 01, 01, 09, 00, 13, 01, 00, 16, 00, 1f, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 14, 01, 01, 09, 00, 15, 01, 00, 18, 00, 23, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 12, 01, 01, 01, 00, 02]
|
||||
Raw bytes (44): 0x[01, 01, 00, 08, 01, 37, 01, 00, 0a, 01, 01, 09, 00, 13, 01, 00, 16, 00, 1f, 01, 01, 05, 00, 0d, 01, 01, 09, 00, 15, 01, 00, 18, 00, 23, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/loops_branches.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 10
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 55, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 19)
|
||||
- Code(Counter(0)) at (prev + 0, 22) to (start + 0, 31)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 0, 24) to (start + 0, 35)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 18)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,22 +1,20 @@
|
|||
Function name: macro_in_closure::NO_BLOCK::{closure#0}
|
||||
Raw bytes (14): 0x[01, 01, 00, 02, 01, 07, 1c, 00, 24, 01, 00, 25, 00, 2c]
|
||||
Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 1c, 00, 24]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/macro_in_closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 2
|
||||
Number of file 0 mappings: 1
|
||||
- Code(Counter(0)) at (prev + 7, 28) to (start + 0, 36)
|
||||
- Code(Counter(0)) at (prev + 0, 37) to (start + 0, 44)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: macro_in_closure::WITH_BLOCK::{closure#0}
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 09, 1e, 00, 1f, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 15, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 09, 1e, 00, 1f, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/macro_in_closure.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 9, 30) to (start + 0, 31)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 21)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,36 +1,33 @@
|
|||
Function name: no_cov_crate::add_coverage_1
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 16, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 22, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 16, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/no_cov_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 34)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: no_cov_crate::add_coverage_2
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 1a, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 22, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 1a, 01, 00, 14, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/no_cov_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 26, 1) to (start + 0, 20)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 34)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: no_cov_crate::add_coverage_not_called (unused)
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 00, 1f, 01, 00, 1d, 00, 01, 05, 00, 0d, 00, 00, 0e, 00, 26, 00, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 00, 1f, 01, 00, 1d, 00, 01, 05, 00, 0d, 00, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/no_cov_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 31, 1) to (start + 0, 29)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Zero) at (prev + 0, 14) to (start + 0, 38)
|
||||
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
|
|
@ -57,28 +54,26 @@ Number of file 0 mappings: 14
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: no_cov_crate::nested_fns::outer
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 33, 05, 00, 20, 01, 01, 09, 00, 11, 01, 00, 12, 00, 26, 01, 01, 09, 00, 1a, 01, 00, 1b, 00, 22, 01, 0a, 05, 00, 06]
|
||||
Raw bytes (29): 0x[01, 01, 00, 05, 01, 33, 05, 00, 20, 01, 01, 09, 00, 11, 01, 01, 09, 00, 1a, 01, 00, 1b, 00, 22, 01, 0a, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/no_cov_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 5
|
||||
- Code(Counter(0)) at (prev + 51, 5) to (start + 0, 32)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 26)
|
||||
- Code(Counter(0)) at (prev + 0, 27) to (start + 0, 34)
|
||||
- Code(Counter(0)) at (prev + 10, 5) to (start + 0, 6)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: no_cov_crate::nested_fns::outer_both_covered
|
||||
Raw bytes (34): 0x[01, 01, 00, 06, 01, 41, 05, 00, 2d, 01, 01, 09, 00, 11, 01, 00, 12, 00, 26, 01, 01, 09, 00, 0e, 01, 00, 0f, 00, 16, 01, 09, 05, 00, 06]
|
||||
Raw bytes (29): 0x[01, 01, 00, 05, 01, 41, 05, 00, 2d, 01, 01, 09, 00, 11, 01, 01, 09, 00, 0e, 01, 00, 0f, 00, 16, 01, 09, 05, 00, 06]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/no_cov_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 5
|
||||
- Code(Counter(0)) at (prev + 65, 5) to (start + 0, 45)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 14)
|
||||
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 9, 5) to (start + 0, 6)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
Function name: overflow::main
|
||||
Raw bytes (96): 0x[01, 01, 06, 05, 01, 05, 17, 01, 09, 05, 13, 17, 0d, 01, 09, 10, 01, 10, 01, 00, 1c, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1b, 05, 01, 0b, 00, 18, 02, 01, 0c, 00, 1a, 09, 00, 1b, 03, 0a, 09, 01, 11, 00, 17, 09, 00, 1a, 00, 28, 06, 02, 13, 00, 20, 0d, 00, 21, 03, 0a, 0d, 01, 11, 00, 17, 0d, 00, 1a, 00, 28, 0e, 02, 09, 00, 0a, 02, 01, 09, 00, 17, 01, 02, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (86): 0x[01, 01, 06, 05, 01, 05, 17, 01, 09, 05, 13, 17, 0d, 01, 09, 0e, 01, 10, 01, 00, 1c, 01, 01, 09, 00, 16, 01, 00, 19, 00, 1b, 05, 01, 0b, 00, 18, 02, 01, 0c, 00, 1a, 09, 00, 1b, 03, 0a, 09, 01, 11, 00, 17, 06, 02, 13, 00, 20, 0d, 00, 21, 03, 0a, 0d, 01, 11, 00, 17, 0e, 02, 09, 00, 0a, 02, 01, 09, 00, 17, 01, 02, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/overflow.rs
|
||||
Number of expressions: 6
|
||||
|
|
@ -9,7 +9,7 @@ Number of expressions: 6
|
|||
- expression 3 operands: lhs = Counter(1), rhs = Expression(4, Add)
|
||||
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
|
||||
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
|
||||
Number of file 0 mappings: 16
|
||||
Number of file 0 mappings: 14
|
||||
- Code(Counter(0)) at (prev + 16, 1) to (start + 0, 28)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 0, 25) to (start + 0, 27)
|
||||
|
|
@ -18,12 +18,10 @@ Number of file 0 mappings: 16
|
|||
= (c1 - c0)
|
||||
- Code(Counter(2)) at (prev + 0, 27) to (start + 3, 10)
|
||||
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 23)
|
||||
- Code(Counter(2)) at (prev + 0, 26) to (start + 0, 40)
|
||||
- Code(Expression(1, Sub)) at (prev + 2, 19) to (start + 0, 32)
|
||||
= (c1 - (c0 + c2))
|
||||
- Code(Counter(3)) at (prev + 0, 33) to (start + 3, 10)
|
||||
- Code(Counter(3)) at (prev + 1, 17) to (start + 0, 23)
|
||||
- Code(Counter(3)) at (prev + 0, 26) to (start + 0, 40)
|
||||
- Code(Expression(3, Sub)) at (prev + 2, 9) to (start + 0, 10)
|
||||
= (c1 - ((c0 + c2) + c3))
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 23)
|
||||
|
|
@ -33,12 +31,12 @@ Number of file 0 mappings: 16
|
|||
Highest counter ID seen: c3
|
||||
|
||||
Function name: overflow::might_overflow
|
||||
Raw bytes (76): 0x[01, 01, 01, 01, 05, 0e, 01, 05, 01, 00, 26, 01, 01, 08, 00, 12, 05, 00, 13, 02, 06, 02, 02, 05, 00, 06, 01, 01, 09, 00, 0f, 01, 00, 12, 00, 1e, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 26, 01, 01, 09, 00, 0f, 01, 00, 12, 00, 21, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 2f, 01, 01, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Raw bytes (66): 0x[01, 01, 01, 01, 05, 0c, 01, 05, 01, 00, 26, 01, 01, 08, 00, 12, 05, 00, 13, 02, 06, 02, 02, 05, 00, 06, 01, 01, 09, 00, 0f, 01, 00, 12, 00, 1e, 01, 01, 05, 00, 0d, 01, 01, 09, 00, 0f, 01, 00, 12, 00, 21, 01, 01, 05, 00, 0d, 01, 01, 05, 00, 0b, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/overflow.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 14
|
||||
Number of file 0 mappings: 12
|
||||
- Code(Counter(0)) at (prev + 5, 1) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 18)
|
||||
- Code(Counter(1)) at (prev + 0, 19) to (start + 2, 6)
|
||||
|
|
@ -47,11 +45,9 @@ Number of file 0 mappings: 14
|
|||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 30)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 15)
|
||||
- Code(Counter(0)) at (prev + 0, 18) to (start + 0, 33)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 47)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 11)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
|
|
|
|||
|
|
@ -29,16 +29,15 @@ Number of file 0 mappings: 12
|
|||
Highest counter ID seen: c3
|
||||
|
||||
Function name: panic_unwind::might_panic
|
||||
Raw bytes (41): 0x[01, 01, 01, 01, 05, 07, 01, 04, 01, 00, 23, 01, 01, 08, 00, 14, 05, 01, 09, 00, 11, 05, 00, 12, 00, 20, 05, 01, 09, 00, 0f, 02, 01, 0c, 02, 06, 02, 03, 01, 00, 02]
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 04, 01, 00, 23, 01, 01, 08, 00, 14, 05, 01, 09, 00, 11, 05, 01, 09, 00, 0f, 02, 01, 0c, 02, 06, 02, 03, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/panic_unwind.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 7
|
||||
Number of file 0 mappings: 6
|
||||
- Code(Counter(0)) at (prev + 4, 1) to (start + 0, 35)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 20)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 32)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 15)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 12) to (start + 2, 6)
|
||||
= (c0 - c1)
|
||||
|
|
|
|||
|
|
@ -11,19 +11,18 @@ Number of file 0 mappings: 4
|
|||
Highest counter ID seen: c0
|
||||
|
||||
Function name: partial_eq::main
|
||||
Raw bytes (49): 0x[01, 01, 00, 09, 01, 11, 01, 00, 0a, 01, 01, 09, 00, 16, 01, 00, 19, 00, 25, 01, 01, 09, 00, 16, 01, 00, 19, 00, 25, 01, 02, 05, 00, 0d, 01, 01, 09, 00, 1b, 01, 03, 09, 00, 26, 01, 02, 01, 00, 02]
|
||||
Raw bytes (44): 0x[01, 01, 00, 08, 01, 11, 01, 00, 0a, 01, 01, 09, 00, 16, 01, 00, 19, 00, 25, 01, 01, 09, 00, 16, 01, 00, 19, 00, 25, 01, 02, 05, 00, 0d, 01, 04, 09, 00, 26, 01, 02, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/partial_eq.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 9
|
||||
Number of file 0 mappings: 8
|
||||
- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 0, 25) to (start + 0, 37)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 22)
|
||||
- Code(Counter(0)) at (prev + 0, 25) to (start + 0, 37)
|
||||
- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 27)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 38)
|
||||
- Code(Counter(0)) at (prev + 2, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
LL| 1| let version_3_3_0 = Version::new(3, 3, 0);
|
||||
LL| |
|
||||
LL| 1| println!(
|
||||
LL| 1| "{:?} < {:?} = {}",
|
||||
LL| | "{:?} < {:?} = {}",
|
||||
LL| | version_3_2_1,
|
||||
LL| | version_3_3_0,
|
||||
LL| 1| version_3_2_1 < version_3_3_0, //
|
||||
|
|
|
|||
|
|
@ -1,12 +1,11 @@
|
|||
Function name: rustfmt_skip::main
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 0a, 01, 00, 0a, 01, 02, 05, 00, 0d, 01, 03, 09, 00, 10, 01, 02, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 0a, 01, 00, 0a, 01, 02, 05, 00, 0d, 01, 05, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/rustfmt-skip.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 10, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 2, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 16)
|
||||
- Code(Counter(0)) at (prev + 2, 1) to (start + 0, 2)
|
||||
- Code(Counter(0)) at (prev + 5, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
LL| 1| println!(
|
||||
LL| | // Keep this on a separate line, to distinguish instrumentation of
|
||||
LL| | // `println!` from instrumentation of its arguments.
|
||||
LL| 1| "hello"
|
||||
LL| | "hello"
|
||||
LL| | );
|
||||
LL| 1|}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,63 +1,59 @@
|
|||
Function name: sort_groups::generic_fn::<&str>
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 05, 01, 09, 00, 11, 02, 01, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Raw bytes (31): 0x[01, 01, 01, 01, 05, 05, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 02, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/sort_groups.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 5
|
||||
- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 12)
|
||||
- Code(Counter(1)) at (prev + 0, 13) to (start + 2, 6)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 6)
|
||||
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
Function name: sort_groups::generic_fn::<()>
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 05, 01, 09, 00, 11, 02, 01, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Raw bytes (31): 0x[01, 01, 01, 01, 05, 05, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 02, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/sort_groups.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 5
|
||||
- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 12)
|
||||
- Code(Counter(1)) at (prev + 0, 13) to (start + 2, 6)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 6)
|
||||
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
Function name: sort_groups::generic_fn::<char>
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 05, 01, 09, 00, 11, 02, 01, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Raw bytes (31): 0x[01, 01, 01, 01, 05, 05, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 02, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/sort_groups.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 5
|
||||
- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 12)
|
||||
- Code(Counter(1)) at (prev + 0, 13) to (start + 2, 6)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 6)
|
||||
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
|
||||
Function name: sort_groups::generic_fn::<i32>
|
||||
Raw bytes (36): 0x[01, 01, 01, 01, 05, 06, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 05, 01, 09, 00, 11, 02, 01, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Raw bytes (31): 0x[01, 01, 01, 01, 05, 05, 01, 11, 01, 00, 1d, 01, 01, 08, 00, 0c, 05, 00, 0d, 02, 06, 02, 02, 05, 00, 06, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/sort_groups.rs
|
||||
Number of expressions: 1
|
||||
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
|
||||
Number of file 0 mappings: 6
|
||||
Number of file 0 mappings: 5
|
||||
- Code(Counter(0)) at (prev + 17, 1) to (start + 0, 29)
|
||||
- Code(Counter(0)) at (prev + 1, 8) to (start + 0, 12)
|
||||
- Code(Counter(1)) at (prev + 0, 13) to (start + 2, 6)
|
||||
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 17)
|
||||
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 6)
|
||||
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
|
||||
= (c0 - c1)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c1
|
||||
|
|
|
|||
|
|
@ -1,24 +1,22 @@
|
|||
Function name: unused_mod::main
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 04, 01, 00, 0a, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 1c, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 04, 01, 00, 0a, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/unused_mod.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 4, 1) to (start + 0, 10)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 28)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: unused_mod::unused_module::never_called_function (unused)
|
||||
Raw bytes (24): 0x[01, 02, 00, 04, 00, 02, 01, 00, 1f, 00, 01, 05, 00, 0d, 00, 00, 0e, 00, 21, 00, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 02, 00, 03, 00, 02, 01, 00, 1f, 00, 01, 05, 00, 0d, 00, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/unused_mod_helper.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Zero) at (prev + 2, 1) to (start + 0, 31)
|
||||
- Code(Zero) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Zero) at (prev + 0, 14) to (start + 0, 33)
|
||||
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: (none)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,48 +1,44 @@
|
|||
Function name: used_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 1b, 01, 00, 4c, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 4f, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 1b, 01, 00, 4c, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 76)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 79)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 13, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 46, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 13, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 19, 1) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 70)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: used_crate::used_only_from_bin_crate_generic_function::<&str>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 13, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 46, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 13, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 19, 1) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 70)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 1f, 01, 00, 5b, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 5e, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 1f, 01, 00, 5b, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 31, 1) to (start + 0, 91)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 94)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -1,12 +1,11 @@
|
|||
Function name: used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 2c, 01, 00, 4c, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 4f, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 2c, 01, 00, 4c, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_inline_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 44, 1) to (start + 0, 76)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 79)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
@ -31,38 +30,35 @@ Number of file 0 mappings: 10
|
|||
Highest counter ID seen: c1
|
||||
|
||||
Function name: used_inline_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 21, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 46, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 21, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_inline_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 33, 1) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 70)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: used_inline_crate::used_only_from_bin_crate_generic_function::<&str>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 21, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 46, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 21, 01, 00, 43, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_inline_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 33, 1) to (start + 0, 67)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 70)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
Function name: used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>
|
||||
Raw bytes (24): 0x[01, 01, 00, 04, 01, 31, 01, 00, 5b, 01, 01, 05, 00, 0d, 01, 00, 0e, 00, 5e, 01, 01, 01, 00, 02]
|
||||
Raw bytes (19): 0x[01, 01, 00, 03, 01, 31, 01, 00, 5b, 01, 01, 05, 00, 0d, 01, 01, 01, 00, 02]
|
||||
Number of files: 1
|
||||
- file 0 => $DIR/auxiliary/used_inline_crate.rs
|
||||
Number of expressions: 0
|
||||
Number of file 0 mappings: 4
|
||||
Number of file 0 mappings: 3
|
||||
- Code(Counter(0)) at (prev + 49, 1) to (start + 0, 91)
|
||||
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 13)
|
||||
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 94)
|
||||
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
|
||||
Highest counter ID seen: c0
|
||||
|
||||
|
|
|
|||
|
|
@ -72,15 +72,9 @@ impl Foo {
|
|||
// This should affect the method itself, but not the impl.
|
||||
#[cfg(any(cfail1,cfail4))]
|
||||
impl Foo {
|
||||
//------------
|
||||
//---------------
|
||||
//----------------------------------------------------------------
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
//--------------------------
|
||||
//------------
|
||||
//---------------
|
||||
//----------------------------------------------------------------
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
//--------------------------
|
||||
#[inline]
|
||||
pub fn method_body_inlined() {
|
||||
|
|
@ -94,15 +88,9 @@ impl Foo {
|
|||
#[rustc_clean(cfg="cfail5")]
|
||||
#[rustc_clean(cfg="cfail6")]
|
||||
impl Foo {
|
||||
#[rustc_clean(
|
||||
cfg="cfail2",
|
||||
except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck"
|
||||
)]
|
||||
#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,optimized_mir,typeck")]
|
||||
#[rustc_clean(cfg="cfail3")]
|
||||
#[rustc_clean(
|
||||
cfg="cfail5",
|
||||
except="opt_hir_owner_nodes,optimized_mir,promoted_mir,typeck"
|
||||
)]
|
||||
#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,optimized_mir,typeck")]
|
||||
#[rustc_clean(cfg="cfail6")]
|
||||
#[inline]
|
||||
pub fn method_body_inlined() {
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ macro_rules! first_macro {
|
|||
}
|
||||
}
|
||||
|
||||
#[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir,promoted_mir", cfg="rpass2")]
|
||||
#[rustc_clean(except="opt_hir_owner_nodes,typeck,optimized_mir", cfg="rpass2")]
|
||||
#[inline(always)]
|
||||
pub fn changed_fn() {
|
||||
// This will cause additional hygiene to be generate,
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ pub mod x {
|
|||
}
|
||||
|
||||
#[cfg(cfail2)]
|
||||
#[rustc_clean(except = "opt_hir_owner_nodes,promoted_mir", cfg = "cfail2")]
|
||||
#[rustc_clean(except = "opt_hir_owner_nodes,optimized_mir", cfg = "cfail2")]
|
||||
pub fn x() {
|
||||
println!("{}", "2");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -209,9 +209,10 @@
|
|||
+ _27 = &(*_12);
|
||||
_26 = &(*_27);
|
||||
StorageLive(_28);
|
||||
_28 = Option::<Arguments<'_>>::None;
|
||||
- _28 = Option::<Arguments<'_>>::None;
|
||||
- _22 = assert_failed::<*const u8, *const u8>(move _23, move _24, move _26, move _28) -> unwind unreachable;
|
||||
+ _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, move _28) -> unwind unreachable;
|
||||
+ _28 = const Option::<Arguments<'_>>::None;
|
||||
+ _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, const Option::<Arguments<'_>>::None) -> unwind unreachable;
|
||||
}
|
||||
|
||||
bb7: {
|
||||
|
|
@ -311,11 +312,15 @@
|
|||
+ _53 = &(*_38);
|
||||
_52 = &(*_53);
|
||||
StorageLive(_54);
|
||||
_54 = Option::<Arguments<'_>>::None;
|
||||
- _54 = Option::<Arguments<'_>>::None;
|
||||
- _48 = assert_failed::<*const u8, *const u8>(move _49, move _50, move _52, move _54) -> unwind unreachable;
|
||||
+ _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, move _54) -> unwind unreachable;
|
||||
+ _54 = const Option::<Arguments<'_>>::None;
|
||||
+ _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, const Option::<Arguments<'_>>::None) -> unwind unreachable;
|
||||
}
|
||||
}
|
||||
|
||||
ALLOC0 (size: 18, align: 1) { .. }
|
||||
- ALLOC0 (size: 18, align: 1) { .. }
|
||||
+ ALLOC0 (size: 16, align: 8) { .. }
|
||||
+
|
||||
+ ALLOC1 (size: 18, align: 1) { .. }
|
||||
|
||||
|
|
|
|||
|
|
@ -209,9 +209,10 @@
|
|||
+ _27 = &(*_12);
|
||||
_26 = &(*_27);
|
||||
StorageLive(_28);
|
||||
_28 = Option::<Arguments<'_>>::None;
|
||||
- _28 = Option::<Arguments<'_>>::None;
|
||||
- _22 = assert_failed::<*const u8, *const u8>(move _23, move _24, move _26, move _28) -> unwind continue;
|
||||
+ _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, move _28) -> unwind continue;
|
||||
+ _28 = const Option::<Arguments<'_>>::None;
|
||||
+ _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, const Option::<Arguments<'_>>::None) -> unwind continue;
|
||||
}
|
||||
|
||||
bb7: {
|
||||
|
|
@ -311,11 +312,15 @@
|
|||
+ _53 = &(*_38);
|
||||
_52 = &(*_53);
|
||||
StorageLive(_54);
|
||||
_54 = Option::<Arguments<'_>>::None;
|
||||
- _54 = Option::<Arguments<'_>>::None;
|
||||
- _48 = assert_failed::<*const u8, *const u8>(move _49, move _50, move _52, move _54) -> unwind continue;
|
||||
+ _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, move _54) -> unwind continue;
|
||||
+ _54 = const Option::<Arguments<'_>>::None;
|
||||
+ _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, const Option::<Arguments<'_>>::None) -> unwind continue;
|
||||
}
|
||||
}
|
||||
|
||||
ALLOC0 (size: 18, align: 1) { .. }
|
||||
- ALLOC0 (size: 18, align: 1) { .. }
|
||||
+ ALLOC0 (size: 16, align: 8) { .. }
|
||||
+
|
||||
+ ALLOC1 (size: 18, align: 1) { .. }
|
||||
|
||||
|
|
|
|||
|
|
@ -164,7 +164,6 @@ fn array_casts() -> () {
|
|||
_31 = &(*_32);
|
||||
StorageLive(_33);
|
||||
_33 = Option::<Arguments<'_>>::None;
|
||||
Retag(_33);
|
||||
_27 = core::panicking::assert_failed::<usize, usize>(move _28, move _29, move _31, move _33) -> unwind unreachable;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -164,7 +164,6 @@ fn array_casts() -> () {
|
|||
_31 = &(*_32);
|
||||
StorageLive(_33);
|
||||
_33 = Option::<Arguments<'_>>::None;
|
||||
Retag(_33);
|
||||
_27 = core::panicking::assert_failed::<usize, usize>(move _28, move _29, move _31, move _33) -> unwind continue;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,23 +17,22 @@
|
|||
let mut _17: &std::boxed::Box<dyn std::fmt::Display>;
|
||||
let mut _18: core::fmt::rt::Argument<'_>;
|
||||
let mut _19: &u32;
|
||||
let mut _20: &[&str; 3];
|
||||
let _21: &[&str; 3];
|
||||
let _22: [&str; 3];
|
||||
let mut _23: &[core::fmt::rt::Argument<'_>; 2];
|
||||
let _24: &[core::fmt::rt::Argument<'_>; 2];
|
||||
let mut _26: &std::boxed::Box<dyn std::fmt::Display>;
|
||||
let mut _27: &u32;
|
||||
let mut _28: bool;
|
||||
let mut _20: &[u8; 7];
|
||||
let _21: &[u8; 7];
|
||||
let mut _22: &[core::fmt::rt::Argument<'_>; 2];
|
||||
let _23: &[core::fmt::rt::Argument<'_>; 2];
|
||||
let mut _24: &std::boxed::Box<dyn std::fmt::Display>;
|
||||
let mut _25: &u32;
|
||||
let mut _26: bool;
|
||||
let mut _27: isize;
|
||||
let mut _28: isize;
|
||||
let mut _29: isize;
|
||||
let mut _30: isize;
|
||||
let mut _31: isize;
|
||||
+ let _32: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>;
|
||||
+ let _33: u32;
|
||||
+ let _30: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>;
|
||||
+ let _31: u32;
|
||||
scope 1 {
|
||||
- debug foo => _1;
|
||||
+ debug ((foo: Foo<T>).0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>) => _32;
|
||||
+ debug ((foo: Foo<T>).1: u32) => _33;
|
||||
+ debug ((foo: Foo<T>).0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>) => _30;
|
||||
+ debug ((foo: Foo<T>).1: u32) => _31;
|
||||
let _5: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>;
|
||||
scope 2 {
|
||||
debug x => _5;
|
||||
|
|
@ -44,16 +43,15 @@
|
|||
debug x => _8;
|
||||
let _8: std::boxed::Box<dyn std::fmt::Display>;
|
||||
let _12: (&std::boxed::Box<dyn std::fmt::Display>, &u32);
|
||||
+ let _34: &std::boxed::Box<dyn std::fmt::Display>;
|
||||
+ let _35: &u32;
|
||||
+ let _32: &std::boxed::Box<dyn std::fmt::Display>;
|
||||
+ let _33: &u32;
|
||||
scope 5 {
|
||||
- debug args => _12;
|
||||
+ debug ((args: (&Box<dyn std::fmt::Display>, &u32)).0: &std::boxed::Box<dyn std::fmt::Display>) => _34;
|
||||
+ debug ((args: (&Box<dyn std::fmt::Display>, &u32)).1: &u32) => _35;
|
||||
+ debug ((args: (&Box<dyn std::fmt::Display>, &u32)).0: &std::boxed::Box<dyn std::fmt::Display>) => _32;
|
||||
+ debug ((args: (&Box<dyn std::fmt::Display>, &u32)).1: &u32) => _33;
|
||||
let _15: [core::fmt::rt::Argument<'_>; 2];
|
||||
scope 6 {
|
||||
debug args => _15;
|
||||
let mut _25: &[&str; 3];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -62,10 +60,10 @@
|
|||
}
|
||||
|
||||
bb0: {
|
||||
_28 = const false;
|
||||
_26 = const false;
|
||||
- StorageLive(_1);
|
||||
+ StorageLive(_32);
|
||||
+ StorageLive(_33);
|
||||
+ StorageLive(_30);
|
||||
+ StorageLive(_31);
|
||||
+ nop;
|
||||
StorageLive(_2);
|
||||
StorageLive(_3);
|
||||
|
|
@ -79,17 +77,17 @@
|
|||
_2 = Result::<Box<dyn std::fmt::Display>, <T as Err>::Err>::Ok(move _3);
|
||||
StorageDead(_3);
|
||||
- _1 = Foo::<T> { x: move _2, y: const 7_u32 };
|
||||
+ _32 = move _2;
|
||||
+ _33 = const 7_u32;
|
||||
+ _30 = move _2;
|
||||
+ _31 = const 7_u32;
|
||||
+ nop;
|
||||
StorageDead(_2);
|
||||
StorageLive(_5);
|
||||
_28 = const true;
|
||||
_26 = const true;
|
||||
- _5 = move (_1.0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>);
|
||||
+ _5 = move _32;
|
||||
+ _5 = move _30;
|
||||
StorageLive(_6);
|
||||
- _6 = copy (_1.1: u32);
|
||||
+ _6 = copy _33;
|
||||
+ _6 = copy _31;
|
||||
_7 = discriminant(_5);
|
||||
switchInt(move _7) -> [0: bb2, otherwise: bb7];
|
||||
}
|
||||
|
|
@ -101,25 +99,25 @@
|
|||
StorageLive(_10);
|
||||
StorageLive(_11);
|
||||
- StorageLive(_12);
|
||||
+ StorageLive(_34);
|
||||
+ StorageLive(_35);
|
||||
+ StorageLive(_32);
|
||||
+ StorageLive(_33);
|
||||
+ nop;
|
||||
StorageLive(_13);
|
||||
_13 = &_8;
|
||||
StorageLive(_14);
|
||||
_14 = &_6;
|
||||
- _12 = (move _13, move _14);
|
||||
+ _34 = move _13;
|
||||
+ _35 = move _14;
|
||||
+ _32 = move _13;
|
||||
+ _33 = move _14;
|
||||
+ nop;
|
||||
StorageDead(_14);
|
||||
StorageDead(_13);
|
||||
StorageLive(_15);
|
||||
StorageLive(_16);
|
||||
StorageLive(_17);
|
||||
- _26 = copy (_12.0: &std::boxed::Box<dyn std::fmt::Display>);
|
||||
+ _26 = copy _34;
|
||||
_17 = &(*_26);
|
||||
- _24 = copy (_12.0: &std::boxed::Box<dyn std::fmt::Display>);
|
||||
+ _24 = copy _32;
|
||||
_17 = &(*_24);
|
||||
_16 = core::fmt::rt::Argument::<'_>::new_display::<Box<dyn std::fmt::Display>>(move _17) -> [return: bb3, unwind unreachable];
|
||||
}
|
||||
|
||||
|
|
@ -127,9 +125,9 @@
|
|||
StorageDead(_17);
|
||||
StorageLive(_18);
|
||||
StorageLive(_19);
|
||||
- _27 = copy (_12.1: &u32);
|
||||
+ _27 = copy _35;
|
||||
_19 = &(*_27);
|
||||
- _25 = copy (_12.1: &u32);
|
||||
+ _25 = copy _33;
|
||||
_19 = &(*_25);
|
||||
_18 = core::fmt::rt::Argument::<'_>::new_display::<u32>(move _19) -> [return: bb4, unwind unreachable];
|
||||
}
|
||||
|
||||
|
|
@ -140,19 +138,18 @@
|
|||
StorageDead(_16);
|
||||
StorageLive(_20);
|
||||
StorageLive(_21);
|
||||
_25 = const foo::<T>::promoted[0];
|
||||
_21 = &(*_25);
|
||||
_21 = const b"\xc0\x01 \xc0\x01\n\x00";
|
||||
_20 = &(*_21);
|
||||
StorageLive(_22);
|
||||
StorageLive(_23);
|
||||
StorageLive(_24);
|
||||
_24 = &_15;
|
||||
_23 = &(*_24);
|
||||
_11 = core::fmt::rt::<impl Arguments<'_>>::new_v1::<3, 2>(move _20, move _23) -> [return: bb5, unwind unreachable];
|
||||
_23 = &_15;
|
||||
_22 = &(*_23);
|
||||
_11 = Arguments::<'_>::new::<7, 2>(move _20, move _22) -> [return: bb5, unwind unreachable];
|
||||
}
|
||||
|
||||
bb5: {
|
||||
StorageDead(_24);
|
||||
StorageDead(_23);
|
||||
StorageDead(_22);
|
||||
StorageDead(_21);
|
||||
StorageDead(_20);
|
||||
_10 = _eprint(move _11) -> [return: bb6, unwind unreachable];
|
||||
|
|
@ -162,8 +159,8 @@
|
|||
StorageDead(_11);
|
||||
StorageDead(_15);
|
||||
- StorageDead(_12);
|
||||
+ StorageDead(_34);
|
||||
+ StorageDead(_35);
|
||||
+ StorageDead(_32);
|
||||
+ StorageDead(_33);
|
||||
+ nop;
|
||||
StorageDead(_10);
|
||||
_9 = const ();
|
||||
|
|
@ -184,16 +181,16 @@
|
|||
|
||||
bb9: {
|
||||
StorageDead(_6);
|
||||
_29 = discriminant(_5);
|
||||
switchInt(move _29) -> [0: bb10, otherwise: bb11];
|
||||
_27 = discriminant(_5);
|
||||
switchInt(move _27) -> [0: bb10, otherwise: bb11];
|
||||
}
|
||||
|
||||
bb10: {
|
||||
_28 = const false;
|
||||
_26 = const false;
|
||||
StorageDead(_5);
|
||||
- StorageDead(_1);
|
||||
+ StorageDead(_32);
|
||||
+ StorageDead(_33);
|
||||
+ StorageDead(_30);
|
||||
+ StorageDead(_31);
|
||||
+ nop;
|
||||
return;
|
||||
}
|
||||
|
|
@ -203,3 +200,7 @@
|
|||
}
|
||||
}
|
||||
|
||||
ALLOC0 (size: 7, align: 1) {
|
||||
c0 01 20 c0 01 0a 00 │ .. ....
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -32,11 +32,10 @@ fn bar() ({
|
|||
((::alloc::__export::must_use as
|
||||
fn(String) -> String {must_use::<String>})(({
|
||||
((::alloc::fmt::format as
|
||||
for<'a> fn(Arguments<'a>) -> String {format})(((format_arguments::new_const
|
||||
for<'a> fn(Arguments<'a>) -> String {format})(((format_arguments::from_str
|
||||
as
|
||||
fn(&[&'static str; 1]) -> Arguments<'_> {core::fmt::rt::<impl Arguments<'_>>::new_const::<1>})((&([("test"
|
||||
as &str)] as [&str; 1]) as &[&str; 1])) as Arguments<'_>))
|
||||
as String)
|
||||
fn(&'static str) -> Arguments<'_> {Arguments::<'_>::from_str})(("test"
|
||||
as &str)) as Arguments<'_>)) as String)
|
||||
} as String)) as String);
|
||||
} as ())
|
||||
type Foo = [i32; (3 as usize)];
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ fn main() {
|
|||
}
|
||||
|
||||
let expected_prefix = adjust_symbol_prefix!("_RNxC12hashed_dylib");
|
||||
if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_prefix)).count() != 2 {
|
||||
if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_prefix)).count() != 1 {
|
||||
eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
|
||||
panic!("expected two dynamic symbols starting with `{expected_prefix}`");
|
||||
}
|
||||
|
|
@ -88,7 +88,7 @@ fn main() {
|
|||
}
|
||||
|
||||
let expected_rlib_prefix = adjust_symbol_prefix!("_RNxC11hashed_rlib");
|
||||
if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_rlib_prefix)).count() != 2 {
|
||||
if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_rlib_prefix)).count() != 1 {
|
||||
eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
|
||||
panic!("expected two exported symbols starting with `{expected_rlib_prefix}`");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ LL | println!("{}", Thing::<i32>::X);
|
|||
| ^^^^^^^^^^^^^^^
|
||||
|
|
||||
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "14"]` attribute to your crate (`recursive_const_in_impl`)
|
||||
= note: query depth increased by 9 when simplifying constant for the type system `main::promoted[1]`
|
||||
= note: query depth increased by 9 when simplifying constant for the type system `main::promoted[0]`
|
||||
= note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error: aborting due to 1 previous error
|
||||
|
|
|
|||
|
|
@ -390,11 +390,11 @@ mod expressions {
|
|||
/// ExprKind::FormatArgs
|
||||
fn expr_format_args() {
|
||||
let expr;
|
||||
format_arguments::new_const(&[]);
|
||||
format_arguments::from_str("");
|
||||
{
|
||||
super let args = (&expr,);
|
||||
super let args = [format_argument::new_display(args.0)];
|
||||
format_arguments::new_v1(&[""], &args)
|
||||
unsafe { format_arguments::new(b"\xc0\x00", &args) }
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,10 @@ fn main() {
|
|||
::std::io::_print({
|
||||
super let args = (&x,);
|
||||
super let args = [format_argument::new_display(args.0)];
|
||||
format_arguments::new_v1(&["a 123 b ", " xyz\n"], &args)
|
||||
unsafe {
|
||||
format_arguments::new(b"\x08a 123 b \xc0\x05 xyz\n\x00",
|
||||
&args)
|
||||
}
|
||||
});
|
||||
};
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue