diff --git a/.vscode/launch.json b/.vscode/launch.json
index dd5712aaa74f417d8f1129ab96732ac4423bdb3a..1d1e8e6eefab7d928121b7967dcbc58d0c04f139 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -9,12 +9,12 @@
"request": "attach",
"name": "Debug hello",
"gdbpath": "/usr/bin/arm-none-eabi-gdb",
+ "executable": "./target/thumbv7em-none-eabihf/debug/examples/hello",
"target": ":3333",
"remote": true,
"autorun": [
"monitor reset halt",
"monitor arm semihosting enable",
- "file ./target/thumbv7em-none-eabihf/debug/examples/hello",
"load"
],
"cwd": "${workspaceRoot}"
@@ -39,14 +39,14 @@
"request": "attach",
"name": "Debug itm",
"gdbpath": "/usr/bin/arm-none-eabi-gdb",
+ "executable": "./target/thumbv7em-none-eabihf/debug/examples/itm",
"target": ":3333",
"remote": true,
"autorun": [
"monitor reset halt",
"monitor arm semihosting enable",
- "monitor tpiu config external uart off 8000000 2000000",
+ "monitor tpiu config internal /tmp/itm.log uart off 16000000 2000000",
"monitor itm port 0 on",
- "file ./target/thumbv7em-none-eabihf/debug/examples/itm",
"load"
],
"cwd": "${workspaceRoot}"
@@ -81,6 +81,21 @@
],
"cwd": "${workspaceRoot}"
},
+ {
+ "type": "gdb",
+ "request": "attach",
+ "name": "Debug usart_clk --release",
+ "gdbpath": "/usr/bin/arm-none-eabi-gdb",
+ "target": ":3333",
+ "remote": true,
+ "autorun": [
+ "monitor reset init",
+ "monitor arm semihosting enable",
+ "file ./target/thumbv7em-none-eabihf/release/examples/usart_clk",
+ "load"
+ ],
+ "cwd": "${workspaceRoot}"
+ },
{
"type": "gdb",
"request": "attach",
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index bb7e1ab1766fe45ea74e7e4fba358a33300428cb..670bf65085e63783834d24f570fd4cd098a18d8d 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -7,6 +7,10 @@
"taskName": "xargo build --example hello --release",
"type": "shell",
"command": "xargo build --example hello --release",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
"problemMatcher": [
"$rustc"
]
@@ -15,6 +19,10 @@
"taskName": "xargo build --example hello",
"type": "shell",
"command": "xargo build --example hello",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
"problemMatcher": [
"$rustc"
]
@@ -23,6 +31,10 @@
"taskName": "xargo build --example gpio",
"type": "shell",
"command": "xargo build --example gpio",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
"problemMatcher": [
"$rustc"
]
@@ -31,6 +43,10 @@
"taskName": "xargo build --example usart1",
"type": "shell",
"command": "xargo build --example usart1",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
"problemMatcher": [
"$rustc"
]
@@ -47,10 +63,26 @@
"$rustc"
]
},
+ {
+ "taskName": "xargo build --example usart_clk --release",
+ "type": "shell",
+ "command": "xargo build --example usart_clk --release",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
+ "problemMatcher": [
+ "$rustc"
+ ]
+ },
{
"taskName": "xargo build --example itm",
"type": "shell",
"command": "xargo build --example itm",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
"problemMatcher": [
"$rustc"
]
@@ -59,6 +91,10 @@
"taskName": "xargo build --example ble_hid",
"type": "shell",
"command": "xargo build --example ble_hid",
+ "group": {
+ "kind": "build",
+ "isDefault": true
+ },
"problemMatcher": [
"$rustc"
]
diff --git a/checkstack.pl b/checkstack.pl
new file mode 100755
index 0000000000000000000000000000000000000000..d11094553f022e37a7f254ec69c42eee2ccdce75
--- /dev/null
+++ b/checkstack.pl
@@ -0,0 +1,154 @@
+#!/usr/bin/perl
+
+# Stolen from Linux kernel :)
+# borrowed from busybox and modified by:
+# Maciek Borzecki <maciek.borzecki@gmail.com>
+
+# Check the stack usage of functions
+#
+# Copyright Joern Engel <joern@wh.fh-wedel.de>
+# Inspired by Linus Torvalds
+# Original idea maybe from Keith Owens
+# s390 port and big speedup by Arnd Bergmann <arnd@bergmann-dalldorf.de>
+# Mips port by Juan Quintela <quintela@mandrakesoft.com>
+# IA64 port via Andreas Dilger
+# Arm port by Holger Schurig
+# sh64 port by Paul Mundt
+# Random bits by Matt Mackall <mpm@selenic.com>
+# M68k port by Geert Uytterhoeven and Andreas Schwab
+#
+# Usage:
+# objdump -d vmlinux | checkstack.pl [arch] [threshold]
+#
+# TODO : Port to all architectures (one regex per arch)
+
+# modifications to version from busybox:
+# 1. fix regex for ARM sp, Rd may not be included
+# 2. add threshold parameter
+
+# check for arch
+#
+# $re is used for two matches:
+# $& (whole re) matches the complete objdump line with the stack growth
+# $1 (first bracket) matches the size of the stack growth
+#
+# use anything else and feel the pain ;)
+my (@stack, $re, $x, $xs, $thresh);
+{
+ my $arch = shift;
+ if ($arch eq "") {
+ $arch = `uname -m`;
+ }
+
+ $thresh = shift;
+ if ($thresh eq "") {
+ $thresh = 100;
+ }
+
+ $x = "[0-9a-f]"; # hex character
+ $xs = "[0-9a-f ]"; # hex character or space
+ if ($arch eq 'arm') {
+ #c0008ffc: e24dd064 sub sp, sp, #100 ; 0x64
+ # or without Rd
+ #800362e: b082 sub sp, #8
+ $re = qr/.*sub.*(?:sp, )?sp, #([0-9]+)/o;
+ } elsif ($arch eq 'blackfin') {
+ # 52: 00 e8 03 00 LINK 0xc;
+ $re = qr/.*LINK (0x$x{1,5});$/o;
+ } elsif ($arch =~ /^i[3456]86$/) {
+ #c0105234: 81 ec ac 05 00 00 sub $0x5ac,%esp
+ $re = qr/^.*[as][du][db] \$(0x$x{1,8}),\%esp$/o;
+ } elsif ($arch eq 'x86_64') {
+ # 2f60: 48 81 ec e8 05 00 00 sub $0x5e8,%rsp
+ $re = qr/^.*[as][du][db] \$(0x$x{1,8}),\%rsp$/o;
+ } elsif ($arch eq 'ia64') {
+ #e0000000044011fc: 01 0f fc 8c adds r12=-384,r12
+ $re = qr/.*adds.*r12=-(([0-9]{2}|[3-9])[0-9]{2}),r12/o;
+ } elsif ($arch eq 'm68k') {
+ # 2b6c: 4e56 fb70 linkw %fp,#-1168
+ # 1df770: defc ffe4 addaw #-28,%sp
+ $re = qr/.*(?:linkw %fp,|addaw )#-([0-9]{1,4})(?:,%sp)?$/o;
+ } elsif ($arch eq 'mips64') {
+ #8800402c: 67bdfff0 daddiu sp,sp,-16
+ $re = qr/.*daddiu.*sp,sp,-(([0-9]{2}|[3-9])[0-9]{2})/o;
+ } elsif ($arch eq 'mips') {
+ #88003254: 27bdffe0 addiu sp,sp,-32
+ $re = qr/.*addiu.*sp,sp,-(([0-9]{2}|[3-9])[0-9]{2})/o;
+ } elsif ($arch eq 'ppc') {
+ #c00029f4: 94 21 ff 30 stwu r1,-208(r1)
+ $re = qr/.*stwu.*r1,-($x{1,8})\(r1\)/o;
+ } elsif ($arch eq 'ppc64') {
+ #XXX
+ $re = qr/.*stdu.*r1,-($x{1,8})\(r1\)/o;
+ } elsif ($arch eq 'powerpc') {
+ $re = qr/.*st[dw]u.*r1,-($x{1,8})\(r1\)/o;
+ } elsif ($arch =~ /^s390x?$/) {
+ # 11160: a7 fb ff 60 aghi %r15,-160
+ $re = qr/.*ag?hi.*\%r15,-(([0-9]{2}|[3-9])[0-9]{2})/o;
+ } elsif ($arch =~ /^sh64$/) {
+ #XXX: we only check for the immediate case presently,
+ # though we will want to check for the movi/sub
+ # pair for larger users. -- PFM.
+ #a00048e0: d4fc40f0 addi.l r15,-240,r15
+ $re = qr/.*addi\.l.*r15,-(([0-9]{2}|[3-9])[0-9]{2}),r15/o;
+ } else {
+ print("wrong or unknown architecture\n");
+ exit
+ }
+}
+
+sub bysize($) {
+ my ($asize, $bsize);
+ ($asize = $a) =~ s/.*: *(.*)$/$1/;
+ ($bsize = $b) =~ s/.*: *(.*)$/$1/;
+ $bsize <=> $asize
+}
+
+#
+# main()
+#
+my $funcre = qr/^$x* <(.*)>:$/;
+my $func;
+my $file, $lastslash;
+
+while (my $line = <STDIN>) {
+ if ($line =~ m/$funcre/) {
+ $func = $1;
+ }
+ elsif ($line =~ m/(.*):\s*file format/) {
+ $file = $1;
+ $file =~ s/\.ko//;
+ $lastslash = rindex($file, "/");
+ if ($lastslash != -1) {
+ $file = substr($file, $lastslash + 1);
+ }
+ }
+ elsif ($line =~ m/$re/) {
+ my $size = $1;
+ $size = hex($size) if ($size =~ /^0x/);
+
+ if ($size > 0xf0000000) {
+ $size = - $size;
+ $size += 0x80000000;
+ $size += 0x80000000;
+ }
+ next if ($size > 0x10000000);
+
+ next if $line !~ m/^($xs*)/;
+ my $addr = $1;
+ $addr =~ s/ /0/g;
+ $addr = "0x$addr";
+
+ # bbox: was: my $intro = "$addr $func [$file]:";
+ my $intro = "$func [$file]:";
+ my $padlen = 56 - length($intro);
+ while ($padlen > 0) {
+ $intro .= ' ';
+ $padlen -= 8;
+ }
+ next if ($size < $thresh);
+ push @stack, "$intro$size\n";
+ }
+}
+
+print sort bysize @stack;
\ No newline at end of file
diff --git a/examples/ble_hid.rs b/examples/ble_hid.rs
index dad30a573d2da5851fabed138a9dc8fb8f6e757f..f1b4493b61c00aad0310ebe2dab9f6dbff940e28 100644
--- a/examples/ble_hid.rs
+++ b/examples/ble_hid.rs
@@ -23,8 +23,8 @@ fn init(p: init::Peripherals) {
p.DWT.cyccnt.write(0);
}
- p.FLASH.acr.reset(); //////////latency().write().bits(2);
- p.FLASH.acr.modify(|_, w| unsafe {w.latency().bits(2)} ); //////////latency().write().bits(2);
+ //p.FLASH.acr.reset();
+ p.FLASH.acr.modify(|_, w| unsafe { w.latency().bits(2) });
//modify(|_, w | w.latency().set_bits(2));
println!("Init! {:x}", p.FLASH.acr.read().latency().bits());
@@ -36,52 +36,43 @@ fn init(p: init::Peripherals) {
// PP PLLN PLLM
//rcc().pllcfgr.write(|w| w.bits(0b0000 0000 0000 00 01 0 101010000 010000));
-
-
- rtfm::bkpt();
- p.RCC.cfgr.modify(|_, w| w.sw0().clear_bit()); //Switch to HSI
- p.RCC.cfgr.modify(|_, w| w.sw1().clear_bit()); //Switch to HSI
- rtfm::bkpt();
- p.RCC.cfgr.modify(|_, w| unsafe { w.ppre1().bits(4) }); //Configure apb1 prescaler = 2
- p.RCC.apb1enr.modify(|_, w| w.pwren().set_bit());
- p.RCC.cr.write(|w| w.pllon().clear_bit()); //Enable PLL
- p.RCC
- .pllcfgr
- .write(|w| unsafe { w.bits(0b00000000000000010101010000010000) }); //Configure PLL
-
- p.RCC.cr.modify(|_, w| w.pllon().set_bit()); //Enable PLL
-
- while p.RCC.cr.read().pllrdy().bit_is_clear() {}
-
- p.RCC.cfgr.modify(|_, w| w.sw0().clear_bit()); //Switch to PLL
- rtfm::bkpt();
- p.RCC.cfgr.modify(|_, w| w.sw1().set_bit()); //Switch to PLL
- rtfm::bkpt();
- p.RCC.apb2enr.modify(|_, w| w.syscfgen().set_bit());
- rtfm::bkpt();
-
- p.RCC.ahb1enr.modify(|_, w| w.gpioaen().set_bit()); //Enable GPIOA clock
- p.RCC.ahb1enr.modify(|_, w| w.gpioben().set_bit()); //Enable GPIOB clock
-
- ////////////////////////////////////////////////////////////////////////////////////////////////
- // USART2 stuff
- ////////////////////////////////////////////////////////////////////////////////////////////////
-
- rtfm::bkpt();
- USART::initialize(p.GPIOA, p.RCC, p.USART2);
- USART::send(p.USART2, "\n\n\nUSART initialized\n\r");
- ////////////////////////////////////////////////////////////////////////////////////////////////
-
- //spi.initialize();
- //i2c.initialize();
-
+
+
+ p.RCC.cfgr.modify(|_, w| w.sw0().clear_bit()); //Switch to HSI
+ p.RCC.cfgr.modify(|_, w| w.sw1().clear_bit()); //Switch to HSI
+ p.RCC.cfgr.modify(|_, w| unsafe { w.ppre1().bits(4) }); //Configure apb1 prescaler = 2
+ p.RCC.apb1enr.modify(|_, w| w.pwren().set_bit());
+ p.RCC.cr.write(|w| w.pllon().clear_bit()); //Enable PLL
+ p.RCC
+ .pllcfgr
+ .write(|w| unsafe { w.bits(0b00000000000000010101010000010000) }); //Configure PLL
+
+ p.RCC.cr.modify(|_, w| w.pllon().set_bit()); //Enable PLL
+
+ while p.RCC.cr.read().pllrdy().bit_is_clear() {}
+
+ p.RCC.cfgr.modify(|_, w| w.sw0().clear_bit()); //Switch to PLL
+ p.RCC.cfgr.modify(|_, w| w.sw1().set_bit()); //Switch to PLL
+ p.RCC.apb2enr.modify(|_, w| w.syscfgen().set_bit());
+
+ p.RCC.ahb1enr.modify(|_, w| w.gpioaen().set_bit()); //Enable GPIOA clock
+ p.RCC.ahb1enr.modify(|_, w| w.gpioben().set_bit()); //Enable GPIOB clock
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ // USART2 stuff
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ USART::initialize(p.GPIOA, p.RCC, p.USART2);
+ USART::send(p.USART2, "\n\n\nUSART initialized\n\r");
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ //spi.initialize();
+ //i2c.initialize();
}
fn idle() -> ! {
rtfm::bkpt();
- rtfm::bkpt();
-
println!("Hello, world!");
rtfm::bkpt();
diff --git a/examples/hello.rs b/examples/hello.rs
index 9ea315ab424d54478b13bd86949df54a397a3872..da24e2e37401305f5f239a6fa06f5b5d6404407f 100644
--- a/examples/hello.rs
+++ b/examples/hello.rs
@@ -17,7 +17,8 @@ app! {
fn init(_p: init::Peripherals) {}
fn idle() -> ! {
- println!("Hello, world!");
+ let f = 1.0;
+ println!("Hello, world! {}", f);
rtfm::bkpt();
loop {
diff --git a/examples/itm.rs b/examples/itm.rs
index 503ed097f04f411ac55eb590e5bb245bd29394d0..c6fd5aa27b52a92b013a30f2419593437b156fbe 100644
--- a/examples/itm.rs
+++ b/examples/itm.rs
@@ -3,7 +3,7 @@
//! You'll need to run these lines in your GDB session
//!
//! ``` text
-//! > monitor tpiu config external uart off 8000000 2000000
+//! > monitor tpiu config internal /tmp/itm.log uart off 16000000 2000000
//! > monitor itm port 0 on
//! ```
//!
@@ -14,7 +14,7 @@
//! file.
//!
//! ``` console
-//! $ cat /dev/ttyUSB0
+//! $ itmdump /tmp/itm.log
//! Hello
//! World
//! ```
diff --git a/examples/usart1.rs b/examples/usart1.rs
index 0ea9954b2b2b59fe6414fdb7e6c28e8f75653246..3b921b7679750abaa6579c5b5e6da1303cbd879e 100644
--- a/examples/usart1.rs
+++ b/examples/usart1.rs
@@ -9,10 +9,11 @@
//! info on pin header CN3 (TX/RX), howto use
//#![deny(unsafe_code)]
#![deny(warnings)]
-//#![allow(warnings)]
+#![allow(warnings)]
#![feature(proc_macro)]
#![no_std]
+
extern crate cortex_m_rtfm as rtfm;
extern crate cortex_m_semihosting as semihosting;
#[macro_use]
@@ -106,9 +107,11 @@ fn init(p: init::Peripherals) {
.clear_bit()
});
+ write(p.USART2, 'A' as u8).unwrap();
loop {
let b = block!(read(p.USART2)).unwrap();
- write(p.USART2, b).unwrap();
+ block!(write(p.USART2, b)).unwrap();
+ // block!(write(p.USART2, ',' as u8)).unwrap();
}
}
@@ -130,9 +133,7 @@ pub enum Error {
fn write(usart2: &USART2, byte: u8) -> Result<()> {
let sr = usart2.sr.read();
- if sr.ore().bit_is_set() {
- Err(nb::Error::Other(Error::Overrun))
- } else if sr.nf().bit_is_set() {
+ if sr.nf().bit_is_set() {
Err(nb::Error::Other(Error::Noise))
} else if sr.fe().bit_is_set() {
Err(nb::Error::Other(Error::Framing))
diff --git a/examples/usart3.rs b/examples/usart3.rs
deleted file mode 100644
index 6dd8e9635520f1731025616ecaa42a9ac9aa3512..0000000000000000000000000000000000000000
--- a/examples/usart3.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-//! Test the USART3 instance
-//!
-//! Connect the TX and RX pins to run this test
-
-#![deny(unsafe_code)]
-#![deny(warnings)]
-#![feature(proc_macro)]
-#![no_std]
-
-extern crate blue_pill;
-extern crate cortex_m_rtfm as rtfm;
-extern crate nb;
-
-use blue_pill::Serial;
-use blue_pill::prelude::*;
-use blue_pill::time::Hertz;
-use nb::Error;
-use rtfm::app;
-
-const BAUD_RATE: Hertz = Hertz(115_200);
-
-app! {
- device: blue_pill::stm32f103xx,
-}
-
-fn init(p: init::Peripherals) {
- let serial = Serial(p.USART3);
-
- serial.init(BAUD_RATE.invert(), p.AFIO, None, p.GPIOB, p.RCC);
-
- const BYTE: u8 = b'A';
-
- assert!(serial.write(BYTE).is_ok());
-
- for _ in 0..1_000 {
- match serial.read() {
- Ok(byte) => {
- assert_eq!(byte, BYTE);
- return;
- }
- Err(Error::Other(e)) => panic!("{:?}", e),
- Err(Error::WouldBlock) => continue,
- }
- }
-
- panic!("Timeout")
-}
-
-fn idle() -> ! {
- // OK
- rtfm::bkpt();
-
- // Sleep
- loop {
- rtfm::wfi();
- }
-}
diff --git a/examples/usart_clk.rs b/examples/usart_clk.rs
index ed907a2059e72d132fee5e723cf9a3eb2fdfd145..fb88eee69af8470eb5203f7a910e9fcb259a88af 100644
--- a/examples/usart_clk.rs
+++ b/examples/usart_clk.rs
@@ -103,6 +103,7 @@ fn clk_init(p: &init::Peripherals) {
// RM0368 8.4.1 (register), 3.4 Table 6
// we assume 3.3 volt operation, thus 2 cycles for 84mHz
// apb1 will be at 42 MHz
+ ::apb1::set_frequency(42_000_000);
p.FLASH.acr.modify(|_, w| unsafe { w.latency().bits(2) });
println!("Flash latency! {:x}", p.FLASH.acr.read().latency().bits());
@@ -140,7 +141,7 @@ fn clk_init(p: &init::Peripherals) {
#[inline(never)]
fn init(p: init::Peripherals) {
println!("Init!");
- // clk_init(&p);
+ clk_init(&p);
serial_init(&p);
//USART::initialize(p.GPIOA, p.RCC, p.USART2);
diff --git a/examples/usart2.rs b/examples/usart_jap_original.rs
similarity index 100%
rename from examples/usart2.rs
rename to examples/usart_jap_original.rs
diff --git a/objdump.out b/objdump.out
new file mode 100644
index 0000000000000000000000000000000000000000..e888bbb895211aa23b2c5116cf0ba85f1fef2aea
--- /dev/null
+++ b/objdump.out
@@ -0,0 +1,7639 @@
+
+target/thumbv7em-none-eabihf/release/examples/hello: file format elf32-littlearm
+
+
+Disassembly of section .text:
+
+08000188 <cortex_m_rt::reset_handler>:
+/// - `sbss` and `ebss` must be `T` aligned.
+pub unsafe fn zero_bss<T>(mut sbss: *mut T, ebss: *mut T)
+where
+ T: Copy,
+{
+ while sbss < ebss {
+ 8000188: f240 0000 movw r0, #0
+ 800018c: f240 0100 movw r1, #0
+ 8000190: f2c2 0000 movt r0, #8192 ; 0x2000
+ 8000194: f2c2 0100 movt r1, #8192 ; 0x2000
+ 8000198: 4281 cmp r1, r0
+ 800019a: d208 bcs.n 80001ae <cortex_m_rt::reset_handler+0x26>
+ 800019c: f240 0100 movw r1, #0
+ 80001a0: 2200 movs r2, #0
+ 80001a2: f2c2 0100 movt r1, #8192 ; 0x2000
+/// }
+/// ```
+#[inline]
+#[stable(feature = "volatile", since = "1.9.0")]
+pub unsafe fn write_volatile<T>(dst: *mut T, src: T) {
+ intrinsics::volatile_store(dst, src);
+ 80001a6: f841 2b04 str.w r2, [r1], #4
+ 80001aa: 4281 cmp r1, r0
+ 80001ac: d3fb bcc.n 80001a6 <cortex_m_rt::reset_handler+0x1e>
+ while sdata < edata {
+ 80001ae: f240 0000 movw r0, #0
+ 80001b2: f240 0100 movw r1, #0
+ 80001b6: f2c2 0000 movt r0, #8192 ; 0x2000
+ 80001ba: f2c2 0100 movt r1, #8192 ; 0x2000
+ 80001be: 4281 cmp r1, r0
+ 80001c0: d20d bcs.n 80001de <cortex_m_rt::reset_handler+0x56>
+ 80001c2: f240 0100 movw r1, #0
+ 80001c6: f644 32f8 movw r2, #19448 ; 0x4bf8
+ 80001ca: f2c2 0100 movt r1, #8192 ; 0x2000
+ 80001ce: f6c0 0200 movt r2, #2048 ; 0x800
+ 80001d2: f852 3b04 ldr.w r3, [r2], #4
+ intrinsics::move_val_init(&mut *dst, src)
+ 80001d6: f841 3b04 str.w r3, [r1], #4
+ 80001da: 4281 cmp r1, r0
+ 80001dc: d3f9 bcc.n 80001d2 <cortex_m_rt::reset_handler+0x4a>
+ 80001de: b580 push {r7, lr}
+ 80001e0: 466f mov r7, sp
+ 80001e2: f64e 5088 movw r0, #60808 ; 0xed88
+ 80001e6: f2ce 0000 movt r0, #57344 ; 0xe000
+ intrinsics::volatile_load(src)
+ 80001ea: 6801 ldr r1, [r0, #0]
+ let mut cpacr = self.cpacr.read() & !SCB_CPACR_FPU_MASK;
+ match mode {
+ FpuAccessMode::Disabled => (),
+ FpuAccessMode::Privileged => cpacr |= SCB_CPACR_FPU_ENABLE,
+ FpuAccessMode::Enabled => {
+ cpacr |= SCB_CPACR_FPU_ENABLE | SCB_CPACR_FPU_USER
+ 80001ec: f441 0170 orr.w r1, r1, #15728640 ; 0xf00000
+ intrinsics::volatile_store(dst, src);
+ 80001f0: 6001 str r1, [r0, #0]
+ unsafe {
+ ::main(0, ::core::ptr::null());
+ }
+ }
+
+ main()
+ 80001f2: f000 f907 bl 8000404 <cortex_m_rt::reset_handler::main>
+ 80001f6: e8bd 4080 ldmia.w sp!, {r7, lr}
+ }
+
+ // If `main` returns, then we go into "reactive" mode and simply attend
+ // interrupts as they occur.
+ loop {
+ asm!("wfi" :::: "volatile");
+ 80001fa: bf30 wfi
+ loop {
+ 80001fc: e7fd b.n 80001fa <cortex_m_rt::reset_handler+0x72>
+ ...
+
+08000200 <ADC>:
+ 8000200: f000 b8fc b.w 80003fc <BUS_FAULT>
+
+08000204 <core::ptr::drop_in_place>:
+pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
+ 8000204: 4770 bx lr
+
+08000206 <core::result::unwrap_failed>:
+}
+
+// This is a separate function to reduce the code size of the methods
+#[inline(never)]
+#[cold]
+fn unwrap_failed<E: fmt::Debug>(msg: &str, error: E) -> ! {
+ 8000206: b580 push {r7, lr}
+ 8000208: 466f mov r7, sp
+ );
+ ($msg:expr) => ({
+ $crate::panicking::panic(&($msg, file!(), line!(), __rust_unstable_column!()))
+ });
+ ($fmt:expr, $($arg:tt)*) => ({
+ $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*),
+ 800020a: f000 fa81 bl 8000710 <core::panicking::panic_fmt>
+
+0800020e <core::result::unwrap_failed>:
+ 800020e: b580 push {r7, lr}
+ 8000210: 466f mov r7, sp
+ 8000212: f000 fa7d bl 8000710 <core::panicking::panic_fmt>
+
+08000216 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char>:
+ {
+ fn write_str(&mut self, s: &str) -> Result {
+ self.0.write_str(s)
+ }
+
+ fn write_char(&mut self, c: char) -> Result {
+ 8000216: b580 push {r7, lr}
+ 8000218: 466f mov r7, sp
+ 800021a: b084 sub sp, #16
+ self.0.write_char(c)
+ 800021c: 6800 ldr r0, [r0, #0]
+ 800021e: 2200 movs r2, #0
+ #[inline]
+ fn encode_utf8(self, dst: &mut [u8]) -> &mut str {
+ let code = self as u32;
+ unsafe {
+ let len =
+ if code < MAX_ONE_B && !dst.is_empty() {
+ 8000220: 297f cmp r1, #127 ; 0x7f
+ self.write_str(c.encode_utf8(&mut [0; 4]))
+ 8000222: 9200 str r2, [sp, #0]
+ 8000224: d804 bhi.n 8000230 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0x1a>
+ *dst.get_unchecked_mut(0) = code as u8;
+ 8000226: f88d 1000 strb.w r1, [sp]
+ 800022a: f04f 0e01 mov.w lr, #1
+ 800022e: e03d b.n 80002ac <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0x96>
+ 1
+ } else if code < MAX_TWO_B && dst.len() >= 2 {
+ 8000230: ebb2 2fd1 cmp.w r2, r1, lsr #11
+ 8000234: d10c bne.n 8000250 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0x3a>
+ *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+ 8000236: 098a lsrs r2, r1, #6
+ 8000238: 2306 movs r3, #6
+ 800023a: f04f 0e02 mov.w lr, #2
+ 800023e: f363 125f bfi r2, r3, #5, #27
+ *dst.get_unchecked_mut(1) = (code & 0x3F) as u8 | TAG_CONT;
+ 8000242: f36e 119f bfi r1, lr, #6, #26
+ *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+ 8000246: f88d 2000 strb.w r2, [sp]
+ *dst.get_unchecked_mut(1) = (code & 0x3F) as u8 | TAG_CONT;
+ 800024a: f88d 1001 strb.w r1, [sp, #1]
+ 800024e: e02d b.n 80002ac <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0x96>
+ 2
+ } else if code < MAX_THREE_B && dst.len() >= 3 {
+ 8000250: 2200 movs r2, #0
+ 8000252: ebb2 4f11 cmp.w r2, r1, lsr #16
+ 8000256: d112 bne.n 800027e <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0x68>
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 8000258: 0b0a lsrs r2, r1, #12
+ 800025a: 230e movs r3, #14
+ 800025c: f04f 0e03 mov.w lr, #3
+ 8000260: f363 121f bfi r2, r3, #4, #28
+ 8000264: 2302 movs r3, #2
+ 8000266: f88d 2000 strb.w r2, [sp]
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 800026a: 098a lsrs r2, r1, #6
+ *dst.get_unchecked_mut(2) = (code & 0x3F) as u8 | TAG_CONT;
+ 800026c: f363 119f bfi r1, r3, #6, #26
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000270: f363 129f bfi r2, r3, #6, #26
+ 8000274: f88d 2001 strb.w r2, [sp, #1]
+ *dst.get_unchecked_mut(2) = (code & 0x3F) as u8 | TAG_CONT;
+ 8000278: f88d 1002 strb.w r1, [sp, #2]
+ 800027c: e016 b.n 80002ac <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0x96>
+ 3
+ } else if dst.len() >= 4 {
+ *dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+ 800027e: 0c8a lsrs r2, r1, #18
+ 8000280: 231e movs r3, #30
+ 8000282: f04f 0e04 mov.w lr, #4
+ 8000286: f363 02df bfi r2, r3, #3, #29
+ 800028a: 2302 movs r3, #2
+ 800028c: f88d 2000 strb.w r2, [sp]
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 8000290: 0b0a lsrs r2, r1, #12
+ 8000292: f363 129f bfi r2, r3, #6, #26
+ 8000296: f88d 2001 strb.w r2, [sp, #1]
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 800029a: 098a lsrs r2, r1, #6
+ *dst.get_unchecked_mut(3) = (code & 0x3F) as u8 | TAG_CONT;
+ 800029c: f363 119f bfi r1, r3, #6, #26
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 80002a0: f363 129f bfi r2, r3, #6, #26
+ 80002a4: f88d 2002 strb.w r2, [sp, #2]
+ *dst.get_unchecked_mut(3) = (code & 0x3F) as u8 | TAG_CONT;
+ 80002a8: f88d 1003 strb.w r1, [sp, #3]
+}
+
+impl HStdout {
+ /// Attempts to write an entire `buffer` into this sink
+ pub fn write_all(&mut self, buffer: &[u8]) -> Result<(), ()> {
+ write_all(self.fd, buffer)
+ 80002ac: f8d0 c000 ldr.w ip, [r0]
+ 80002b0: 4668 mov r0, sp
+ 80002b2: a901 add r1, sp, #4
+ }
+}
+
+fn write_all(fd: usize, mut buffer: &[u8]) -> Result<(), ()> {
+ while !buffer.is_empty() {
+ match unsafe { syscall!(WRITE, fd, buffer.as_ptr(), buffer.len()) } {
+ 80002b4: f8cd c004 str.w ip, [sp, #4]
+ 80002b8: e9cd 0e02 strd r0, lr, [sp, #8]
+
+/// Performs a semihosting operation, takes a pointer to an argument block
+#[inline(always)]
+#[cfg(target_arch = "arm")]
+pub unsafe fn syscall<T>(mut nr: usize, arg: &T) -> usize {
+ asm!("bkpt 0xAB"
+ 80002bc: 2005 movs r0, #5
+ 80002be: beab bkpt 0x00ab
+ // Done
+ 0 => return Ok(()),
+ 80002c0: 2800 cmp r0, #0
+ 80002c2: d010 beq.n 80002e6 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0xd0>
+ 80002c4: 466b mov r3, sp
+ 80002c6: a901 add r1, sp, #4
+ 80002c8: 4602 mov r2, r0
+ // `n` bytes were not written
+ n if n <= buffer.len() => {
+ 80002ca: 4596 cmp lr, r2
+ 80002cc: d30e bcc.n 80002ec <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0xd6>
+ let offset = (buffer.len() - n) as isize;
+ 80002ce: ebae 0002 sub.w r0, lr, r2
+ match unsafe { syscall!(WRITE, fd, buffer.as_ptr(), buffer.len()) } {
+ 80002d2: f8cd c004 str.w ip, [sp, #4]
+ 80002d6: 4696 mov lr, r2
+ /// }
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub unsafe fn offset(self, count: isize) -> *const T where T: Sized {
+ intrinsics::offset(self, count)
+ 80002d8: 4403 add r3, r0
+ 80002da: 2005 movs r0, #5
+ 80002dc: e9cd 3202 strd r3, r2, [sp, #8]
+ 80002e0: beab bkpt 0x00ab
+ 0 => return Ok(()),
+ 80002e2: 2800 cmp r0, #0
+ 80002e4: d1f0 bne.n 80002c8 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_char+0xb2>
+ 80002e6: 2000 movs r0, #0
+ 80002e8: b004 add sp, #16
+ 80002ea: bd80 pop {r7, pc}
+ 80002ec: 2001 movs r0, #1
+ }
+ 80002ee: b004 add sp, #16
+ 80002f0: bd80 pop {r7, pc}
+
+080002f2 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_fmt>:
+
+ fn write_fmt(&mut self, args: Arguments) -> Result {
+ 80002f2: b5f0 push {r4, r5, r6, r7, lr}
+ 80002f4: af03 add r7, sp, #12
+ 80002f6: f84d bd04 str.w fp, [sp, #-4]!
+ 80002fa: b088 sub sp, #32
+ self.0.write_fmt(args)
+ 80002fc: 6800 ldr r0, [r0, #0]
+ 80002fe: aa02 add r2, sp, #8
+ }
+ }
+
+ write(&mut Adapter(self), args)
+ 8000300: 9001 str r0, [sp, #4]
+ 8000302: 4610 mov r0, r2
+ 8000304: e891 5078 ldmia.w r1, {r3, r4, r5, r6, ip, lr}
+ 8000308: f643 5180 movw r1, #15744 ; 0x3d80
+ 800030c: f6c0 0100 movt r1, #2048 ; 0x800
+ 8000310: e880 5078 stmia.w r0, {r3, r4, r5, r6, ip, lr}
+ 8000314: a801 add r0, sp, #4
+ 8000316: f000 fcf4 bl 8000d02 <core::fmt::write>
+ }
+ 800031a: b008 add sp, #32
+ 800031c: f85d bb04 ldr.w fp, [sp], #4
+ 8000320: bdf0 pop {r4, r5, r6, r7, pc}
+
+08000322 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_str>:
+ fn write_str(&mut self, s: &str) -> Result {
+ 8000322: b580 push {r7, lr}
+ 8000324: 466f mov r7, sp
+ 8000326: b083 sub sp, #12
+ 8000328: 468e mov lr, r1
+ 800032a: b1c2 cbz r2, 800035e <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_str+0x3c>
+ self.0.write_str(s)
+ 800032c: 6800 ldr r0, [r0, #0]
+ 800032e: 4669 mov r1, sp
+ write_all(self.fd, buffer)
+ 8000330: f8d0 c000 ldr.w ip, [r0]
+ 8000334: 2005 movs r0, #5
+ match unsafe { syscall!(WRITE, fd, buffer.as_ptr(), buffer.len()) } {
+ 8000336: e9cd ce00 strd ip, lr, [sp]
+ 800033a: 9202 str r2, [sp, #8]
+ 800033c: beab bkpt 0x00ab
+ 800033e: b170 cbz r0, 800035e <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_str+0x3c>
+ 8000340: 4669 mov r1, sp
+ 8000342: 4603 mov r3, r0
+ n if n <= buffer.len() => {
+ 8000344: 429a cmp r2, r3
+ 8000346: d30d bcc.n 8000364 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_str+0x42>
+ let offset = (buffer.len() - n) as isize;
+ 8000348: 1ad0 subs r0, r2, r3
+ match unsafe { syscall!(WRITE, fd, buffer.as_ptr(), buffer.len()) } {
+ 800034a: f8cd c000 str.w ip, [sp]
+ 800034e: 461a mov r2, r3
+ 8000350: 4486 add lr, r0
+ 8000352: 2005 movs r0, #5
+ 8000354: e9cd e301 strd lr, r3, [sp, #4]
+ 8000358: beab bkpt 0x00ab
+ 0 => return Ok(()),
+ 800035a: 2800 cmp r0, #0
+ 800035c: d1f1 bne.n 8000342 <<core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_str+0x20>
+ 800035e: 2000 movs r0, #0
+ 8000360: b003 add sp, #12
+ 8000362: bd80 pop {r7, pc}
+ 8000364: 2001 movs r0, #1
+ }
+ 8000366: b003 add sp, #12
+ 8000368: bd80 pop {r7, pc}
+
+0800036a <main>:
+ 800036a: b580 push {r7, lr}
+ 800036c: 466f mov r7, sp
+ 800036e: b08c sub sp, #48 ; 0x30
+ 8000370: f240 1088 movw r0, #392 ; 0x188
+ 8000374: 2200 movs r2, #0
+ 8000376: a906 add r1, sp, #24
+ 8000378: 2301 movs r3, #1
+ 800037a: f6c0 0000 movt r0, #2048 ; 0x800
+ 800037e: 7800 ldrb r0, [r0, #0]
+#[inline(always)]
+pub fn disable() {
+ match () {
+ #[cfg(target_arch = "arm")]
+ () => unsafe {
+ asm!("cpsid i"
+ 8000380: b672 cpsid i
+}
+
+fn init(_p: init::Peripherals) {}
+
+fn idle() -> ! {
+ let f = 1.0;
+ 8000382: 2000 movs r0, #0
+#[inline(always)]
+pub unsafe fn enable() {
+ match () {
+ #[cfg(target_arch = "arm")]
+ () => {
+ asm!("cpsie i"
+ 8000384: b662 cpsie i
+ 8000386: f6c3 70f0 movt r0, #16368 ; 0x3ff0
+ 800038a: 9001 str r0, [sp, #4]
+ match unsafe { syscall!(OPEN, name.as_ptr(), mode, name.len() - 1) } as
+ 800038c: f643 50b8 movw r0, #15800 ; 0x3db8
+ 8000390: 9200 str r2, [sp, #0]
+ 8000392: f6c0 0000 movt r0, #2048 ; 0x800
+ 8000396: 9006 str r0, [sp, #24]
+ 8000398: 2004 movs r0, #4
+ 800039a: 9007 str r0, [sp, #28]
+ 800039c: 2003 movs r0, #3
+ 800039e: 9008 str r0, [sp, #32]
+ 80003a0: 2001 movs r0, #1
+ 80003a2: beab bkpt 0x00ab
+ Ok(t) => t,
+ 80003a4: 1c41 adds r1, r0, #1
+ 80003a6: d023 beq.n 80003f0 <main+0x86>
+ println!("Hello, world! {}", f);
+ 80003a8: 9002 str r0, [sp, #8]
+ 80003aa: 4668 mov r0, sp
+ write(&mut Adapter(self), args)
+ 80003ac: f643 5180 movw r1, #15744 ; 0x3d80
+ 80003b0: 9003 str r0, [sp, #12]
+ 80003b2: f643 2097 movw r0, #14999 ; 0x3a97
+ 80003b6: f6c0 0100 movt r1, #2048 ; 0x800
+ 80003ba: f6c0 0000 movt r0, #2048 ; 0x800
+ 80003be: 9004 str r0, [sp, #16]
+ 80003c0: a802 add r0, sp, #8
+ 80003c2: 9005 str r0, [sp, #20]
+ 80003c4: f643 50a8 movw r0, #15784 ; 0x3da8
+ 80003c8: f6c0 0000 movt r0, #2048 ; 0x800
+ 80003cc: 9006 str r0, [sp, #24]
+ 80003ce: 2002 movs r0, #2
+ 80003d0: 9209 str r2, [sp, #36] ; 0x24
+ 80003d2: e9cd 0207 strd r0, r2, [sp, #28]
+ 80003d6: a803 add r0, sp, #12
+ 80003d8: aa06 add r2, sp, #24
+ 80003da: e9cd 030a strd r0, r3, [sp, #40] ; 0x28
+ 80003de: a805 add r0, sp, #20
+ 80003e0: f000 fc8f bl 8000d02 <core::fmt::write>
+ 80003e4: f010 0fff tst.w r0, #255 ; 0xff
+ 80003e8: d104 bne.n 80003f4 <main+0x8a>
+/// cause an exception
+#[inline(always)]
+pub fn bkpt() {
+ #[cfg(target_arch = "arm")]
+ unsafe {
+ asm!("bkpt"
+ 80003ea: be00 bkpt 0x0000
+#[inline(always)]
+pub fn wfi() {
+ match () {
+ #[cfg(target_arch = "arm")]
+ () => unsafe{
+ asm!("wfi"
+ 80003ec: bf30 wfi
+
+ rtfm::bkpt();
+ loop {
+ 80003ee: e7fd b.n 80003ec <main+0x82>
+ Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", e),
+ 80003f0: f7ff ff09 bl 8000206 <core::result::unwrap_failed>
+ 80003f4: f7ff ff0b bl 800020e <core::result::unwrap_failed>
+
+080003f8 <cortex_m_rt::default_handler>:
+ asm!("bkpt"
+ 80003f8: be00 bkpt 0x0000
+#[allow(unused_variables)]
+#[cfg(target_arch = "arm")]
+extern "C" fn default_handler(ef: &ExceptionFrame) -> ! {
+ asm::bkpt();
+
+ loop {}
+ 80003fa: e7fe b.n 80003fa <cortex_m_rt::default_handler+0x2>
+
+080003fc <BUS_FAULT>:
+ #[export_name = "DEFAULT_HANDLER"]
+ #[linkage = "weak"]
+ #[naked]
+ extern "C" fn trampoline() -> ! {
+ unsafe {
+ asm!("mrs r0, MSP
+ 80003fc: f3ef 8008 mrs r0, MSP
+ 8000400: f7ff bffa b.w 80003f8 <cortex_m_rt::default_handler>
+
+08000404 <cortex_m_rt::reset_handler::main>:
+ ::main(0, ::core::ptr::null());
+ 8000404: f7ff bfb1 b.w 800036a <main>
+
+08000408 <core::num::flt2dec::strategy::dragon::mul_pow10>:
+ [0, 0, 0, 0, 0, 0, 0, 0, 0x982e7c01, 0xbed3875b, 0xd8d99f72, 0x12152f87, 0x6bde50c6,
+ 0xcf4a6e70, 0xd595d80f, 0x26b2716e, 0xadc666b0, 0x1d153624, 0x3c42d35a, 0x63ff540e,
+ 0xcc5573c0, 0x65f9ef17, 0x55bc28f2, 0x80dcc7f7, 0xf46eeddc, 0x5fdcefce, 0x553f7];
+
+#[doc(hidden)]
+pub fn mul_pow10(x: &mut Big, n: usize) -> &mut Big {
+ 8000408: b5f0 push {r4, r5, r6, r7, lr}
+ 800040a: af03 add r7, sp, #12
+ 800040c: f84d 8d04 str.w r8, [sp, #-4]!
+ 8000410: 4688 mov r8, r1
+ debug_assert!(n < 512);
+ if n & 7 != 0 { x.mul_small(POW10[n & 7]); }
+ 8000412: f018 0207 ands.w r2, r8, #7
+ 8000416: d02a beq.n 800046e <core::num::flt2dec::strategy::dragon::mul_pow10+0x66>
+ /// Multiplies itself by a digit-sized `other` and returns its own
+ /// mutable reference.
+ pub fn mul_small(&mut self, other: $ty) -> &mut $name {
+ use num::bignum::FullOps;
+
+ let mut sz = self.size;
+ 8000418: f8d0 e000 ldr.w lr, [r0]
+
+ #[inline]
+ fn index_mut(self, slice: &mut [T]) -> &mut [T] {
+ if self.start > self.end {
+ slice_index_order_fail(self.start, self.end);
+ } else if self.end > slice.len() {
+ 800041c: f1be 0f29 cmp.w lr, #41 ; 0x29
+ 8000420: f080 8085 bcs.w 800052e <core::num::flt2dec::strategy::dragon::mul_pow10+0x126>
+ 8000424: 2600 movs r6, #0
+ unsafe {
+ if mem::size_of::<T>() != 0 {
+ assume(!self.ptr.is_null());
+ assume(!self.end.is_null());
+ }
+ if self.ptr == self.end {
+ 8000426: f1be 0f00 cmp.w lr, #0
+ 800042a: d01f beq.n 800046c <core::num::flt2dec::strategy::dragon::mul_pow10+0x64>
+ &(*slice)[self]
+ 800042c: f244 23d0 movw r3, #17104 ; 0x42d0
+ if self.ptr == self.end {
+ 8000430: ea4f 048e mov.w r4, lr, lsl #2
+ let mut carry = 0;
+ for a in &mut self.base[..sz] {
+ 8000434: 1d05 adds r5, r0, #4
+ &(*slice)[self]
+ 8000436: f6c0 0300 movt r3, #2048 ; 0x800
+ 800043a: f853 3022 ldr.w r3, [r3, r2, lsl #2]
+ /// }
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub unsafe fn offset(self, count: isize) -> *mut T where T: Sized {
+ intrinsics::offset(self, count) as *mut T
+ 800043e: eb00 028e add.w r2, r0, lr, lsl #2
+ 8000442: f102 0c04 add.w ip, r2, #4
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8000446: 6829 ldr r1, [r5, #0]
+ 8000448: 2200 movs r2, #0
+ if self.ptr == self.end {
+ 800044a: 3c04 subs r4, #4
+ 800044c: fbe1 6203 umlal r6, r2, r1, r3
+ let (c, v) = (*a).full_mul(other, carry);
+ *a = v;
+ 8000450: f845 6b04 str.w r6, [r5], #4
+ 8000454: 4616 mov r6, r2
+ 8000456: d1f6 bne.n 8000446 <core::num::flt2dec::strategy::dragon::mul_pow10+0x3e>
+ 8000458: b13a cbz r2, 800046a <core::num::flt2dec::strategy::dragon::mul_pow10+0x62>
+ carry = c;
+ }
+ if carry > 0 {
+ self.base[sz] = carry;
+ 800045a: f1be 0f27 cmp.w lr, #39 ; 0x27
+ 800045e: d86a bhi.n 8000536 <core::num::flt2dec::strategy::dragon::mul_pow10+0x12e>
+ sz += 1;
+ 8000460: f10e 0601 add.w r6, lr, #1
+ self.base[sz] = carry;
+ 8000464: f8cc 2000 str.w r2, [ip]
+ 8000468: e000 b.n 800046c <core::num::flt2dec::strategy::dragon::mul_pow10+0x64>
+ 800046a: 4676 mov r6, lr
+ }
+ self.size = sz;
+ 800046c: 6006 str r6, [r0, #0]
+ if n & 8 != 0 { x.mul_small(POW10[8]); }
+ 800046e: ea5f 7108 movs.w r1, r8, lsl #28
+ 8000472: d527 bpl.n 80004c4 <core::num::flt2dec::strategy::dragon::mul_pow10+0xbc>
+ let mut sz = self.size;
+ 8000474: f8d0 e000 ldr.w lr, [r0]
+ } else if self.end > slice.len() {
+ 8000478: f1be 0f29 cmp.w lr, #41 ; 0x29
+ 800047c: d257 bcs.n 800052e <core::num::flt2dec::strategy::dragon::mul_pow10+0x126>
+ 800047e: 2600 movs r6, #0
+ if self.ptr == self.end {
+ 8000480: f1be 0f00 cmp.w lr, #0
+ 8000484: d01d beq.n 80004c2 <core::num::flt2dec::strategy::dragon::mul_pow10+0xba>
+ 8000486: f24e 1500 movw r5, #57600 ; 0xe100
+ 800048a: eb00 028e add.w r2, r0, lr, lsl #2
+ 800048e: ea4f 038e mov.w r3, lr, lsl #2
+ for a in &mut self.base[..sz] {
+ 8000492: 1d04 adds r4, r0, #4
+ 8000494: f102 0c04 add.w ip, r2, #4
+ 8000498: f2c0 55f5 movt r5, #1525 ; 0x5f5
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 800049c: 6821 ldr r1, [r4, #0]
+ 800049e: 2200 movs r2, #0
+ 80004a0: 3b04 subs r3, #4
+ 80004a2: fbe1 6205 umlal r6, r2, r1, r5
+ *a = v;
+ 80004a6: f844 6b04 str.w r6, [r4], #4
+ 80004aa: 4616 mov r6, r2
+ 80004ac: d1f6 bne.n 800049c <core::num::flt2dec::strategy::dragon::mul_pow10+0x94>
+ 80004ae: b13a cbz r2, 80004c0 <core::num::flt2dec::strategy::dragon::mul_pow10+0xb8>
+ self.base[sz] = carry;
+ 80004b0: f1be 0f27 cmp.w lr, #39 ; 0x27
+ 80004b4: d83f bhi.n 8000536 <core::num::flt2dec::strategy::dragon::mul_pow10+0x12e>
+ sz += 1;
+ 80004b6: f10e 0601 add.w r6, lr, #1
+ self.base[sz] = carry;
+ 80004ba: f8cc 2000 str.w r2, [ip]
+ 80004be: e000 b.n 80004c2 <core::num::flt2dec::strategy::dragon::mul_pow10+0xba>
+ 80004c0: 4676 mov r6, lr
+ self.size = sz;
+ 80004c2: 6006 str r6, [r0, #0]
+ if n & 16 != 0 { x.mul_digits(&POW10TO16); }
+ 80004c4: ea5f 61c8 movs.w r1, r8, lsl #27
+ 80004c8: d506 bpl.n 80004d8 <core::num::flt2dec::strategy::dragon::mul_pow10+0xd0>
+ 80004ca: f244 21f8 movw r1, #17144 ; 0x42f8
+ 80004ce: 2202 movs r2, #2
+ 80004d0: f6c0 0100 movt r1, #2048 ; 0x800
+ 80004d4: f000 f83b bl 800054e <core::num::bignum::Big32x40::mul_digits>
+ if n & 32 != 0 { x.mul_digits(&POW10TO32); }
+ 80004d8: ea5f 6188 movs.w r1, r8, lsl #26
+ 80004dc: d506 bpl.n 80004ec <core::num::flt2dec::strategy::dragon::mul_pow10+0xe4>
+ 80004de: f244 3100 movw r1, #17152 ; 0x4300
+ 80004e2: 2204 movs r2, #4
+ 80004e4: f6c0 0100 movt r1, #2048 ; 0x800
+ 80004e8: f000 f831 bl 800054e <core::num::bignum::Big32x40::mul_digits>
+ if n & 64 != 0 { x.mul_digits(&POW10TO64); }
+ 80004ec: ea5f 6148 movs.w r1, r8, lsl #25
+ 80004f0: d506 bpl.n 8000500 <core::num::flt2dec::strategy::dragon::mul_pow10+0xf8>
+ 80004f2: f244 3110 movw r1, #17168 ; 0x4310
+ 80004f6: 2207 movs r2, #7
+ 80004f8: f6c0 0100 movt r1, #2048 ; 0x800
+ 80004fc: f000 f827 bl 800054e <core::num::bignum::Big32x40::mul_digits>
+ if n & 128 != 0 { x.mul_digits(&POW10TO128); }
+ 8000500: ea5f 6108 movs.w r1, r8, lsl #24
+ 8000504: d506 bpl.n 8000514 <core::num::flt2dec::strategy::dragon::mul_pow10+0x10c>
+ 8000506: f244 312c movw r1, #17196 ; 0x432c
+ 800050a: 220e movs r2, #14
+ 800050c: f6c0 0100 movt r1, #2048 ; 0x800
+ 8000510: f000 f81d bl 800054e <core::num::bignum::Big32x40::mul_digits>
+ if n & 256 != 0 { x.mul_digits(&POW10TO256); }
+ 8000514: ea5f 51c8 movs.w r1, r8, lsl #23
+ 8000518: d506 bpl.n 8000528 <core::num::flt2dec::strategy::dragon::mul_pow10+0x120>
+ 800051a: f244 3164 movw r1, #17252 ; 0x4364
+ 800051e: 221b movs r2, #27
+ 8000520: f6c0 0100 movt r1, #2048 ; 0x800
+ 8000524: f000 f813 bl 800054e <core::num::bignum::Big32x40::mul_digits>
+ x
+}
+ 8000528: f85d 8b04 ldr.w r8, [sp], #4
+ 800052c: bdf0 pop {r4, r5, r6, r7, pc}
+ 800052e: 4670 mov r0, lr
+ 8000530: 2128 movs r1, #40 ; 0x28
+ 8000532: f000 f804 bl 800053e <core::slice::slice_index_len_fail>
+ 8000536: 4670 mov r0, lr
+ 8000538: 2128 movs r1, #40 ; 0x28
+ 800053a: f000 f804 bl 8000546 <core::panicking::panic_bounds_check>
+
+0800053e <core::slice::slice_index_len_fail>:
+fn slice_index_len_fail(index: usize, len: usize) -> ! {
+ 800053e: b580 push {r7, lr}
+ 8000540: 466f mov r7, sp
+ panic!("index {} out of range for slice of length {}", index, len);
+ 8000542: f000 f8e5 bl 8000710 <core::panicking::panic_fmt>
+
+08000546 <core::panicking::panic_bounds_check>:
+ panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
+}
+
+#[cold] #[inline(never)]
+#[lang = "panic_bounds_check"]
+fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
+ 8000546: b580 push {r7, lr}
+ 8000548: 466f mov r7, sp
+ index: usize, len: usize) -> ! {
+ panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
+ 800054a: f000 f8e1 bl 8000710 <core::panicking::panic_fmt>
+
+0800054e <core::num::bignum::Big32x40::mul_digits>:
+
+
+ /// Multiplies itself by a number described by `other[0] + other[1] * 2^W +
+ /// other[2] * 2^(2W) + ...` (where `W` is the number of bits in the digit type)
+ /// and returns its own mutable reference.
+ pub fn mul_digits<'a>(&'a mut self, other: &[$ty]) -> &'a mut $name {
+ 800054e: b5f0 push {r4, r5, r6, r7, lr}
+ 8000550: af03 add r7, sp, #12
+ 8000552: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8000556: b0af sub sp, #188 ; 0xbc
+ 8000558: ac07 add r4, sp, #28
+ 800055a: 460d mov r5, r1
+ 800055c: 4681 mov r9, r0
+ }
+ }
+ retsz
+ }
+
+ let mut ret = [0; $n];
+ 800055e: 21a0 movs r1, #160 ; 0xa0
+ 8000560: 4616 mov r6, r2
+ 8000562: 4620 mov r0, r4
+ 8000564: f003 fb06 bl 8003b74 <__aeabi_memclr4>
+ let retsz = if self.size < other.len() {
+ 8000568: f8d9 8000 ldr.w r8, [r9]
+ } else if self.end > slice.len() {
+ 800056c: f1b8 0f29 cmp.w r8, #41 ; 0x29
+ 8000570: f080 80ca bcs.w 8000708 <core::num::bignum::Big32x40::mul_digits+0x1ba>
+ &self.base[..self.size]
+ 8000574: f109 0004 add.w r0, r9, #4
+ let retsz = if self.size < other.len() {
+ 8000578: 45b0 cmp r8, r6
+ 800057a: d210 bcs.n 800059e <core::num::bignum::Big32x40::mul_digits+0x50>
+ 800057c: eb04 0186 add.w r1, r4, r6, lsl #2
+ 8000580: 1c72 adds r2, r6, #1
+ 8000582: f04f 0a00 mov.w sl, #0
+ let mut retsz = 0;
+ 8000586: 3904 subs r1, #4
+ 8000588: 9201 str r2, [sp, #4]
+ 800058a: 2200 movs r2, #0
+ intrinsics::offset(self, count)
+ 800058c: 9102 str r1, [sp, #8]
+ 800058e: eb09 0188 add.w r1, r9, r8, lsl #2
+ 8000592: f1a4 0804 sub.w r8, r4, #4
+ 8000596: 4604 mov r4, r0
+ 8000598: 1d0b adds r3, r1, #4
+ 800059a: 00b1 lsls r1, r6, #2
+ 800059c: e029 b.n 80005f2 <core::num::bignum::Big32x40::mul_digits+0xa4>
+ 800059e: eb05 0b86 add.w fp, r5, r6, lsl #2
+ for (i, &a) in aa.iter().enumerate() {
+ 80005a2: f1b8 0f00 cmp.w r8, #0
+ 80005a6: f000 808a beq.w 80006be <core::num::bignum::Big32x40::mul_digits+0x170>
+ 80005aa: f108 0101 add.w r1, r8, #1
+ let mut retsz = 0;
+ 80005ae: 1f22 subs r2, r4, #4
+ 80005b0: 2600 movs r6, #0
+ 80005b2: f04f 0a00 mov.w sl, #0
+ 80005b6: 9103 str r1, [sp, #12]
+ 80005b8: eb04 0188 add.w r1, r4, r8, lsl #2
+ 80005bc: 3904 subs r1, #4
+ 80005be: 9102 str r1, [sp, #8]
+ 80005c0: ea4f 0188 mov.w r1, r8, lsl #2
+ 80005c4: e055 b.n 8000672 <core::num::bignum::Big32x40::mul_digits+0x124>
+ 80005c6: e9dd 8a05 ldrd r8, sl, [sp, #20]
+ if carry > 0 {
+ 80005ca: f1b9 0f00 cmp.w r9, #0
+ 80005ce: 4631 mov r1, r6
+ 80005d0: d008 beq.n 80005e4 <core::num::bignum::Big32x40::mul_digits+0x96>
+ &mut (*slice)[self]
+ 80005d2: 18b1 adds r1, r6, r2
+ 80005d4: 3901 subs r1, #1
+ 80005d6: 2928 cmp r1, #40 ; 0x28
+ 80005d8: f080 808e bcs.w 80006f8 <core::num::bignum::Big32x40::mul_digits+0x1aa>
+ ret[i + sz] = carry;
+ 80005dc: 9902 ldr r1, [sp, #8]
+ 80005de: f841 9022 str.w r9, [r1, r2, lsl #2]
+ 80005e2: 9901 ldr r1, [sp, #4]
+ if retsz < i + sz {
+ 80005e4: 4411 add r1, r2
+ 80005e6: 3901 subs r1, #1
+ 80005e8: 458a cmp sl, r1
+ 80005ea: bf38 it cc
+ 80005ec: 468a movcc sl, r1
+ 80005ee: e9dd 1903 ldrd r1, r9, [sp, #12]
+ let mut retsz = 0;
+ 80005f2: eb08 0c82 add.w ip, r8, r2, lsl #2
+ if self.ptr == self.end {
+ 80005f6: 429c cmp r4, r3
+ 80005f8: d073 beq.n 80006e2 <core::num::bignum::Big32x40::mul_digits+0x194>
+ for (i, &a) in aa.iter().enumerate() {
+ 80005fa: f854 eb04 ldr.w lr, [r4], #4
+ if a == 0 { continue; }
+ 80005fe: f10c 0c04 add.w ip, ip, #4
+ #[rustc_inherit_overflow_checks]
+ fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
+ self.iter.next().map(|a| {
+ let ret = (self.count, a);
+ // Possible undefined overflow.
+ self.count += 1;
+ 8000602: 3201 adds r2, #1
+ 8000604: f1be 0f00 cmp.w lr, #0
+ 8000608: d0f5 beq.n 80005f6 <core::num::bignum::Big32x40::mul_digits+0xa8>
+ 800060a: f8cd a018 str.w sl, [sp, #24]
+ 800060e: e9cd 9804 strd r9, r8, [sp, #16]
+ 8000612: f04f 0900 mov.w r9, #0
+ 8000616: 468a mov sl, r1
+ 8000618: f04f 0800 mov.w r8, #0
+ 800061c: 9103 str r1, [sp, #12]
+ &(*slice)[self]
+ 800061e: eb02 0108 add.w r1, r2, r8
+ 8000622: 3901 subs r1, #1
+ 8000624: 2928 cmp r1, #40 ; 0x28
+ 8000626: d267 bcs.n 80006f8 <core::num::bignum::Big32x40::mul_digits+0x1aa>
+ let v = (self as $bigty) * (other as $bigty) + (other2 as $bigty) +
+ 8000628: f85c 1028 ldr.w r1, [ip, r8, lsl #2]
+ 800062c: f855 b028 ldr.w fp, [r5, r8, lsl #2]
+ if self.ptr == self.end {
+ 8000630: f1ba 0a04 subs.w sl, sl, #4
+ 8000634: fbeb 196e umaal r1, r9, fp, lr
+ ret[i + j] = v;
+ 8000638: f84c 1028 str.w r1, [ip, r8, lsl #2]
+ 800063c: f108 0801 add.w r8, r8, #1
+ 8000640: d1ed bne.n 800061e <core::num::bignum::Big32x40::mul_digits+0xd0>
+ 8000642: e7c0 b.n 80005c6 <core::num::bignum::Big32x40::mul_digits+0x78>
+ 8000644: 46d1 mov r9, sl
+ 8000646: f8dd a018 ldr.w sl, [sp, #24]
+ if carry > 0 {
+ 800064a: f1bc 0f00 cmp.w ip, #0
+ 800064e: 4641 mov r1, r8
+ 8000650: d008 beq.n 8000664 <core::num::bignum::Big32x40::mul_digits+0x116>
+ &mut (*slice)[self]
+ 8000652: eb08 0106 add.w r1, r8, r6
+ 8000656: 1e4a subs r2, r1, #1
+ 8000658: 2a28 cmp r2, #40 ; 0x28
+ 800065a: d251 bcs.n 8000700 <core::num::bignum::Big32x40::mul_digits+0x1b2>
+ ret[i + sz] = carry;
+ 800065c: 9902 ldr r1, [sp, #8]
+ 800065e: f841 c026 str.w ip, [r1, r6, lsl #2]
+ 8000662: 9903 ldr r1, [sp, #12]
+ if retsz < i + sz {
+ 8000664: 4431 add r1, r6
+ 8000666: 3901 subs r1, #1
+ 8000668: 458a cmp sl, r1
+ 800066a: bf38 it cc
+ 800066c: 468a movcc sl, r1
+ 800066e: e9dd 2104 ldrd r2, r1, [sp, #16]
+ let mut retsz = 0;
+ 8000672: eb02 0486 add.w r4, r2, r6, lsl #2
+ if self.ptr == self.end {
+ 8000676: 455d cmp r5, fp
+ 8000678: d033 beq.n 80006e2 <core::num::bignum::Big32x40::mul_digits+0x194>
+ for (i, &a) in aa.iter().enumerate() {
+ 800067a: f855 eb04 ldr.w lr, [r5], #4
+ if a == 0 { continue; }
+ 800067e: 3404 adds r4, #4
+ 8000680: 3601 adds r6, #1
+ 8000682: f1be 0f00 cmp.w lr, #0
+ 8000686: d0f6 beq.n 8000676 <core::num::bignum::Big32x40::mul_digits+0x128>
+ 8000688: f8cd a018 str.w sl, [sp, #24]
+ 800068c: 46ca mov sl, r9
+ 800068e: f04f 0c00 mov.w ip, #0
+ 8000692: 9105 str r1, [sp, #20]
+ 8000694: 4689 mov r9, r1
+ 8000696: 2100 movs r1, #0
+ 8000698: 9204 str r2, [sp, #16]
+ &(*slice)[self]
+ 800069a: 1872 adds r2, r6, r1
+ 800069c: 3a01 subs r2, #1
+ 800069e: 2a28 cmp r2, #40 ; 0x28
+ 80006a0: d22e bcs.n 8000700 <core::num::bignum::Big32x40::mul_digits+0x1b2>
+ let v = (self as $bigty) * (other as $bigty) + (other2 as $bigty) +
+ 80006a2: f854 2021 ldr.w r2, [r4, r1, lsl #2]
+ 80006a6: f850 3021 ldr.w r3, [r0, r1, lsl #2]
+ if self.ptr == self.end {
+ 80006aa: f1b9 0904 subs.w r9, r9, #4
+ 80006ae: fbe3 2c6e umaal r2, ip, r3, lr
+ ret[i + j] = v;
+ 80006b2: f844 2021 str.w r2, [r4, r1, lsl #2]
+ 80006b6: f101 0101 add.w r1, r1, #1
+ 80006ba: d1ee bne.n 800069a <core::num::bignum::Big32x40::mul_digits+0x14c>
+ 80006bc: e7c2 b.n 8000644 <core::num::bignum::Big32x40::mul_digits+0xf6>
+ 80006be: 2100 movs r1, #0
+ 80006c0: f04f 0a00 mov.w sl, #0
+ 80006c4: 455d cmp r5, fp
+ 80006c6: d106 bne.n 80006d6 <core::num::bignum::Big32x40::mul_digits+0x188>
+ 80006c8: e00b b.n 80006e2 <core::num::bignum::Big32x40::mul_digits+0x194>
+ if retsz < i + sz {
+ 80006ca: 1e4a subs r2, r1, #1
+ 80006cc: 4592 cmp sl, r2
+ 80006ce: bf38 it cc
+ 80006d0: 4692 movcc sl, r2
+ 80006d2: 455d cmp r5, fp
+ 80006d4: d005 beq.n 80006e2 <core::num::bignum::Big32x40::mul_digits+0x194>
+ for (i, &a) in aa.iter().enumerate() {
+ 80006d6: f855 2b04 ldr.w r2, [r5], #4
+ 80006da: 3101 adds r1, #1
+ if a == 0 { continue; }
+ 80006dc: 2a00 cmp r2, #0
+ 80006de: d0f8 beq.n 80006d2 <core::num::bignum::Big32x40::mul_digits+0x184>
+ 80006e0: e7f3 b.n 80006ca <core::num::bignum::Big32x40::mul_digits+0x17c>
+ 80006e2: a907 add r1, sp, #28
+ mul_inner(&mut ret, &self.digits(), other)
+ } else {
+ mul_inner(&mut ret, other, &self.digits())
+ };
+ self.base = ret;
+ 80006e4: 22a0 movs r2, #160 ; 0xa0
+ 80006e6: f003 f9fd bl 8003ae4 <__aeabi_memcpy4>
+ self.size = retsz;
+ 80006ea: f8c9 a000 str.w sl, [r9]
+ self
+ }
+ 80006ee: 4648 mov r0, r9
+ 80006f0: b02f add sp, #188 ; 0xbc
+ 80006f2: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 80006f6: bdf0 pop {r4, r5, r6, r7, pc}
+ 80006f8: 4608 mov r0, r1
+ 80006fa: 2128 movs r1, #40 ; 0x28
+ 80006fc: f7ff ff23 bl 8000546 <core::panicking::panic_bounds_check>
+ 8000700: 4610 mov r0, r2
+ 8000702: 2128 movs r1, #40 ; 0x28
+ 8000704: f7ff ff1f bl 8000546 <core::panicking::panic_bounds_check>
+ slice_index_len_fail(self.end, slice.len());
+ 8000708: 4640 mov r0, r8
+ 800070a: 2128 movs r1, #40 ; 0x28
+ 800070c: f7ff ff17 bl 800053e <core::slice::slice_index_len_fail>
+
+08000710 <core::panicking::panic_fmt>:
+ _: ::core::fmt::Arguments,
+ _: &'static str,
+ _: u32,
+ _: u32,
+) -> ! {
+ ::core::intrinsics::abort()
+ 8000710: defe udf #254 ; 0xfe
+
+08000712 <core::fmt::Formatter::pad_integral>:
+ /// * buf - the byte array that the number has been formatted into
+ ///
+ /// This function will correctly account for the flags provided as well as
+ /// the minimum width. It will not take precision into account.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn pad_integral(&mut self,
+ 8000712: b5f0 push {r4, r5, r6, r7, lr}
+ 8000714: af03 add r7, sp, #12
+ 8000716: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 800071a: b087 sub sp, #28
+ 800071c: 4681 mov r9, r0
+ 800071e: 468b mov fp, r1
+ 8000720: 4690 mov r8, r2
+ 8000722: f8d9 0000 ldr.w r0, [r9]
+
+ // The `width` field is more of a `min-width` parameter at this point.
+ match self.width {
+ // If there's no minimum length requirements then we can just
+ // write the bytes.
+ None => {
+ 8000726: f8d9 1008 ldr.w r1, [r9, #8]
+ } else if self.sign_plus() {
+ 800072a: 4645 mov r5, r8
+ #[stable(feature = "fmt_flags", since = "1.5.0")]
+ pub fn precision(&self) -> Option<usize> { self.precision }
+
+ /// Determines if the `+` flag was specified.
+ #[stable(feature = "fmt_flags", since = "1.5.0")]
+ pub fn sign_plus(&self) -> bool { self.flags & (1 << FlagV1::SignPlus as u32) != 0 }
+ 800072c: f010 0401 ands.w r4, r0, #1
+ } else if self.sign_plus() {
+ 8000730: bf18 it ne
+ 8000732: 3501 addne r5, #1
+ if self.alternate() {
+ 8000734: f3c0 0a80 ubfx sl, r0, #2, #1
+ 8000738: b1d9 cbz r1, 8000772 <core::fmt::Formatter::pad_integral+0x60>
+ Some(min) if width >= min => {
+ 800073a: f8d9 600c ldr.w r6, [r9, #12]
+ 800073e: 42ae cmp r6, r5
+ 8000740: d92c bls.n 800079c <core::fmt::Formatter::pad_integral+0x8a>
+ Some(min) if self.sign_aware_zero_pad() => {
+ 8000742: 0700 lsls r0, r0, #28
+ 8000744: d455 bmi.n 80007f2 <core::fmt::Formatter::pad_integral+0xe0>
+ rt::v1::Alignment::Unknown => default,
+ 8000746: f899 0030 ldrb.w r0, [r9, #48] ; 0x30
+ self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
+ 800074a: 1b76 subs r6, r6, r5
+ rt::v1::Alignment::Unknown => default,
+ 800074c: 2803 cmp r0, #3
+ 800074e: bf08 it eq
+ 8000750: 2001 moveq r0, #1
+ 8000752: f8cd 8010 str.w r8, [sp, #16]
+ 8000756: f010 0103 ands.w r1, r0, #3
+ 800075a: f04f 0000 mov.w r0, #0
+ 800075e: f000 8088 beq.w 8000872 <core::fmt::Formatter::pad_integral+0x160>
+ 8000762: 2902 cmp r1, #2
+ 8000764: f040 8088 bne.w 8000878 <core::fmt::Formatter::pad_integral+0x166>
+ rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2),
+ 8000768: 1c71 adds r1, r6, #1
+ 800076a: ea4f 0856 mov.w r8, r6, lsr #1
+ 800076e: 084e lsrs r6, r1, #1
+ 8000770: e084 b.n 800087c <core::fmt::Formatter::pad_integral+0x16a>
+ 8000772: b17c cbz r4, 8000794 <core::fmt::Formatter::pad_integral+0x82>
+ f.buf.write_str(c.encode_utf8(&mut [0; 4]))?;
+ 8000774: e9d9 0106 ldrd r0, r1, [r9, #24]
+ 8000778: 2200 movs r2, #0
+ 800077a: 2401 movs r4, #1
+ 800077c: 9206 str r2, [sp, #24]
+ *dst.get_unchecked_mut(0) = code as u8;
+ 800077e: 222b movs r2, #43 ; 0x2b
+ 8000780: f88d 2018 strb.w r2, [sp, #24]
+ 8000784: 2201 movs r2, #1
+ 8000786: 68cb ldr r3, [r1, #12]
+ 8000788: a906 add r1, sp, #24
+ 800078a: 4798 blx r3
+ 800078c: f010 0fff tst.w r0, #255 ; 0xff
+ 8000790: f040 8193 bne.w 8000aba <core::fmt::Formatter::pad_integral+0x3a8>
+ if prefixed { f.buf.write_str(prefix) }
+ 8000794: f1ba 0f00 cmp.w sl, #0
+ 8000798: d114 bne.n 80007c4 <core::fmt::Formatter::pad_integral+0xb2>
+ 800079a: e020 b.n 80007de <core::fmt::Formatter::pad_integral+0xcc>
+ 800079c: b17c cbz r4, 80007be <core::fmt::Formatter::pad_integral+0xac>
+ f.buf.write_str(c.encode_utf8(&mut [0; 4]))?;
+ 800079e: e9d9 0106 ldrd r0, r1, [r9, #24]
+ 80007a2: 2200 movs r2, #0
+ 80007a4: 2401 movs r4, #1
+ 80007a6: 9206 str r2, [sp, #24]
+ 80007a8: 222b movs r2, #43 ; 0x2b
+ 80007aa: f88d 2018 strb.w r2, [sp, #24]
+ 80007ae: 2201 movs r2, #1
+ 80007b0: 68cb ldr r3, [r1, #12]
+ 80007b2: a906 add r1, sp, #24
+ 80007b4: 4798 blx r3
+ 80007b6: f010 0fff tst.w r0, #255 ; 0xff
+ 80007ba: f040 817e bne.w 8000aba <core::fmt::Formatter::pad_integral+0x3a8>
+ if prefixed { f.buf.write_str(prefix) }
+ 80007be: f1ba 0f00 cmp.w sl, #0
+ 80007c2: d00c beq.n 80007de <core::fmt::Formatter::pad_integral+0xcc>
+ 80007c4: e9d9 0106 ldrd r0, r1, [r9, #24]
+ 80007c8: 2200 movs r2, #0
+ 80007ca: 68cb ldr r3, [r1, #12]
+ 80007cc: f244 4198 movw r1, #17560 ; 0x4498
+ 80007d0: f6c0 0100 movt r1, #2048 ; 0x800
+ 80007d4: 4798 blx r3
+ 80007d6: f010 0fff tst.w r0, #255 ; 0xff
+ 80007da: f040 816d bne.w 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ 80007de: f8d9 101c ldr.w r1, [r9, #28]
+ 80007e2: f8d9 0018 ldr.w r0, [r9, #24]
+ 80007e6: 4642 mov r2, r8
+ 80007e8: 68cb ldr r3, [r1, #12]
+ 80007ea: 4659 mov r1, fp
+ 80007ec: 4798 blx r3
+ 80007ee: 4604 mov r4, r0
+ 80007f0: e163 b.n 8000aba <core::fmt::Formatter::pad_integral+0x3a8>
+ 80007f2: 2030 movs r0, #48 ; 0x30
+ if let Some(c) = sign {
+ 80007f4: 2c00 cmp r4, #0
+ self.fill = '0';
+ 80007f6: f8c9 0004 str.w r0, [r9, #4]
+ self.align = rt::v1::Alignment::Right;
+ 80007fa: f04f 0001 mov.w r0, #1
+ 80007fe: f889 0030 strb.w r0, [r9, #48] ; 0x30
+ 8000802: d00f beq.n 8000824 <core::fmt::Formatter::pad_integral+0x112>
+ f.buf.write_str(c.encode_utf8(&mut [0; 4]))?;
+ 8000804: e9d9 0106 ldrd r0, r1, [r9, #24]
+ 8000808: 2200 movs r2, #0
+ 800080a: 2401 movs r4, #1
+ 800080c: 9206 str r2, [sp, #24]
+ 800080e: 222b movs r2, #43 ; 0x2b
+ 8000810: f88d 2018 strb.w r2, [sp, #24]
+ 8000814: 2201 movs r2, #1
+ 8000816: 68cb ldr r3, [r1, #12]
+ 8000818: a906 add r1, sp, #24
+ 800081a: 4798 blx r3
+ 800081c: f010 0fff tst.w r0, #255 ; 0xff
+ 8000820: f040 814b bne.w 8000aba <core::fmt::Formatter::pad_integral+0x3a8>
+ if prefixed { f.buf.write_str(prefix) }
+ 8000824: f1ba 0f00 cmp.w sl, #0
+ 8000828: d00c beq.n 8000844 <core::fmt::Formatter::pad_integral+0x132>
+ 800082a: e9d9 0106 ldrd r0, r1, [r9, #24]
+ 800082e: 2200 movs r2, #0
+ 8000830: 68cb ldr r3, [r1, #12]
+ 8000832: f244 4198 movw r1, #17560 ; 0x4498
+ 8000836: f6c0 0100 movt r1, #2048 ; 0x800
+ 800083a: 4798 blx r3
+ write_prefix(self)?;
+ 800083c: f010 0fff tst.w r0, #255 ; 0xff
+ 8000840: f040 813a bne.w 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ rt::v1::Alignment::Unknown => default,
+ 8000844: f899 0030 ldrb.w r0, [r9, #48] ; 0x30
+ self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
+ 8000848: eba6 0a05 sub.w sl, r6, r5
+ rt::v1::Alignment::Unknown => default,
+ 800084c: 2803 cmp r0, #3
+ 800084e: bf08 it eq
+ 8000850: 2001 moveq r0, #1
+ 8000852: f8cd 8010 str.w r8, [sp, #16]
+ 8000856: f010 0103 ands.w r1, r0, #3
+ 800085a: f04f 0000 mov.w r0, #0
+ 800085e: d042 beq.n 80008e6 <core::fmt::Formatter::pad_integral+0x1d4>
+ 8000860: 2902 cmp r1, #2
+ 8000862: d143 bne.n 80008ec <core::fmt::Formatter::pad_integral+0x1da>
+ rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2),
+ 8000864: f10a 0101 add.w r1, sl, #1
+ 8000868: ea4f 085a mov.w r8, sl, lsr #1
+ 800086c: ea4f 0a51 mov.w sl, r1, lsr #1
+ 8000870: e03f b.n 80008f2 <core::fmt::Formatter::pad_integral+0x1e0>
+ 8000872: f04f 0800 mov.w r8, #0
+ 8000876: e001 b.n 800087c <core::fmt::Formatter::pad_integral+0x16a>
+ 8000878: 46b0 mov r8, r6
+ 800087a: 2600 movs r6, #0
+ let mut fill = [0; 4];
+ 800087c: 9005 str r0, [sp, #20]
+ let fill = self.fill.encode_utf8(&mut fill);
+ 800087e: f8d9 0004 ldr.w r0, [r9, #4]
+ if code < MAX_ONE_B && !dst.is_empty() {
+ 8000882: e9cd 6a00 strd r6, sl, [sp]
+ 8000886: e9cd 4b02 strd r4, fp, [sp, #8]
+ 800088a: 287f cmp r0, #127 ; 0x7f
+ 800088c: d804 bhi.n 8000898 <core::fmt::Formatter::pad_integral+0x186>
+ *dst.get_unchecked_mut(0) = code as u8;
+ 800088e: f88d 0014 strb.w r0, [sp, #20]
+ 8000892: f04f 0a01 mov.w sl, #1
+ 8000896: e066 b.n 8000966 <core::fmt::Formatter::pad_integral+0x254>
+ } else if code < MAX_TWO_B && dst.len() >= 2 {
+ 8000898: 2100 movs r1, #0
+ 800089a: ebb1 2fd0 cmp.w r1, r0, lsr #11
+ 800089e: d10b bne.n 80008b8 <core::fmt::Formatter::pad_integral+0x1a6>
+ *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+ 80008a0: f64f 72fe movw r2, #65534 ; 0xfffe
+ 80008a4: 0981 lsrs r1, r0, #6
+ 80008a6: f04f 0a02 mov.w sl, #2
+ 80008aa: ab05 add r3, sp, #20
+ 80008ac: f2c0 72ff movt r2, #2047 ; 0x7ff
+ 80008b0: f362 115f bfi r1, r2, #5, #27
+ 80008b4: 2201 movs r2, #1
+ 80008b6: e050 b.n 800095a <core::fmt::Formatter::pad_integral+0x248>
+ } else if code < MAX_THREE_B && dst.len() >= 3 {
+ 80008b8: ebb1 4f10 cmp.w r1, r0, lsr #16
+ 80008bc: d135 bne.n 800092a <core::fmt::Formatter::pad_integral+0x218>
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 80008be: 0b01 lsrs r1, r0, #12
+ 80008c0: 220e movs r2, #14
+ 80008c2: f04f 0a03 mov.w sl, #3
+ 80008c6: f362 111f bfi r1, r2, #4, #28
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 80008ca: f64f 72fe movw r2, #65534 ; 0xfffe
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 80008ce: f88d 1014 strb.w r1, [sp, #20]
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 80008d2: 0981 lsrs r1, r0, #6
+ 80008d4: f2c0 32ff movt r2, #1023 ; 0x3ff
+ 80008d8: f362 119f bfi r1, r2, #6, #26
+ 80008dc: aa05 add r2, sp, #20
+ intrinsics::offset(self, count) as *mut T
+ 80008de: f042 0301 orr.w r3, r2, #1
+ 80008e2: 2202 movs r2, #2
+ 80008e4: e039 b.n 800095a <core::fmt::Formatter::pad_integral+0x248>
+ 80008e6: f04f 0800 mov.w r8, #0
+ 80008ea: e002 b.n 80008f2 <core::fmt::Formatter::pad_integral+0x1e0>
+ 80008ec: 46d0 mov r8, sl
+ 80008ee: f04f 0a00 mov.w sl, #0
+ let mut fill = [0; 4];
+ 80008f2: 9006 str r0, [sp, #24]
+ let fill = self.fill.encode_utf8(&mut fill);
+ 80008f4: f8d9 0004 ldr.w r0, [r9, #4]
+ if code < MAX_ONE_B && !dst.is_empty() {
+ 80008f8: f8cd b00c str.w fp, [sp, #12]
+ 80008fc: 287f cmp r0, #127 ; 0x7f
+ 80008fe: d804 bhi.n 800090a <core::fmt::Formatter::pad_integral+0x1f8>
+ *dst.get_unchecked_mut(0) = code as u8;
+ 8000900: f88d 0018 strb.w r0, [sp, #24]
+ 8000904: f04f 0b01 mov.w fp, #1
+ 8000908: e0b6 b.n 8000a78 <core::fmt::Formatter::pad_integral+0x366>
+ } else if code < MAX_TWO_B && dst.len() >= 2 {
+ 800090a: 2100 movs r1, #0
+ 800090c: ebb1 2fd0 cmp.w r1, r0, lsr #11
+ 8000910: d17b bne.n 8000a0a <core::fmt::Formatter::pad_integral+0x2f8>
+ *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+ 8000912: f64f 72fe movw r2, #65534 ; 0xfffe
+ 8000916: 0981 lsrs r1, r0, #6
+ 8000918: f04f 0b02 mov.w fp, #2
+ 800091c: ab06 add r3, sp, #24
+ 800091e: f2c0 72ff movt r2, #2047 ; 0x7ff
+ 8000922: f362 115f bfi r1, r2, #5, #27
+ 8000926: 2201 movs r2, #1
+ 8000928: e0a0 b.n 8000a6c <core::fmt::Formatter::pad_integral+0x35a>
+ *dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+ 800092a: 21f0 movs r1, #240 ; 0xf0
+ 800092c: 2202 movs r2, #2
+ 800092e: f04f 0a04 mov.w sl, #4
+ 8000932: ea41 4190 orr.w r1, r1, r0, lsr #18
+ 8000936: f88d 1014 strb.w r1, [sp, #20]
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 800093a: 0b01 lsrs r1, r0, #12
+ 800093c: f362 119f bfi r1, r2, #6, #26
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000940: f64f 72fe movw r2, #65534 ; 0xfffe
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 8000944: f88d 1015 strb.w r1, [sp, #21]
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000948: 0981 lsrs r1, r0, #6
+ 800094a: f2c0 32ff movt r2, #1023 ; 0x3ff
+ 800094e: f362 119f bfi r1, r2, #6, #26
+ 8000952: aa05 add r2, sp, #20
+ 8000954: f042 0302 orr.w r3, r2, #2
+ 8000958: 2203 movs r2, #3
+ 800095a: 7019 strb r1, [r3, #0]
+ 800095c: 2102 movs r1, #2
+ 800095e: f361 109f bfi r0, r1, #6, #26
+ 8000962: a905 add r1, sp, #20
+ 8000964: 5488 strb r0, [r1, r2]
+ 8000966: e9d9 b506 ldrd fp, r5, [r9, #24]
+ 800096a: 2000 movs r0, #0
+ 800096c: ae05 add r6, sp, #20
+impl<A: Step> Iterator for ops::Range<A> {
+ type Item = A;
+
+ #[inline]
+ fn next(&mut self) -> Option<A> {
+ if self.start < self.end {
+ 800096e: 4540 cmp r0, r8
+ 8000970: d210 bcs.n 8000994 <core::fmt::Formatter::pad_integral+0x282>
+ /// ```
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_add(self, rhs: Self) -> (Self, bool) {
+ unsafe {
+ let (a, b) = $add_with_overflow(self as $ActualT,
+ 8000972: 1c44 adds r4, r0, #1
+ 8000974: 4284 cmp r4, r0
+ 8000976: f04f 0001 mov.w r0, #1
+ 800097a: bf28 it cs
+ 800097c: 2000 movcs r0, #0
+ 800097e: b948 cbnz r0, 8000994 <core::fmt::Formatter::pad_integral+0x282>
+ self.buf.write_str(fill)?;
+ 8000980: 68eb ldr r3, [r5, #12]
+ 8000982: 4658 mov r0, fp
+ 8000984: 4631 mov r1, r6
+ 8000986: 4652 mov r2, sl
+ 8000988: 4798 blx r3
+ 800098a: f010 0fff tst.w r0, #255 ; 0xff
+ 800098e: 4620 mov r0, r4
+ 8000990: d0ed beq.n 800096e <core::fmt::Formatter::pad_integral+0x25c>
+ 8000992: e091 b.n 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ if let Some(c) = sign {
+ 8000994: 9802 ldr r0, [sp, #8]
+ 8000996: b908 cbnz r0, 800099c <core::fmt::Formatter::pad_integral+0x28a>
+ 8000998: 68ee ldr r6, [r5, #12]
+ 800099a: e00d b.n 80009b8 <core::fmt::Formatter::pad_integral+0x2a6>
+ 800099c: 2000 movs r0, #0
+ 800099e: a906 add r1, sp, #24
+ f.buf.write_str(c.encode_utf8(&mut [0; 4]))?;
+ 80009a0: 2201 movs r2, #1
+ 80009a2: 9006 str r0, [sp, #24]
+ *dst.get_unchecked_mut(0) = code as u8;
+ 80009a4: 202b movs r0, #43 ; 0x2b
+ 80009a6: f88d 0018 strb.w r0, [sp, #24]
+ 80009aa: 4658 mov r0, fp
+ 80009ac: 68ee ldr r6, [r5, #12]
+ 80009ae: 47b0 blx r6
+ 80009b0: f010 0fff tst.w r0, #255 ; 0xff
+ 80009b4: f040 8080 bne.w 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ if prefixed { f.buf.write_str(prefix) }
+ 80009b8: 9801 ldr r0, [sp, #4]
+ 80009ba: b148 cbz r0, 80009d0 <core::fmt::Formatter::pad_integral+0x2be>
+ 80009bc: f244 4198 movw r1, #17560 ; 0x4498
+ 80009c0: 4658 mov r0, fp
+ 80009c2: 2200 movs r2, #0
+ 80009c4: f6c0 0100 movt r1, #2048 ; 0x800
+ 80009c8: 47b0 blx r6
+ write_prefix(f)?; f.buf.write_str(buf)
+ 80009ca: f010 0fff tst.w r0, #255 ; 0xff
+ 80009ce: d173 bne.n 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ 80009d0: e9dd 1203 ldrd r1, r2, [sp, #12]
+ 80009d4: 4658 mov r0, fp
+ 80009d6: 47b0 blx r6
+ f(self)?;
+ 80009d8: f010 0fff tst.w r0, #255 ; 0xff
+ 80009dc: d16c bne.n 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ 80009de: 9d00 ldr r5, [sp, #0]
+ 80009e0: 2000 movs r0, #0
+ 80009e2: f10d 0814 add.w r8, sp, #20
+ 80009e6: 42a8 cmp r0, r5
+ 80009e8: d226 bcs.n 8000a38 <core::fmt::Formatter::pad_integral+0x326>
+ 80009ea: 1c44 adds r4, r0, #1
+ 80009ec: 4284 cmp r4, r0
+ 80009ee: f04f 0001 mov.w r0, #1
+ 80009f2: bf28 it cs
+ 80009f4: 2000 movcs r0, #0
+ 80009f6: b9f8 cbnz r0, 8000a38 <core::fmt::Formatter::pad_integral+0x326>
+ self.buf.write_str(fill)?;
+ 80009f8: 4658 mov r0, fp
+ 80009fa: 4641 mov r1, r8
+ 80009fc: 4652 mov r2, sl
+ 80009fe: 47b0 blx r6
+ 8000a00: f010 0fff tst.w r0, #255 ; 0xff
+ 8000a04: 4620 mov r0, r4
+ 8000a06: d0ee beq.n 80009e6 <core::fmt::Formatter::pad_integral+0x2d4>
+ 8000a08: e056 b.n 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ } else if code < MAX_THREE_B && dst.len() >= 3 {
+ 8000a0a: ebb1 4f10 cmp.w r1, r0, lsr #16
+ 8000a0e: d115 bne.n 8000a3c <core::fmt::Formatter::pad_integral+0x32a>
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 8000a10: 0b01 lsrs r1, r0, #12
+ 8000a12: 220e movs r2, #14
+ 8000a14: f04f 0b03 mov.w fp, #3
+ 8000a18: f362 111f bfi r1, r2, #4, #28
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000a1c: f64f 72fe movw r2, #65534 ; 0xfffe
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 8000a20: f88d 1018 strb.w r1, [sp, #24]
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000a24: 0981 lsrs r1, r0, #6
+ 8000a26: f2c0 32ff movt r2, #1023 ; 0x3ff
+ 8000a2a: f362 119f bfi r1, r2, #6, #26
+ 8000a2e: aa06 add r2, sp, #24
+ 8000a30: f042 0301 orr.w r3, r2, #1
+ 8000a34: 2202 movs r2, #2
+ 8000a36: e019 b.n 8000a6c <core::fmt::Formatter::pad_integral+0x35a>
+ 8000a38: 2400 movs r4, #0
+ 8000a3a: e03e b.n 8000aba <core::fmt::Formatter::pad_integral+0x3a8>
+ *dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+ 8000a3c: 21f0 movs r1, #240 ; 0xf0
+ 8000a3e: 2202 movs r2, #2
+ 8000a40: f04f 0b04 mov.w fp, #4
+ 8000a44: ea41 4190 orr.w r1, r1, r0, lsr #18
+ 8000a48: f88d 1018 strb.w r1, [sp, #24]
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 8000a4c: 0b01 lsrs r1, r0, #12
+ 8000a4e: f362 119f bfi r1, r2, #6, #26
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000a52: f64f 72fe movw r2, #65534 ; 0xfffe
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 8000a56: f88d 1019 strb.w r1, [sp, #25]
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8000a5a: 0981 lsrs r1, r0, #6
+ 8000a5c: f2c0 32ff movt r2, #1023 ; 0x3ff
+ 8000a60: f362 119f bfi r1, r2, #6, #26
+ 8000a64: aa06 add r2, sp, #24
+ 8000a66: f042 0302 orr.w r3, r2, #2
+ 8000a6a: 2203 movs r2, #3
+ 8000a6c: 7019 strb r1, [r3, #0]
+ 8000a6e: 2102 movs r1, #2
+ 8000a70: f361 109f bfi r0, r1, #6, #26
+ 8000a74: a906 add r1, sp, #24
+ 8000a76: 5488 strb r0, [r1, r2]
+ 8000a78: e9d9 4506 ldrd r4, r5, [r9, #24]
+ 8000a7c: 2000 movs r0, #0
+ 8000a7e: f10d 0918 add.w r9, sp, #24
+ 8000a82: 4540 cmp r0, r8
+ 8000a84: d210 bcs.n 8000aa8 <core::fmt::Formatter::pad_integral+0x396>
+ 8000a86: 1c46 adds r6, r0, #1
+ 8000a88: 4286 cmp r6, r0
+ 8000a8a: f04f 0001 mov.w r0, #1
+ 8000a8e: bf28 it cs
+ 8000a90: 2000 movcs r0, #0
+ 8000a92: b948 cbnz r0, 8000aa8 <core::fmt::Formatter::pad_integral+0x396>
+ self.buf.write_str(fill)?;
+ 8000a94: 68eb ldr r3, [r5, #12]
+ 8000a96: 4620 mov r0, r4
+ 8000a98: 4649 mov r1, r9
+ 8000a9a: 465a mov r2, fp
+ 8000a9c: 4798 blx r3
+ 8000a9e: f010 0fff tst.w r0, #255 ; 0xff
+ 8000aa2: 4630 mov r0, r6
+ 8000aa4: d0ed beq.n 8000a82 <core::fmt::Formatter::pad_integral+0x370>
+ 8000aa6: e007 b.n 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ f.buf.write_str(buf)
+ 8000aa8: 68ee ldr r6, [r5, #12]
+ 8000aaa: e9dd 1203 ldrd r1, r2, [sp, #12]
+ 8000aae: 4620 mov r0, r4
+ 8000ab0: 47b0 blx r6
+ f(self)?;
+ 8000ab2: f010 0fff tst.w r0, #255 ; 0xff
+ 8000ab6: d005 beq.n 8000ac4 <core::fmt::Formatter::pad_integral+0x3b2>
+ 8000ab8: 2401 movs r4, #1
+ }
+ 8000aba: 4620 mov r0, r4
+ 8000abc: b007 add sp, #28
+ 8000abe: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8000ac2: bdf0 pop {r4, r5, r6, r7, pc}
+ 8000ac4: 2000 movs r0, #0
+ 8000ac6: f10d 0818 add.w r8, sp, #24
+ 8000aca: 4550 cmp r0, sl
+ 8000acc: d20f bcs.n 8000aee <core::fmt::Formatter::pad_integral+0x3dc>
+ 8000ace: 1c45 adds r5, r0, #1
+ 8000ad0: 4285 cmp r5, r0
+ 8000ad2: f04f 0001 mov.w r0, #1
+ 8000ad6: bf28 it cs
+ 8000ad8: 2000 movcs r0, #0
+ 8000ada: b940 cbnz r0, 8000aee <core::fmt::Formatter::pad_integral+0x3dc>
+ self.buf.write_str(fill)?;
+ 8000adc: 4620 mov r0, r4
+ 8000ade: 4641 mov r1, r8
+ 8000ae0: 465a mov r2, fp
+ 8000ae2: 47b0 blx r6
+ 8000ae4: f010 0fff tst.w r0, #255 ; 0xff
+ 8000ae8: 4628 mov r0, r5
+ 8000aea: d0ee beq.n 8000aca <core::fmt::Formatter::pad_integral+0x3b8>
+ 8000aec: e7e4 b.n 8000ab8 <core::fmt::Formatter::pad_integral+0x3a6>
+ 8000aee: 2400 movs r4, #0
+ 8000af0: e7e3 b.n 8000aba <core::fmt::Formatter::pad_integral+0x3a8>
+
+08000af2 <core::panicking::panic>:
+pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
+ 8000af2: b580 push {r7, lr}
+ 8000af4: 466f mov r7, sp
+ panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
+ 8000af6: f7ff fe0b bl 8000710 <core::panicking::panic_fmt>
+
+08000afa <core::num::bignum::Big32x40::mul_pow2>:
+ pub fn mul_pow2(&mut self, bits: usize) -> &mut $name {
+ 8000afa: b5f0 push {r4, r5, r6, r7, lr}
+ 8000afc: af03 add r7, sp, #12
+ 8000afe: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8000b02: b081 sub sp, #4
+ assert!(digits < $n);
+ 8000b04: f5b1 6fa0 cmp.w r1, #1280 ; 0x500
+ 8000b08: d273 bcs.n 8000bf2 <core::num::bignum::Big32x40::mul_pow2+0xf8>
+ for i in (0..self.size).rev() {
+ 8000b0a: 6806 ldr r6, [r0, #0]
+ let digits = bits / digitbits;
+ 8000b0c: ea4f 1c51 mov.w ip, r1, lsr #5
+ 8000b10: b186 cbz r6, 8000b34 <core::num::bignum::Big32x40::mul_pow2+0x3a>
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+ 8000b12: eb00 058c add.w r5, r0, ip, lsl #2
+ impl Sub for $t {
+ type Output = $t;
+
+ #[inline]
+ #[rustc_inherit_overflow_checks]
+ fn sub(self, other: $t) -> $t { self - other }
+ 8000b16: 1e72 subs r2, r6, #1
+ self.base[i+digits] = self.base[i];
+ 8000b18: 2a27 cmp r2, #39 ; 0x27
+ 8000b1a: d85e bhi.n 8000bda <core::num::bignum::Big32x40::mul_pow2+0xe0>
+ &mut (*slice)[self]
+ 8000b1c: eb0c 0306 add.w r3, ip, r6
+ 8000b20: 3b01 subs r3, #1
+ 8000b22: 2b28 cmp r3, #40 ; 0x28
+ 8000b24: d25d bcs.n 8000be2 <core::num::bignum::Big32x40::mul_pow2+0xe8>
+ 8000b26: f850 3026 ldr.w r3, [r0, r6, lsl #2]
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<A: Step> DoubleEndedIterator for ops::Range<A> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> {
+ if self.start < self.end {
+ 8000b2a: 2a00 cmp r2, #0
+ 8000b2c: f845 3026 str.w r3, [r5, r6, lsl #2]
+ 8000b30: 4616 mov r6, r2
+ 8000b32: d1f0 bne.n 8000b16 <core::num::bignum::Big32x40::mul_pow2+0x1c>
+ if self.start < self.end {
+ 8000b34: f1bc 0f00 cmp.w ip, #0
+ 8000b38: d00a beq.n 8000b50 <core::num::bignum::Big32x40::mul_pow2+0x56>
+// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT
+ 8000b3a: 1d03 adds r3, r0, #4
+ 8000b3c: 2600 movs r6, #0
+ 8000b3e: 2200 movs r2, #0
+ self.base[i] = 0;
+ 8000b40: 2a27 cmp r2, #39 ; 0x27
+ 8000b42: d84a bhi.n 8000bda <core::num::bignum::Big32x40::mul_pow2+0xe0>
+ 8000b44: 1c55 adds r5, r2, #1
+ 8000b46: f843 6022 str.w r6, [r3, r2, lsl #2]
+ if self.start < self.end {
+ 8000b4a: 4565 cmp r5, ip
+ 8000b4c: 462a mov r2, r5
+ 8000b4e: d3f7 bcc.n 8000b40 <core::num::bignum::Big32x40::mul_pow2+0x46>
+ let mut sz = self.size + digits;
+ 8000b50: 6802 ldr r2, [r0, #0]
+ let bits = bits % digitbits;
+ 8000b52: f011 081f ands.w r8, r1, #31
+ let mut sz = self.size + digits;
+ 8000b56: 4462 add r2, ip
+ 8000b58: d016 beq.n 8000b88 <core::num::bignum::Big32x40::mul_pow2+0x8e>
+ let overflow = self.base[last-1] >> (digitbits - bits);
+ 8000b5a: f1a2 0e01 sub.w lr, r2, #1
+ &(*slice)[self]
+ 8000b5e: f1be 0f28 cmp.w lr, #40 ; 0x28
+ 8000b62: d24c bcs.n 8000bfe <core::num::bignum::Big32x40::mul_pow2+0x104>
+ 8000b64: eb00 038e add.w r3, r0, lr, lsl #2
+ 8000b68: 4249 negs r1, r1
+ 8000b6a: f8d3 b004 ldr.w fp, [r3, #4]
+ 8000b6e: f001 091f and.w r9, r1, #31
+ 8000b72: fa3b f109 lsrs.w r1, fp, r9
+ 8000b76: d009 beq.n 8000b8c <core::num::bignum::Big32x40::mul_pow2+0x92>
+ self.base[last] = overflow;
+ 8000b78: 2a27 cmp r2, #39 ; 0x27
+ 8000b7a: d82e bhi.n 8000bda <core::num::bignum::Big32x40::mul_pow2+0xe0>
+ 8000b7c: eb00 0682 add.w r6, r0, r2, lsl #2
+ sz += 1;
+ 8000b80: f102 0e01 add.w lr, r2, #1
+ self.base[last] = overflow;
+ 8000b84: 6071 str r1, [r6, #4]
+ 8000b86: e002 b.n 8000b8e <core::num::bignum::Big32x40::mul_pow2+0x94>
+ 8000b88: 4696 mov lr, r2
+ 8000b8a: e020 b.n 8000bce <core::num::bignum::Big32x40::mul_pow2+0xd4>
+ 8000b8c: 4696 mov lr, r2
+ for i in (digits+1..last).rev() {
+ 8000b8e: f10c 0a01 add.w sl, ip, #1
+ if self.start < self.end {
+ 8000b92: 4592 cmp sl, r2
+ 8000b94: d215 bcs.n 8000bc2 <core::num::bignum::Big32x40::mul_pow2+0xc8>
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+ 8000b96: eb00 0682 add.w r6, r0, r2, lsl #2
+ 8000b9a: 1e91 subs r1, r2, #2
+ self.base[i] = (self.base[i] << bits) |
+ 8000b9c: 1c4a adds r2, r1, #1
+ 8000b9e: 2a27 cmp r2, #39 ; 0x27
+ 8000ba0: d81b bhi.n 8000bda <core::num::bignum::Big32x40::mul_pow2+0xe0>
+ 8000ba2: 2928 cmp r1, #40 ; 0x28
+ 8000ba4: d221 bcs.n 8000bea <core::num::bignum::Big32x40::mul_pow2+0xf0>
+ (self.base[i-1] >> (digitbits - bits));
+ 8000ba6: 4635 mov r5, r6
+ self.base[i] = (self.base[i] << bits) |
+ 8000ba8: fa0b f308 lsl.w r3, fp, r8
+ #[inline]
+ fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
+ Some(self.cmp(other))
+ }
+ #[inline]
+ fn lt(&self, other: &$t) -> bool { (*self) < (*other) }
+ 8000bac: 3901 subs r1, #1
+ 8000bae: 4592 cmp sl, r2
+ (self.base[i-1] >> (digitbits - bits));
+ 8000bb0: f855 bd04 ldr.w fp, [r5, #-4]!
+ 8000bb4: fa2b f409 lsr.w r4, fp, r9
+ self.base[i] = (self.base[i] << bits) |
+ 8000bb8: ea43 0304 orr.w r3, r3, r4
+ 8000bbc: 6033 str r3, [r6, #0]
+ 8000bbe: 462e mov r6, r5
+ 8000bc0: d3ec bcc.n 8000b9c <core::num::bignum::Big32x40::mul_pow2+0xa2>
+ self.base[digits] <<= bits;
+ 8000bc2: eb00 018c add.w r1, r0, ip, lsl #2
+ 8000bc6: 684a ldr r2, [r1, #4]
+ 8000bc8: fa02 f208 lsl.w r2, r2, r8
+ 8000bcc: 604a str r2, [r1, #4]
+ self.size = sz;
+ 8000bce: f8c0 e000 str.w lr, [r0]
+ }
+ 8000bd2: b001 add sp, #4
+ 8000bd4: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8000bd8: bdf0 pop {r4, r5, r6, r7, pc}
+ 8000bda: 4610 mov r0, r2
+ 8000bdc: 2128 movs r1, #40 ; 0x28
+ 8000bde: f7ff fcb2 bl 8000546 <core::panicking::panic_bounds_check>
+ &mut (*slice)[self]
+ 8000be2: 4618 mov r0, r3
+ 8000be4: 2128 movs r1, #40 ; 0x28
+ 8000be6: f7ff fcae bl 8000546 <core::panicking::panic_bounds_check>
+ &(*slice)[self]
+ 8000bea: 4608 mov r0, r1
+ 8000bec: 2128 movs r1, #40 ; 0x28
+ 8000bee: f7ff fcaa bl 8000546 <core::panicking::panic_bounds_check>
+ assert!(digits < $n);
+ 8000bf2: f244 604c movw r0, #17996 ; 0x464c
+ 8000bf6: f6c0 0000 movt r0, #2048 ; 0x800
+ 8000bfa: f7ff ff7a bl 8000af2 <core::panicking::panic>
+ 8000bfe: 4670 mov r0, lr
+ 8000c00: 2128 movs r1, #40 ; 0x28
+ 8000c02: f7ff fca0 bl 8000546 <core::panicking::panic_bounds_check>
+
+08000c06 <core::num::flt2dec::round_up>:
+pub const MAX_SIG_DIGITS: usize = 17;
+
+/// When `d[..n]` contains decimal digits, increase the last digit and propagate carry.
+/// Returns a next digit when it causes the length change.
+#[doc(hidden)]
+pub fn round_up(d: &mut [u8], n: usize) -> Option<u8> {
+ 8000c06: b5d0 push {r4, r6, r7, lr}
+ 8000c08: af02 add r7, sp, #8
+ } else if self.end > slice.len() {
+ 8000c0a: 428a cmp r2, r1
+ 8000c0c: d86f bhi.n 8000cee <core::num::flt2dec::round_up+0xe8>
+ 8000c0e: 4694 mov ip, r2
+ fn rsearch_while<Acc, G>(&mut self, default: Acc, mut g: G) -> Acc
+ where Self: Sized,
+ G: FnMut($elem) -> SearchWhile<Acc>
+ {
+ unsafe {
+ while ptrdistance(self.ptr, self.end) >= 4 {
+ 8000c10: f1bc 0f03 cmp.w ip, #3
+ 8000c14: d914 bls.n 8000c40 <core::num::flt2dec::round_up+0x3a>
+ let diff = (other as isize).wrapping_sub(self as isize);
+ 8000c16: eb00 0e0c add.w lr, r0, ip
+ 8000c1a: f81e 3c01 ldrb.w r3, [lr, #-1]
+ if predicate(elt) {
+ 8000c1e: 2b39 cmp r3, #57 ; 0x39
+ 8000c20: d11a bne.n 8000c58 <core::num::flt2dec::round_up+0x52>
+ 8000c22: f81e 3c02 ldrb.w r3, [lr, #-2]
+ 8000c26: 2b39 cmp r3, #57 ; 0x39
+ 8000c28: d11b bne.n 8000c62 <core::num::flt2dec::round_up+0x5c>
+ 8000c2a: f81e 3c03 ldrb.w r3, [lr, #-3]
+ 8000c2e: 2b39 cmp r3, #57 ; 0x39
+ 8000c30: d11c bne.n 8000c6c <core::num::flt2dec::round_up+0x66>
+ 8000c32: f81e 3c04 ldrb.w r3, [lr, #-4]
+ index -= 1;
+ 8000c36: f1ac 0c04 sub.w ip, ip, #4
+ if predicate(elt) {
+ 8000c3a: 2b39 cmp r3, #57 ; 0x39
+ 8000c3c: d0e8 beq.n 8000c10 <core::num::flt2dec::round_up+0xa>
+ 8000c3e: e017 b.n 8000c70 <core::num::flt2dec::round_up+0x6a>
+ search_while!(g($mkref!(self.end.pre_dec())));
+ search_while!(g($mkref!(self.end.pre_dec())));
+ search_while!(g($mkref!(self.end.pre_dec())));
+ search_while!(g($mkref!(self.end.pre_dec())));
+ }
+ while self.ptr != self.end {
+ 8000c40: f1bc 0f00 cmp.w ip, #0
+ 8000c44: d034 beq.n 8000cb0 <core::num::flt2dec::round_up+0xaa>
+ 8000c46: eb00 030c add.w r3, r0, ip
+ index -= 1;
+ 8000c4a: f1ac 0c01 sub.w ip, ip, #1
+ 8000c4e: f813 3c01 ldrb.w r3, [r3, #-1]
+ if predicate(elt) {
+ 8000c52: 2b39 cmp r3, #57 ; 0x39
+ 8000c54: d0f4 beq.n 8000c40 <core::num::flt2dec::round_up+0x3a>
+ 8000c56: e00b b.n 8000c70 <core::num::flt2dec::round_up+0x6a>
+ index -= 1;
+ 8000c58: f1ac 0c01 sub.w ip, ip, #1
+ match d[..n].iter().rposition(|&c| c != b'9') {
+ Some(i) => { // d[i+1..n] is all nines
+ d[i] += 1;
+ 8000c5c: 458c cmp ip, r1
+ 8000c5e: d309 bcc.n 8000c74 <core::num::flt2dec::round_up+0x6e>
+ 8000c60: e048 b.n 8000cf4 <core::num::flt2dec::round_up+0xee>
+ 8000c62: f1ac 0c02 sub.w ip, ip, #2
+ 8000c66: 458c cmp ip, r1
+ 8000c68: d304 bcc.n 8000c74 <core::num::flt2dec::round_up+0x6e>
+ 8000c6a: e043 b.n 8000cf4 <core::num::flt2dec::round_up+0xee>
+ 8000c6c: f1ac 0c03 sub.w ip, ip, #3
+ 8000c70: 458c cmp ip, r1
+ 8000c72: d23f bcs.n 8000cf4 <core::num::flt2dec::round_up+0xee>
+ 8000c74: f810 300c ldrb.w r3, [r0, ip]
+ for j in i+1..n { d[j] = b'0'; }
+ 8000c78: f10c 0e01 add.w lr, ip, #1
+ if self.start < self.end {
+ 8000c7c: 4596 cmp lr, r2
+ d[i] += 1;
+ 8000c7e: f103 0301 add.w r3, r3, #1
+ 8000c82: f800 300c strb.w r3, [r0, ip]
+ 8000c86: d20f bcs.n 8000ca8 <core::num::flt2dec::round_up+0xa2>
+ 8000c88: f04f 0c30 mov.w ip, #48 ; 0x30
+ 8000c8c: f10e 0301 add.w r3, lr, #1
+ 8000c90: 2401 movs r4, #1
+ 8000c92: 4573 cmp r3, lr
+ 8000c94: bf28 it cs
+ 8000c96: 2400 movcs r4, #0
+ 8000c98: b934 cbnz r4, 8000ca8 <core::num::flt2dec::round_up+0xa2>
+ for j in i+1..n { d[j] = b'0'; }
+ 8000c9a: 458e cmp lr, r1
+ 8000c9c: d221 bcs.n 8000ce2 <core::num::flt2dec::round_up+0xdc>
+ 8000c9e: f800 c00e strb.w ip, [r0, lr]
+ 8000ca2: 4293 cmp r3, r2
+ 8000ca4: 469e mov lr, r3
+ 8000ca6: d3f1 bcc.n 8000c8c <core::num::flt2dec::round_up+0x86>
+ 8000ca8: 2000 movs r0, #0
+ 8000caa: 2100 movs r1, #0
+ }
+ None => { // an empty buffer rounds up (a bit strange but reasonable)
+ Some(b'1')
+ }
+ }
+}
+ 8000cac: 4308 orrs r0, r1
+ 8000cae: bdd0 pop {r4, r6, r7, pc}
+ 8000cb0: b192 cbz r2, 8000cd8 <core::num::flt2dec::round_up+0xd2>
+ 8000cb2: b311 cbz r1, 8000cfa <core::num::flt2dec::round_up+0xf4>
+ d[0] = b'1';
+ 8000cb4: 2331 movs r3, #49 ; 0x31
+ 8000cb6: 2a02 cmp r2, #2
+ 8000cb8: 7003 strb r3, [r0, #0]
+ 8000cba: d30a bcc.n 8000cd2 <core::num::flt2dec::round_up+0xcc>
+ 8000cbc: 2301 movs r3, #1
+ 8000cbe: f04f 0c30 mov.w ip, #48 ; 0x30
+ for j in 1..n { d[j] = b'0'; }
+ 8000cc2: 428b cmp r3, r1
+ 8000cc4: d210 bcs.n 8000ce8 <core::num::flt2dec::round_up+0xe2>
+ 8000cc6: 1c5c adds r4, r3, #1
+ 8000cc8: f800 c003 strb.w ip, [r0, r3]
+ 8000ccc: 4294 cmp r4, r2
+ 8000cce: 4623 mov r3, r4
+ 8000cd0: d3f7 bcc.n 8000cc2 <core::num::flt2dec::round_up+0xbc>
+ 8000cd2: f44f 5140 mov.w r1, #12288 ; 0x3000
+ 8000cd6: e001 b.n 8000cdc <core::num::flt2dec::round_up+0xd6>
+ 8000cd8: f44f 5144 mov.w r1, #12544 ; 0x3100
+ 8000cdc: 2001 movs r0, #1
+}
+ 8000cde: 4308 orrs r0, r1
+ 8000ce0: bdd0 pop {r4, r6, r7, pc}
+ for j in i+1..n { d[j] = b'0'; }
+ 8000ce2: 4670 mov r0, lr
+ 8000ce4: f7ff fc2f bl 8000546 <core::panicking::panic_bounds_check>
+ for j in 1..n { d[j] = b'0'; }
+ 8000ce8: 4618 mov r0, r3
+ 8000cea: f7ff fc2c bl 8000546 <core::panicking::panic_bounds_check>
+ slice_index_len_fail(self.end, slice.len());
+ 8000cee: 4610 mov r0, r2
+ 8000cf0: f7ff fc25 bl 800053e <core::slice::slice_index_len_fail>
+ d[i] += 1;
+ 8000cf4: 4660 mov r0, ip
+ 8000cf6: f7ff fc26 bl 8000546 <core::panicking::panic_bounds_check>
+ d[0] = b'1';
+ 8000cfa: 2000 movs r0, #0
+ 8000cfc: 2100 movs r1, #0
+ 8000cfe: f7ff fc22 bl 8000546 <core::panicking::panic_bounds_check>
+
+08000d02 <core::fmt::write>:
+pub fn write(output: &mut Write, args: Arguments) -> Result {
+ 8000d02: b5f0 push {r4, r5, r6, r7, lr}
+ 8000d04: af03 add r7, sp, #12
+ 8000d06: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8000d0a: b08f sub sp, #60 ; 0x3c
+ 8000d0c: e9d2 5e00 ldrd r5, lr, [r2]
+ 8000d10: e9d2 6c02 ldrd r6, ip, [r2, #8]
+ 8000d14: e9d2 4204 ldrd r4, r2, [r2, #16]
+ 8000d18: f04f 0800 mov.w r8, #0
+ let mut formatter = Formatter {
+ 8000d1c: 2320 movs r3, #32
+ 8000d1e: f8cd 8008 str.w r8, [sp, #8]
+ 8000d22: 9303 str r3, [sp, #12]
+ 8000d24: 2303 movs r3, #3
+ 8000d26: f88d 3038 strb.w r3, [sp, #56] ; 0x38
+ 8000d2a: ab08 add r3, sp, #32
+ 8000d2c: f8cd 8010 str.w r8, [sp, #16]
+ 8000d30: f8cd 8018 str.w r8, [sp, #24]
+ 8000d34: c313 stmia r3!, {r0, r1, r4}
+ intrinsics::offset(self, count)
+ 8000d36: eb04 08c2 add.w r8, r4, r2, lsl #3
+ None => {
+ 8000d3a: 2e00 cmp r6, #0
+ 8000d3c: eb05 00ce add.w r0, r5, lr, lsl #3
+ let mut formatter = Formatter {
+ 8000d40: e9cd 840b strd r8, r4, [sp, #44] ; 0x2c
+ 8000d44: 920d str r2, [sp, #52] ; 0x34
+ None => {
+ 8000d46: 9001 str r0, [sp, #4]
+ 8000d48: f000 80ab beq.w 8000ea2 <core::fmt::write+0x1a0>
+ 8000d4c: a802 add r0, sp, #8
+ for (arg, piece) in fmt.iter().zip(pieces.by_ref()) {
+ 8000d4e: f106 0a04 add.w sl, r6, #4
+ 8000d52: ea4f 04ce mov.w r4, lr, lsl #3
+ 8000d56: f100 0b10 add.w fp, r0, #16
+ 8000d5a: f100 0808 add.w r8, r0, #8
+ 8000d5e: eb0c 00cc add.w r0, ip, ip, lsl #3
+ 8000d62: ea4f 0980 mov.w r9, r0, lsl #2
+ if self.ptr == self.end {
+ 8000d66: f1b9 0f00 cmp.w r9, #0
+ 8000d6a: f000 80b7 beq.w 8000edc <core::fmt::write+0x1da>
+ 8000d6e: 2c00 cmp r4, #0
+ 8000d70: f000 80b6 beq.w 8000ee0 <core::fmt::write+0x1de>
+ formatter.buf.write_str(*piece)?;
+ 8000d74: e9d5 1200 ldrd r1, r2, [r5]
+ 8000d78: e9dd 0308 ldrd r0, r3, [sp, #32]
+ 8000d7c: 68db ldr r3, [r3, #12]
+ 8000d7e: 4798 blx r3
+ 8000d80: f010 0fff tst.w r0, #255 ; 0xff
+ 8000d84: f040 80bb bne.w 8000efe <core::fmt::write+0x1fc>
+ self.fill = arg.format.fill;
+ 8000d88: 68b0 ldr r0, [r6, #8]
+ 8000d8a: 9003 str r0, [sp, #12]
+ self.align = arg.format.align;
+ 8000d8c: f896 0020 ldrb.w r0, [r6, #32]
+ 8000d90: f88d 0038 strb.w r0, [sp, #56] ; 0x38
+ self.flags = arg.format.flags;
+ 8000d94: 68f0 ldr r0, [r6, #12]
+ 8000d96: 9002 str r0, [sp, #8]
+ 8000d98: e9d6 1006 ldrd r1, r0, [r6, #24]
+ rt::v1::Count::Is(n) => Some(n),
+ 8000d9c: f011 0103 ands.w r1, r1, #3
+ 8000da0: d024 beq.n 8000dec <core::fmt::write+0xea>
+ 8000da2: 2901 cmp r1, #1
+ 8000da4: d011 beq.n 8000dca <core::fmt::write+0xc8>
+ 8000da6: 2902 cmp r1, #2
+ 8000da8: d123 bne.n 8000df2 <core::fmt::write+0xf0>
+ assume(!self.ptr.is_null());
+ 8000daa: e9dd 010a ldrd r0, r1, [sp, #40] ; 0x28
+ if self.ptr == self.end {
+ 8000dae: 4288 cmp r0, r1
+ 8000db0: d01f beq.n 8000df2 <core::fmt::write+0xf0>
+ 8000db2: f100 0108 add.w r1, r0, #8
+ if self.formatter as usize == ArgumentV1::show_usize as usize {
+ 8000db6: f640 7225 movw r2, #3877 ; 0xf25
+
+ /// Increments `self` by 1, but returns the old value.
+ #[inline(always)]
+ unsafe fn post_inc(&mut self) -> Self {
+ let current = *self;
+ *self = self.slice_offset(1);
+ 8000dba: 910a str r1, [sp, #40] ; 0x28
+ 8000dbc: f6c0 0200 movt r2, #2048 ; 0x800
+ 8000dc0: 6841 ldr r1, [r0, #4]
+ 8000dc2: 4291 cmp r1, r2
+ 8000dc4: d115 bne.n 8000df2 <core::fmt::write+0xf0>
+ Some(unsafe { *(self.value as *const _ as *const usize) })
+ 8000dc6: 6800 ldr r0, [r0, #0]
+ 8000dc8: e00f b.n 8000dea <core::fmt::write+0xe8>
+ self.args[i].as_usize()
+ 8000dca: 990d ldr r1, [sp, #52] ; 0x34
+ 8000dcc: 4281 cmp r1, r0
+ 8000dce: f240 80a5 bls.w 8000f1c <core::fmt::write+0x21a>
+ 8000dd2: 990c ldr r1, [sp, #48] ; 0x30
+ if self.formatter as usize == ArgumentV1::show_usize as usize {
+ 8000dd4: f640 7325 movw r3, #3877 ; 0xf25
+ 8000dd8: f6c0 0300 movt r3, #2048 ; 0x800
+ 8000ddc: eb01 02c0 add.w r2, r1, r0, lsl #3
+ 8000de0: 6852 ldr r2, [r2, #4]
+ 8000de2: 429a cmp r2, r3
+ 8000de4: d105 bne.n 8000df2 <core::fmt::write+0xf0>
+ Some(unsafe { *(self.value as *const _ as *const usize) })
+ 8000de6: f851 0030 ldr.w r0, [r1, r0, lsl #3]
+ 8000dea: 6800 ldr r0, [r0, #0]
+ 8000dec: 2200 movs r2, #0
+ 8000dee: 2101 movs r1, #1
+ 8000df0: e001 b.n 8000df6 <core::fmt::write+0xf4>
+ 8000df2: 2100 movs r1, #0
+ 8000df4: 2200 movs r2, #0
+ self.width = self.getcount(&arg.format.width);
+ 8000df6: 4310 orrs r0, r2
+ 8000df8: e9c8 1000 strd r1, r0, [r8]
+ 8000dfc: e9d6 1004 ldrd r1, r0, [r6, #16]
+ rt::v1::Count::Is(n) => Some(n),
+ 8000e00: f011 0103 ands.w r1, r1, #3
+ 8000e04: d023 beq.n 8000e4e <core::fmt::write+0x14c>
+ 8000e06: 2901 cmp r1, #1
+ 8000e08: d011 beq.n 8000e2e <core::fmt::write+0x12c>
+ 8000e0a: 2902 cmp r1, #2
+ 8000e0c: d122 bne.n 8000e54 <core::fmt::write+0x152>
+ assume(!self.ptr.is_null());
+ 8000e0e: e9dd 010a ldrd r0, r1, [sp, #40] ; 0x28
+ if self.ptr == self.end {
+ 8000e12: 4288 cmp r0, r1
+ 8000e14: d01e beq.n 8000e54 <core::fmt::write+0x152>
+ 8000e16: f100 0108 add.w r1, r0, #8
+ if self.formatter as usize == ArgumentV1::show_usize as usize {
+ 8000e1a: f640 7225 movw r2, #3877 ; 0xf25
+ *self = self.slice_offset(1);
+ 8000e1e: 910a str r1, [sp, #40] ; 0x28
+ 8000e20: f6c0 0200 movt r2, #2048 ; 0x800
+ 8000e24: 6841 ldr r1, [r0, #4]
+ 8000e26: 4291 cmp r1, r2
+ 8000e28: d114 bne.n 8000e54 <core::fmt::write+0x152>
+ Some(unsafe { *(self.value as *const _ as *const usize) })
+ 8000e2a: 6800 ldr r0, [r0, #0]
+ 8000e2c: e00e b.n 8000e4c <core::fmt::write+0x14a>
+ self.args[i].as_usize()
+ 8000e2e: 990d ldr r1, [sp, #52] ; 0x34
+ 8000e30: 4281 cmp r1, r0
+ 8000e32: d975 bls.n 8000f20 <core::fmt::write+0x21e>
+ 8000e34: 990c ldr r1, [sp, #48] ; 0x30
+ if self.formatter as usize == ArgumentV1::show_usize as usize {
+ 8000e36: f640 7325 movw r3, #3877 ; 0xf25
+ 8000e3a: f6c0 0300 movt r3, #2048 ; 0x800
+ 8000e3e: eb01 02c0 add.w r2, r1, r0, lsl #3
+ 8000e42: 6852 ldr r2, [r2, #4]
+ 8000e44: 429a cmp r2, r3
+ 8000e46: d105 bne.n 8000e54 <core::fmt::write+0x152>
+ Some(unsafe { *(self.value as *const _ as *const usize) })
+ 8000e48: f851 0030 ldr.w r0, [r1, r0, lsl #3]
+ 8000e4c: 6800 ldr r0, [r0, #0]
+ 8000e4e: 2200 movs r2, #0
+ 8000e50: 2101 movs r1, #1
+ 8000e52: e001 b.n 8000e58 <core::fmt::write+0x156>
+ 8000e54: 2100 movs r1, #0
+ 8000e56: 2200 movs r2, #0
+ self.precision = self.getcount(&arg.format.precision);
+ 8000e58: 4310 orrs r0, r2
+ 8000e5a: e9cb 1000 strd r1, r0, [fp]
+ rt::v1::Position::Next => { *self.curarg.next().unwrap() }
+ 8000e5e: 6830 ldr r0, [r6, #0]
+ 8000e60: b140 cbz r0, 8000e74 <core::fmt::write+0x172>
+ rt::v1::Position::At(i) => self.args[i],
+ 8000e62: f8da 0000 ldr.w r0, [sl]
+ 8000e66: 990d ldr r1, [sp, #52] ; 0x34
+ 8000e68: 4288 cmp r0, r1
+ 8000e6a: d24f bcs.n 8000f0c <core::fmt::write+0x20a>
+ 8000e6c: 990c ldr r1, [sp, #48] ; 0x30
+ 8000e6e: eb01 01c0 add.w r1, r1, r0, lsl #3
+ 8000e72: e006 b.n 8000e82 <core::fmt::write+0x180>
+ assume(!self.ptr.is_null());
+ 8000e74: e9dd 100a ldrd r1, r0, [sp, #40] ; 0x28
+ if self.ptr == self.end {
+ 8000e78: 4281 cmp r1, r0
+ 8000e7a: d049 beq.n 8000f10 <core::fmt::write+0x20e>
+ 8000e7c: f101 0008 add.w r0, r1, #8
+ *self = self.slice_offset(1);
+ 8000e80: 900a str r0, [sp, #40] ; 0x28
+ 8000e82: e9d1 0200 ldrd r0, r2, [r1]
+ (value.formatter)(value.value, self)
+ 8000e86: a902 add r1, sp, #8
+ 8000e88: 3624 adds r6, #36 ; 0x24
+ 8000e8a: 3508 adds r5, #8
+ 8000e8c: 4790 blx r2
+ formatter.run(arg)?;
+ 8000e8e: f1a9 0924 sub.w r9, r9, #36 ; 0x24
+ 8000e92: f10a 0a24 add.w sl, sl, #36 ; 0x24
+ 8000e96: 3c08 subs r4, #8
+ 8000e98: f010 0fff tst.w r0, #255 ; 0xff
+ 8000e9c: f43f af63 beq.w 8000d66 <core::fmt::write+0x64>
+ 8000ea0: e02d b.n 8000efe <core::fmt::write+0x1fc>
+ for (arg, piece) in args.args.iter().zip(pieces.by_ref()) {
+ 8000ea2: ea4f 06ce mov.w r6, lr, lsl #3
+ 8000ea6: f10d 0908 add.w r9, sp, #8
+ if self.ptr == self.end {
+ 8000eaa: 4544 cmp r4, r8
+ 8000eac: d016 beq.n 8000edc <core::fmt::write+0x1da>
+ 8000eae: b1be cbz r6, 8000ee0 <core::fmt::write+0x1de>
+ formatter.buf.write_str(*piece)?;
+ 8000eb0: e9d5 1200 ldrd r1, r2, [r5]
+ 8000eb4: e9dd 0308 ldrd r0, r3, [sp, #32]
+ 8000eb8: 68db ldr r3, [r3, #12]
+ 8000eba: 4798 blx r3
+ 8000ebc: f010 0fff tst.w r0, #255 ; 0xff
+ 8000ec0: d11d bne.n 8000efe <core::fmt::write+0x1fc>
+ (arg.formatter)(arg.value, &mut formatter)?;
+ 8000ec2: e9d4 0200 ldrd r0, r2, [r4]
+ 8000ec6: 4649 mov r1, r9
+ 8000ec8: f104 0a08 add.w sl, r4, #8
+ 8000ecc: 4790 blx r2
+ 8000ece: 3e08 subs r6, #8
+ 8000ed0: 3508 adds r5, #8
+ 8000ed2: f010 0fff tst.w r0, #255 ; 0xff
+ 8000ed6: 4654 mov r4, sl
+ 8000ed8: d0e7 beq.n 8000eaa <core::fmt::write+0x1a8>
+ 8000eda: e010 b.n 8000efe <core::fmt::write+0x1fc>
+ 8000edc: 9801 ldr r0, [sp, #4]
+ 8000ede: e001 b.n 8000ee4 <core::fmt::write+0x1e2>
+ 8000ee0: 9801 ldr r0, [sp, #4]
+ 8000ee2: 4605 mov r5, r0
+ 8000ee4: 4285 cmp r5, r0
+ 8000ee6: bf18 it ne
+ 8000ee8: 2d00 cmpne r5, #0
+ 8000eea: d00a beq.n 8000f02 <core::fmt::write+0x200>
+ formatter.buf.write_str(*piece)?;
+ 8000eec: e9d5 1200 ldrd r1, r2, [r5]
+ 8000ef0: e9dd 0308 ldrd r0, r3, [sp, #32]
+ 8000ef4: 68db ldr r3, [r3, #12]
+ 8000ef6: 4798 blx r3
+ 8000ef8: f010 0fff tst.w r0, #255 ; 0xff
+ 8000efc: d001 beq.n 8000f02 <core::fmt::write+0x200>
+ 8000efe: 2001 movs r0, #1
+ 8000f00: e000 b.n 8000f04 <core::fmt::write+0x202>
+ 8000f02: 2000 movs r0, #0
+}
+ 8000f04: b00f add sp, #60 ; 0x3c
+ 8000f06: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8000f0a: bdf0 pop {r4, r5, r6, r7, pc}
+ rt::v1::Position::At(i) => self.args[i],
+ 8000f0c: f7ff fb1b bl 8000546 <core::panicking::panic_bounds_check>
+ #[inline]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn unwrap(self) -> T {
+ match self {
+ Some(val) => val,
+ None => panic!("called `Option::unwrap()` on a `None` value"),
+ 8000f10: f644 20b4 movw r0, #19124 ; 0x4ab4
+ 8000f14: f6c0 0000 movt r0, #2048 ; 0x800
+ 8000f18: f7ff fdeb bl 8000af2 <core::panicking::panic>
+ self.args[i].as_usize()
+ 8000f1c: f7ff fb13 bl 8000546 <core::panicking::panic_bounds_check>
+ 8000f20: f7ff fb11 bl 8000546 <core::panicking::panic_bounds_check>
+
+08000f24 <core::fmt::ArgumentV1::show_usize>:
+ fn show_usize(x: &usize, f: &mut Formatter) -> Result {
+ 8000f24: b5f0 push {r4, r5, r6, r7, lr}
+ 8000f26: af03 add r7, sp, #12
+ 8000f28: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8000f2c: b08b sub sp, #44 ; 0x2c
+ ($($t:ident)*) => ($(impl Int for $t {
+ fn zero() -> $t { 0 }
+ fn from_u8(u: u8) -> $t { u as $t }
+ fn to_u8(&self) -> u8 { *self as u8 }
+ fn to_u16(&self) -> u16 { *self as u16 }
+ fn to_u32(&self) -> u32 { *self as u32 }
+ 8000f2e: 6804 ldr r4, [r0, #0]
+ let buf_ptr = buf.as_mut_ptr();
+ let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+
+ unsafe {
+ // need at least 16 bits for the 4-characters-at-a-time to work.
+ if ::mem::size_of::<$t>() >= 2 {
+ 8000f30: f242 7c10 movw ip, #10000 ; 0x2710
+ 8000f34: 4564 cmp r4, ip
+ 8000f36: d339 bcc.n 8000fac <core::fmt::ArgumentV1::show_usize+0x88>
+ 8000f38: f241 7859 movw r8, #5977 ; 0x1759
+ 8000f3c: f248 591f movw r9, #34079 ; 0x851f
+ 8000f40: f244 3ed0 movw lr, #17360 ; 0x43d0
+ 8000f44: f24e 0bff movw fp, #57599 ; 0xe0ff
+ 8000f48: 2300 movs r3, #0
+ 8000f4a: f04f 0a64 mov.w sl, #100 ; 0x64
+ 8000f4e: 9100 str r1, [sp, #0]
+ 8000f50: f2cd 18b7 movt r8, #53687 ; 0xd1b7
+ 8000f54: f2c5 19eb movt r9, #20971 ; 0x51eb
+ 8000f58: f6c0 0e00 movt lr, #2048 ; 0x800
+ 8000f5c: f2c0 5bf5 movt fp, #1525 ; 0x5f5
+ n /= 10000;
+
+ let d1 = (rem / 100) << 1;
+ let d2 = (rem % 100) << 1;
+ curr -= 4;
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8000f60: f1a7 0043 sub.w r0, r7, #67 ; 0x43
+ while n >= 10000 {
+ 8000f64: 455c cmp r4, fp
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8000f66: eb00 0603 add.w r6, r0, r3
+ let rem = (n % 10000) as isize;
+ 8000f6a: fba4 0208 umull r0, r2, r4, r8
+ while n >= 10000 {
+ 8000f6e: f1a3 0304 sub.w r3, r3, #4
+ n /= 10000;
+ 8000f72: ea4f 3052 mov.w r0, r2, lsr #13
+ let rem = (n % 10000) as isize;
+ 8000f76: fb00 421c mls r2, r0, ip, r4
+ 8000f7a: 4604 mov r4, r0
+ let d1 = (rem / 100) << 1;
+ 8000f7c: fba2 c109 umull ip, r1, r2, r9
+ 8000f80: ea4f 1151 mov.w r1, r1, lsr #5
+ if ::mem::size_of::<$t>() >= 2 {
+ 8000f84: f242 7c10 movw ip, #10000 ; 0x2710
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8000f88: f83e 5011 ldrh.w r5, [lr, r1, lsl #1]
+ let d2 = (rem % 100) << 1;
+ 8000f8c: fb01 211a mls r1, r1, sl, r2
+ ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
+ 8000f90: f83e 1011 ldrh.w r1, [lr, r1, lsl #1]
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8000f94: f8a6 5023 strh.w r5, [r6, #35] ; 0x23
+ ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
+ 8000f98: f8a6 1025 strh.w r1, [r6, #37] ; 0x25
+ while n >= 10000 {
+ 8000f9c: d8e0 bhi.n 8000f60 <core::fmt::ArgumentV1::show_usize+0x3c>
+ 8000f9e: 9900 ldr r1, [sp, #0]
+ let mut curr = buf.len() as isize;
+ 8000fa0: f103 0227 add.w r2, r3, #39 ; 0x27
+ 8000fa4: 4604 mov r4, r0
+
+ // if we reach here numbers are <= 9999, so at most 4 chars long
+ let mut n = n as isize; // possibly reduce 64bit math
+
+ // decode 2 more chars, if > 2 chars
+ if n >= 100 {
+ 8000fa6: 2c64 cmp r4, #100 ; 0x64
+ 8000fa8: da03 bge.n 8000fb2 <core::fmt::ArgumentV1::show_usize+0x8e>
+ 8000faa: e019 b.n 8000fe0 <core::fmt::ArgumentV1::show_usize+0xbc>
+ 8000fac: 2227 movs r2, #39 ; 0x27
+ 8000fae: 2c64 cmp r4, #100 ; 0x64
+ 8000fb0: db16 blt.n 8000fe0 <core::fmt::ArgumentV1::show_usize+0xbc>
+ 8000fb2: f248 501f movw r0, #34079 ; 0x851f
+ 8000fb6: f244 36d0 movw r6, #17360 ; 0x43d0
+ let d1 = (n % 100) << 1;
+ n /= 100;
+ curr -= 2;
+ 8000fba: 3a02 subs r2, #2
+ 8000fbc: f2c5 10eb movt r0, #20971 ; 0x51eb
+ 8000fc0: f6c0 0600 movt r6, #2048 ; 0x800
+ 8000fc4: fba4 0300 umull r0, r3, r4, r0
+ 8000fc8: 095b lsrs r3, r3, #5
+ 8000fca: 2064 movs r0, #100 ; 0x64
+ 8000fcc: fb03 4010 mls r0, r3, r0, r4
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8000fd0: f836 0010 ldrh.w r0, [r6, r0, lsl #1]
+ 8000fd4: f1a7 0643 sub.w r6, r7, #67 ; 0x43
+ 8000fd8: 52b0 strh r0, [r6, r2]
+ }
+
+ // decode last 1 or 2 chars
+ if n < 10 {
+ 8000fda: 2b09 cmp r3, #9
+ 8000fdc: dd03 ble.n 8000fe6 <core::fmt::ArgumentV1::show_usize+0xc2>
+ 8000fde: e008 b.n 8000ff2 <core::fmt::ArgumentV1::show_usize+0xce>
+ 8000fe0: 4623 mov r3, r4
+ 8000fe2: 2b09 cmp r3, #9
+ 8000fe4: dc05 bgt.n 8000ff2 <core::fmt::ArgumentV1::show_usize+0xce>
+ curr -= 1;
+ 8000fe6: 1e50 subs r0, r2, #1
+ *buf_ptr.offset(curr) = (n as u8) + b'0';
+ 8000fe8: 3330 adds r3, #48 ; 0x30
+ 8000fea: f1a7 0243 sub.w r2, r7, #67 ; 0x43
+ 8000fee: 5413 strb r3, [r2, r0]
+ 8000ff0: e009 b.n 8001006 <core::fmt::ArgumentV1::show_usize+0xe2>
+ 8000ff2: f244 30d0 movw r0, #17360 ; 0x43d0
+ 8000ff6: f6c0 0000 movt r0, #2048 ; 0x800
+ } else {
+ let d1 = n << 1;
+ curr -= 2;
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8000ffa: f830 3013 ldrh.w r3, [r0, r3, lsl #1]
+ curr -= 2;
+ 8000ffe: 1e90 subs r0, r2, #2
+ 8001000: f1a7 0243 sub.w r2, r7, #67 ; 0x43
+ ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+ 8001004: 5213 strh r3, [r2, r0]
+ 8001006: f1a7 0243 sub.w r2, r7, #67 ; 0x43
+ intrinsics::offset(self, count) as *mut T
+ 800100a: 1813 adds r3, r2, r0
+ }
+ }
+
+ let buf_slice = unsafe {
+ str::from_utf8_unchecked(
+ slice::from_raw_parts(buf_ptr.offset(curr), buf.len() - curr as usize))
+ 800100c: f1c0 0227 rsb r2, r0, #39 ; 0x27
+ };
+ f.pad_integral(is_nonnegative, "", buf_slice)
+ 8001010: 4608 mov r0, r1
+ 8001012: 4619 mov r1, r3
+ 8001014: f7ff fb7d bl 8000712 <core::fmt::Formatter::pad_integral>
+ }
+ 8001018: b00b add sp, #44 ; 0x2c
+ 800101a: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 800101e: bdf0 pop {r4, r5, r6, r7, pc}
+
+08001020 <core::fmt::Formatter::pad_formatted_parts>:
+ fn pad_formatted_parts(&mut self, formatted: &flt2dec::Formatted) -> Result {
+ 8001020: b5f0 push {r4, r5, r6, r7, lr}
+ 8001022: af03 add r7, sp, #12
+ 8001024: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8001028: b089 sub sp, #36 ; 0x24
+ 800102a: 4604 mov r4, r0
+ 800102c: 460a mov r2, r1
+ if let Some(mut width) = self.width {
+ 800102e: 68a0 ldr r0, [r4, #8]
+ 8001030: 2801 cmp r0, #1
+ 8001032: d114 bne.n 800105e <core::fmt::Formatter::pad_formatted_parts+0x3e>
+ 8001034: f8d4 800c ldr.w r8, [r4, #12]
+ 8001038: e892 0222 ldmia.w r2, {r1, r5, r9}
+}
+
+/// Formatted result containing one or more parts.
+/// This can be written to the byte buffer or converted to the allocated string.
+#[allow(missing_debug_implementations)]
+#[derive(Clone)]
+ 800103c: a804 add r0, sp, #16
+ 800103e: 68d6 ldr r6, [r2, #12]
+ 8001040: e880 0222 stmia.w r0, {r1, r5, r9}
+ 8001044: 9607 str r6, [sp, #28]
+ if self.sign_aware_zero_pad() {
+ 8001046: 7820 ldrb r0, [r4, #0]
+ let old_align = self.align;
+ 8001048: f894 a030 ldrb.w sl, [r4, #48] ; 0x30
+ let old_fill = self.fill;
+ 800104c: f8d4 b004 ldr.w fp, [r4, #4]
+ if self.sign_aware_zero_pad() {
+ 8001050: 0700 lsls r0, r0, #28
+ 8001052: d40d bmi.n 8001070 <core::fmt::Formatter::pad_formatted_parts+0x50>
+ let fill = self.fill.encode_utf8(&mut fill);
+ 8001054: 46dc mov ip, fp
+}
+
+impl<'a> Formatted<'a> {
+ /// Returns the exact byte length of combined formatted result.
+ pub fn len(&self) -> usize {
+ let mut len = self.sign.len();
+ 8001056: 462a mov r2, r5
+ rt::v1::Alignment::Unknown => default,
+ 8001058: 46d6 mov lr, sl
+ 800105a: bb46 cbnz r6, 80010ae <core::fmt::Formatter::pad_formatted_parts+0x8e>
+ 800105c: e052 b.n 8001104 <core::fmt::Formatter::pad_formatted_parts+0xe4>
+ self.write_formatted_parts(formatted)
+ 800105e: 4620 mov r0, r4
+ 8001060: 4611 mov r1, r2
+ 8001062: b009 add sp, #36 ; 0x24
+ 8001064: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8001068: e8bd 40f0 ldmia.w sp!, {r4, r5, r6, r7, lr}
+ 800106c: f000 b908 b.w 8001280 <core::fmt::Formatter::write_formatted_parts>
+ self.buf.write_str(sign)?;
+ 8001070: e9d4 0206 ldrd r0, r2, [r4, #24]
+ 8001074: 68d3 ldr r3, [r2, #12]
+ 8001076: 462a mov r2, r5
+ 8001078: 4798 blx r3
+ 800107a: f010 0fff tst.w r0, #255 ; 0xff
+ 800107e: d001 beq.n 8001084 <core::fmt::Formatter::pad_formatted_parts+0x64>
+ 8001080: 2001 movs r0, #1
+ 8001082: e0dd b.n 8001240 <core::fmt::Formatter::pad_formatted_parts+0x220>
+ formatted.sign = b"";
+ 8001084: f244 4098 movw r0, #17560 ; 0x4498
+ 8001088: f04f 0c30 mov.w ip, #48 ; 0x30
+ 800108c: 2200 movs r2, #0
+ 800108e: f04f 0e01 mov.w lr, #1
+ width = if width < sign.len() { 0 } else { width - sign.len() };
+ 8001092: ebb8 0805 subs.w r8, r8, r5
+ formatted.sign = b"";
+ 8001096: f6c0 0000 movt r0, #2048 ; 0x800
+ self.fill = '0';
+ 800109a: f8c4 c004 str.w ip, [r4, #4]
+ self.align = rt::v1::Alignment::Right;
+ 800109e: f884 e030 strb.w lr, [r4, #48] ; 0x30
+ formatted.sign = b"";
+ 80010a2: 9004 str r0, [sp, #16]
+ 80010a4: 9205 str r2, [sp, #20]
+ width = if width < sign.len() { 0 } else { width - sign.len() };
+ 80010a6: bf38 it cc
+ 80010a8: f04f 0800 movcc.w r8, #0
+ 80010ac: b356 cbz r6, 8001104 <core::fmt::Formatter::pad_formatted_parts+0xe4>
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 80010ae: eb06 0046 add.w r0, r6, r6, lsl #1
+ 80010b2: f109 0304 add.w r3, r9, #4
+ 80010b6: 0085 lsls r5, r0, #2
+ 80010b8: f242 7010 movw r0, #10000 ; 0x2710
+ Part::Zero(nzeroes) => nzeroes,
+ 80010bc: f833 6c04 ldrh.w r6, [r3, #-4]
+ 80010c0: f006 0103 and.w r1, r6, #3
+ 80010c4: 2901 cmp r1, #1
+ 80010c6: d002 beq.n 80010ce <core::fmt::Formatter::pad_formatted_parts+0xae>
+ 80010c8: b956 cbnz r6, 80010e0 <core::fmt::Formatter::pad_formatted_parts+0xc0>
+ 80010ca: 681e ldr r6, [r3, #0]
+ 80010cc: e015 b.n 80010fa <core::fmt::Formatter::pad_formatted_parts+0xda>
+ Part::Num(v) => if v < 1_000 { if v < 10 { 1 } else if v < 100 { 2 } else { 3 } }
+ 80010ce: f833 6c02 ldrh.w r6, [r3, #-2]
+ 80010d2: f5b6 7f7a cmp.w r6, #1000 ; 0x3e8
+ 80010d6: d205 bcs.n 80010e4 <core::fmt::Formatter::pad_formatted_parts+0xc4>
+ 80010d8: 2e0a cmp r6, #10
+ 80010da: d209 bcs.n 80010f0 <core::fmt::Formatter::pad_formatted_parts+0xd0>
+ 80010dc: 2601 movs r6, #1
+ 80010de: e00c b.n 80010fa <core::fmt::Formatter::pad_formatted_parts+0xda>
+ Part::Copy(buf) => buf.len(),
+ 80010e0: 685e ldr r6, [r3, #4]
+ 80010e2: e00a b.n 80010fa <core::fmt::Formatter::pad_formatted_parts+0xda>
+ else { if v < 10_000 { 4 } else { 5 } },
+ 80010e4: 4286 cmp r6, r0
+ 80010e6: f04f 0605 mov.w r6, #5
+ 80010ea: bf38 it cc
+ 80010ec: 2604 movcc r6, #4
+ 80010ee: e004 b.n 80010fa <core::fmt::Formatter::pad_formatted_parts+0xda>
+ Part::Num(v) => if v < 1_000 { if v < 10 { 1 } else if v < 100 { 2 } else { 3 } }
+ 80010f0: 2e64 cmp r6, #100 ; 0x64
+ 80010f2: f04f 0603 mov.w r6, #3
+ 80010f6: bf38 it cc
+ 80010f8: 2602 movcc r6, #2
+ for part in self.parts {
+ len += part.len();
+ 80010fa: 4432 add r2, r6
+ if self.ptr == self.end {
+ 80010fc: 3d0c subs r5, #12
+ 80010fe: f103 030c add.w r3, r3, #12
+ 8001102: d1db bne.n 80010bc <core::fmt::Formatter::pad_formatted_parts+0x9c>
+ let ret = if width <= len { // no padding
+ 8001104: 4590 cmp r8, r2
+ 8001106: d910 bls.n 800112a <core::fmt::Formatter::pad_formatted_parts+0x10a>
+ self.with_padding(width - len, align, |f| {
+ 8001108: eba8 0002 sub.w r0, r8, r2
+ rt::v1::Alignment::Left => (0, padding),
+ 800110c: f1be 0f00 cmp.w lr, #0
+ 8001110: 9003 str r0, [sp, #12]
+ 8001112: f04f 0000 mov.w r0, #0
+ 8001116: d00d beq.n 8001134 <core::fmt::Formatter::pad_formatted_parts+0x114>
+ 8001118: f1be 0f02 cmp.w lr, #2
+ 800111c: d10d bne.n 800113a <core::fmt::Formatter::pad_formatted_parts+0x11a>
+ 800111e: 9903 ldr r1, [sp, #12]
+ rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2),
+ 8001120: ea4f 0851 mov.w r8, r1, lsr #1
+ 8001124: 3101 adds r1, #1
+ 8001126: 0849 lsrs r1, r1, #1
+ 8001128: e00a b.n 8001140 <core::fmt::Formatter::pad_formatted_parts+0x120>
+ 800112a: a904 add r1, sp, #16
+ self.write_formatted_parts(&formatted)
+ 800112c: 4620 mov r0, r4
+ 800112e: f000 f8a7 bl 8001280 <core::fmt::Formatter::write_formatted_parts>
+ 8001132: e081 b.n 8001238 <core::fmt::Formatter::pad_formatted_parts+0x218>
+ 8001134: f04f 0800 mov.w r8, #0
+ 8001138: e003 b.n 8001142 <core::fmt::Formatter::pad_formatted_parts+0x122>
+ 800113a: f8dd 800c ldr.w r8, [sp, #12]
+ 800113e: 2100 movs r1, #0
+ 8001140: 9103 str r1, [sp, #12]
+ if code < MAX_ONE_B && !dst.is_empty() {
+ 8001142: f1bc 0f7f cmp.w ip, #127 ; 0x7f
+ let mut fill = [0; 4];
+ 8001146: 9008 str r0, [sp, #32]
+ 8001148: e9cd ba01 strd fp, sl, [sp, #4]
+ 800114c: d804 bhi.n 8001158 <core::fmt::Formatter::pad_formatted_parts+0x138>
+ *dst.get_unchecked_mut(0) = code as u8;
+ 800114e: f88d c020 strb.w ip, [sp, #32]
+ 8001152: f04f 0901 mov.w r9, #1
+ 8001156: e04a b.n 80011ee <core::fmt::Formatter::pad_formatted_parts+0x1ce>
+ } else if code < MAX_TWO_B && dst.len() >= 2 {
+ 8001158: 2000 movs r0, #0
+ 800115a: ebb0 2fdc cmp.w r0, ip, lsr #11
+ 800115e: d10c bne.n 800117a <core::fmt::Formatter::pad_formatted_parts+0x15a>
+ *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+ 8001160: f64f 71fe movw r1, #65534 ; 0xfffe
+ 8001164: ea4f 109c mov.w r0, ip, lsr #6
+ 8001168: f04f 0902 mov.w r9, #2
+ 800116c: aa08 add r2, sp, #32
+ 800116e: f2c0 71ff movt r1, #2047 ; 0x7ff
+ 8001172: f361 105f bfi r0, r1, #5, #27
+ 8001176: 2101 movs r1, #1
+ 8001178: e032 b.n 80011e0 <core::fmt::Formatter::pad_formatted_parts+0x1c0>
+ } else if code < MAX_THREE_B && dst.len() >= 3 {
+ 800117a: ebb0 4f1c cmp.w r0, ip, lsr #16
+ 800117e: d115 bne.n 80011ac <core::fmt::Formatter::pad_formatted_parts+0x18c>
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 8001180: ea4f 301c mov.w r0, ip, lsr #12
+ 8001184: 210e movs r1, #14
+ 8001186: f04f 0903 mov.w r9, #3
+ 800118a: f361 101f bfi r0, r1, #4, #28
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 800118e: f64f 71fe movw r1, #65534 ; 0xfffe
+ *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+ 8001192: f88d 0020 strb.w r0, [sp, #32]
+ *dst.get_unchecked_mut(1) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 8001196: ea4f 109c mov.w r0, ip, lsr #6
+ 800119a: f2c0 31ff movt r1, #1023 ; 0x3ff
+ 800119e: f361 109f bfi r0, r1, #6, #26
+ 80011a2: a908 add r1, sp, #32
+ 80011a4: f041 0201 orr.w r2, r1, #1
+ 80011a8: 2102 movs r1, #2
+ 80011aa: e019 b.n 80011e0 <core::fmt::Formatter::pad_formatted_parts+0x1c0>
+ *dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+ 80011ac: 20f0 movs r0, #240 ; 0xf0
+ 80011ae: 2102 movs r1, #2
+ 80011b0: f04f 0904 mov.w r9, #4
+ 80011b4: ea40 409c orr.w r0, r0, ip, lsr #18
+ 80011b8: f88d 0020 strb.w r0, [sp, #32]
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 80011bc: ea4f 301c mov.w r0, ip, lsr #12
+ 80011c0: f361 109f bfi r0, r1, #6, #26
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 80011c4: f64f 71fe movw r1, #65534 ; 0xfffe
+ *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+ 80011c8: f88d 0021 strb.w r0, [sp, #33] ; 0x21
+ *dst.get_unchecked_mut(2) = (code >> 6 & 0x3F) as u8 | TAG_CONT;
+ 80011cc: ea4f 109c mov.w r0, ip, lsr #6
+ 80011d0: f2c0 31ff movt r1, #1023 ; 0x3ff
+ 80011d4: f361 109f bfi r0, r1, #6, #26
+ 80011d8: a908 add r1, sp, #32
+ 80011da: f041 0202 orr.w r2, r1, #2
+ 80011de: 2103 movs r1, #3
+ 80011e0: 7010 strb r0, [r2, #0]
+ 80011e2: 2002 movs r0, #2
+ 80011e4: f360 1c9f bfi ip, r0, #6, #26
+ 80011e8: a808 add r0, sp, #32
+ 80011ea: f800 c001 strb.w ip, [r0, r1]
+ 80011ee: e9d4 6b06 ldrd r6, fp, [r4, #24]
+ 80011f2: 2000 movs r0, #0
+ 80011f4: ad08 add r5, sp, #32
+ 80011f6: 4540 cmp r0, r8
+ 80011f8: d212 bcs.n 8001220 <core::fmt::Formatter::pad_formatted_parts+0x200>
+ 80011fa: f100 0a01 add.w sl, r0, #1
+ 80011fe: 4582 cmp sl, r0
+ 8001200: f04f 0001 mov.w r0, #1
+ 8001204: bf28 it cs
+ 8001206: 2000 movcs r0, #0
+ 8001208: b950 cbnz r0, 8001220 <core::fmt::Formatter::pad_formatted_parts+0x200>
+ self.buf.write_str(fill)?;
+ 800120a: f8db 300c ldr.w r3, [fp, #12]
+ 800120e: 4630 mov r0, r6
+ 8001210: 4629 mov r1, r5
+ 8001212: 464a mov r2, r9
+ 8001214: 4798 blx r3
+ 8001216: f010 0fff tst.w r0, #255 ; 0xff
+ 800121a: 4650 mov r0, sl
+ 800121c: d0eb beq.n 80011f6 <core::fmt::Formatter::pad_formatted_parts+0x1d6>
+ 800121e: e006 b.n 800122e <core::fmt::Formatter::pad_formatted_parts+0x20e>
+ 8001220: a904 add r1, sp, #16
+ f.write_formatted_parts(&formatted)
+ 8001222: 4620 mov r0, r4
+ 8001224: f000 f82c bl 8001280 <core::fmt::Formatter::write_formatted_parts>
+ f(self)?;
+ 8001228: f010 0fff tst.w r0, #255 ; 0xff
+ 800122c: d00c beq.n 8001248 <core::fmt::Formatter::pad_formatted_parts+0x228>
+ 800122e: f8dd a008 ldr.w sl, [sp, #8]
+ 8001232: 2001 movs r0, #1
+ 8001234: f8dd b004 ldr.w fp, [sp, #4]
+ self.fill = old_fill;
+ 8001238: f8c4 b004 str.w fp, [r4, #4]
+ self.align = old_align;
+ 800123c: f884 a030 strb.w sl, [r4, #48] ; 0x30
+ }
+ 8001240: b009 add sp, #36 ; 0x24
+ 8001242: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8001246: bdf0 pop {r4, r5, r6, r7, pc}
+ 8001248: f8dd a008 ldr.w sl, [sp, #8]
+ 800124c: 2000 movs r0, #0
+ 800124e: f10d 0820 add.w r8, sp, #32
+ 8001252: 9903 ldr r1, [sp, #12]
+ 8001254: 4288 cmp r0, r1
+ 8001256: d211 bcs.n 800127c <core::fmt::Formatter::pad_formatted_parts+0x25c>
+ 8001258: 1c45 adds r5, r0, #1
+ 800125a: 4285 cmp r5, r0
+ 800125c: f04f 0001 mov.w r0, #1
+ 8001260: bf28 it cs
+ 8001262: 2000 movcs r0, #0
+ 8001264: b950 cbnz r0, 800127c <core::fmt::Formatter::pad_formatted_parts+0x25c>
+ self.buf.write_str(fill)?;
+ 8001266: f8db 300c ldr.w r3, [fp, #12]
+ 800126a: 4630 mov r0, r6
+ 800126c: 4641 mov r1, r8
+ 800126e: 464a mov r2, r9
+ 8001270: 4798 blx r3
+ 8001272: f010 0fff tst.w r0, #255 ; 0xff
+ 8001276: 4628 mov r0, r5
+ 8001278: d0eb beq.n 8001252 <core::fmt::Formatter::pad_formatted_parts+0x232>
+ 800127a: e7da b.n 8001232 <core::fmt::Formatter::pad_formatted_parts+0x212>
+ 800127c: 2000 movs r0, #0
+ 800127e: e7d9 b.n 8001234 <core::fmt::Formatter::pad_formatted_parts+0x214>
+
+08001280 <core::fmt::Formatter::write_formatted_parts>:
+ fn write_formatted_parts(&mut self, formatted: &flt2dec::Formatted) -> Result {
+ 8001280: b5f0 push {r4, r5, r6, r7, lr}
+ 8001282: af03 add r7, sp, #12
+ 8001284: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8001288: b083 sub sp, #12
+ 800128a: 460c mov r4, r1
+ 800128c: 4682 mov sl, r0
+ if !formatted.sign.is_empty() {
+ 800128e: 6862 ldr r2, [r4, #4]
+ 8001290: b142 cbz r2, 80012a4 <core::fmt::Formatter::write_formatted_parts+0x24>
+ write_bytes(self.buf, formatted.sign)?;
+ 8001292: 6821 ldr r1, [r4, #0]
+ 8001294: e9da 0306 ldrd r0, r3, [sl, #24]
+ buf.write_str(unsafe { str::from_utf8_unchecked(s) })
+ 8001298: 68db ldr r3, [r3, #12]
+ 800129a: 4798 blx r3
+ write_bytes(self.buf, formatted.sign)?;
+ 800129c: f010 0fff tst.w r0, #255 ; 0xff
+ 80012a0: f040 8094 bne.w 80013cc <core::fmt::Formatter::write_formatted_parts+0x14c>
+ for part in formatted.parts {
+ 80012a4: 68e0 ldr r0, [r4, #12]
+ 80012a6: f04f 0900 mov.w r9, #0
+ 80012aa: 2800 cmp r0, #0
+ 80012ac: f000 8090 beq.w 80013d0 <core::fmt::Formatter::write_formatted_parts+0x150>
+ 80012b0: f8d4 b008 ldr.w fp, [r4, #8]
+ 80012b4: f64c 48cd movw r8, #52429 ; 0xcccd
+ intrinsics::offset(self, count)
+ 80012b8: eb00 0040 add.w r0, r0, r0, lsl #1
+ 80012bc: ae01 add r6, sp, #4
+ 80012be: f6cc 48cc movt r8, #52428 ; 0xcccc
+ 80012c2: eb0b 0580 add.w r5, fp, r0, lsl #2
+ 80012c6: 9500 str r5, [sp, #0]
+ 80012c8: 465a mov r2, fp
+ flt2dec::Part::Zero(mut nzeroes) => {
+ 80012ca: f83b 0b0c ldrh.w r0, [fp], #12
+ 80012ce: f000 0103 and.w r1, r0, #3
+ 80012d2: 2901 cmp r1, #1
+ 80012d4: d015 beq.n 8001302 <core::fmt::Formatter::write_formatted_parts+0x82>
+ 80012d6: bb50 cbnz r0, 800132e <core::fmt::Formatter::write_formatted_parts+0xae>
+ 80012d8: 6854 ldr r4, [r2, #4]
+ while nzeroes > ZEROES.len() {
+ 80012da: 2c41 cmp r4, #65 ; 0x41
+ 80012dc: d32d bcc.n 800133a <core::fmt::Formatter::write_formatted_parts+0xba>
+ 80012de: e9da 5006 ldrd r5, r0, [sl, #24]
+ 80012e2: f8d0 900c ldr.w r9, [r0, #12]
+ self.buf.write_str(ZEROES)?;
+ 80012e6: f644 3190 movw r1, #19344 ; 0x4b90
+ 80012ea: 4628 mov r0, r5
+ 80012ec: 2240 movs r2, #64 ; 0x40
+ 80012ee: f6c0 0100 movt r1, #2048 ; 0x800
+ 80012f2: 47c8 blx r9
+ 80012f4: f010 0fff tst.w r0, #255 ; 0xff
+ 80012f8: d168 bne.n 80013cc <core::fmt::Formatter::write_formatted_parts+0x14c>
+ nzeroes -= ZEROES.len();
+ 80012fa: 3c40 subs r4, #64 ; 0x40
+ while nzeroes > ZEROES.len() {
+ 80012fc: 2c40 cmp r4, #64 ; 0x40
+ 80012fe: d8f2 bhi.n 80012e6 <core::fmt::Formatter::write_formatted_parts+0x66>
+ 8001300: e021 b.n 8001346 <core::fmt::Formatter::write_formatted_parts+0xc6>
+ flt2dec::Part::Num(mut v) => {
+ 8001302: 8850 ldrh r0, [r2, #2]
+ let mut s = [0; 5];
+ 8001304: f88d 9008 strb.w r9, [sp, #8]
+ 8001308: f8cd 9004 str.w r9, [sp, #4]
+ Part::Zero(nzeroes) => nzeroes,
+ 800130c: 8811 ldrh r1, [r2, #0]
+ 800130e: f001 0303 and.w r3, r1, #3
+ 8001312: 2b01 cmp r3, #1
+ 8001314: d025 beq.n 8001362 <core::fmt::Formatter::write_formatted_parts+0xe2>
+ 8001316: 2900 cmp r1, #0
+ 8001318: bf0c ite eq
+ 800131a: 2100 moveq r1, #0
+ 800131c: 2101 movne r1, #1
+ 800131e: eb02 0181 add.w r1, r2, r1, lsl #2
+ 8001322: 684a ldr r2, [r1, #4]
+ } else if self.end > slice.len() {
+ 8001324: 2a06 cmp r2, #6
+ 8001326: d258 bcs.n 80013da <core::fmt::Formatter::write_formatted_parts+0x15a>
+ 8001328: bb82 cbnz r2, 800138c <core::fmt::Formatter::write_formatted_parts+0x10c>
+ 800132a: 2200 movs r2, #0
+ 800132c: e040 b.n 80013b0 <core::fmt::Formatter::write_formatted_parts+0x130>
+ flt2dec::Part::Copy(buf) => {
+ 800132e: e9d2 1201 ldrd r1, r2, [r2, #4]
+ write_bytes(self.buf, buf)?;
+ 8001332: e9da 0306 ldrd r0, r3, [sl, #24]
+ buf.write_str(unsafe { str::from_utf8_unchecked(s) })
+ 8001336: 68db ldr r3, [r3, #12]
+ 8001338: e03e b.n 80013b8 <core::fmt::Formatter::write_formatted_parts+0x138>
+ if nzeroes > 0 {
+ 800133a: 2c00 cmp r4, #0
+ 800133c: d040 beq.n 80013c0 <core::fmt::Formatter::write_formatted_parts+0x140>
+ 800133e: e9da 5006 ldrd r5, r0, [sl, #24]
+ 8001342: f8d0 900c ldr.w r9, [r0, #12]
+ self.buf.write_str(&ZEROES[..nzeroes])?;
+ 8001346: f644 3190 movw r1, #19344 ; 0x4b90
+ 800134a: 4628 mov r0, r5
+ 800134c: 4622 mov r2, r4
+ 800134e: f6c0 0100 movt r1, #2048 ; 0x800
+ 8001352: 47c8 blx r9
+ 8001354: 9d00 ldr r5, [sp, #0]
+ 8001356: f010 0fff tst.w r0, #255 ; 0xff
+ 800135a: f04f 0900 mov.w r9, #0
+ 800135e: d02f beq.n 80013c0 <core::fmt::Formatter::write_formatted_parts+0x140>
+ 8001360: e034 b.n 80013cc <core::fmt::Formatter::write_formatted_parts+0x14c>
+ Part::Num(v) => if v < 1_000 { if v < 10 { 1 } else if v < 100 { 2 } else { 3 } }
+ 8001362: 8851 ldrh r1, [r2, #2]
+ 8001364: 08ca lsrs r2, r1, #3
+ 8001366: 2a7c cmp r2, #124 ; 0x7c
+ 8001368: d803 bhi.n 8001372 <core::fmt::Formatter::write_formatted_parts+0xf2>
+ 800136a: 290a cmp r1, #10
+ 800136c: d209 bcs.n 8001382 <core::fmt::Formatter::write_formatted_parts+0x102>
+ 800136e: 2201 movs r2, #1
+ 8001370: e00c b.n 800138c <core::fmt::Formatter::write_formatted_parts+0x10c>
+ else { if v < 10_000 { 4 } else { 5 } },
+ 8001372: f242 7210 movw r2, #10000 ; 0x2710
+ 8001376: 4291 cmp r1, r2
+ 8001378: f04f 0205 mov.w r2, #5
+ 800137c: bf38 it cc
+ 800137e: 2204 movcc r2, #4
+ 8001380: e004 b.n 800138c <core::fmt::Formatter::write_formatted_parts+0x10c>
+ Part::Num(v) => if v < 1_000 { if v < 10 { 1 } else if v < 100 { 2 } else { 3 } }
+ 8001382: 2964 cmp r1, #100 ; 0x64
+ 8001384: f04f 0203 mov.w r2, #3
+ 8001388: bf38 it cc
+ 800138a: 2202 movcc r2, #2
+ 800138c: 4611 mov r1, r2
+ *c = b'0' + (v % 10) as u8;
+ 800138e: b285 uxth r5, r0
+ 8001390: 1873 adds r3, r6, r1
+ if self.end == self.ptr {
+ 8001392: 3901 subs r1, #1
+ 8001394: fba5 0408 umull r0, r4, r5, r8
+ 8001398: ea4f 00d4 mov.w r0, r4, lsr #3
+ 800139c: eb00 0480 add.w r4, r0, r0, lsl #2
+ 80013a0: eba5 0544 sub.w r5, r5, r4, lsl #1
+ 80013a4: f045 0530 orr.w r5, r5, #48 ; 0x30
+ 80013a8: f803 5c01 strb.w r5, [r3, #-1]
+ 80013ac: d1ef bne.n 800138e <core::fmt::Formatter::write_formatted_parts+0x10e>
+ 80013ae: 9d00 ldr r5, [sp, #0]
+ write_bytes(self.buf, &s[..len])?;
+ 80013b0: e9da 0106 ldrd r0, r1, [sl, #24]
+ buf.write_str(unsafe { str::from_utf8_unchecked(s) })
+ 80013b4: 68cb ldr r3, [r1, #12]
+ 80013b6: 4631 mov r1, r6
+ 80013b8: 4798 blx r3
+ 80013ba: f010 0fff tst.w r0, #255 ; 0xff
+ 80013be: d105 bne.n 80013cc <core::fmt::Formatter::write_formatted_parts+0x14c>
+ if self.ptr == self.end {
+ 80013c0: 45ab cmp fp, r5
+ 80013c2: f47f af81 bne.w 80012c8 <core::fmt::Formatter::write_formatted_parts+0x48>
+ 80013c6: f04f 0900 mov.w r9, #0
+ 80013ca: e001 b.n 80013d0 <core::fmt::Formatter::write_formatted_parts+0x150>
+ 80013cc: f04f 0901 mov.w r9, #1
+ }
+ 80013d0: 4648 mov r0, r9
+ 80013d2: b003 add sp, #12
+ 80013d4: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 80013d8: bdf0 pop {r4, r5, r6, r7, pc}
+ slice_index_len_fail(self.end, slice.len());
+ 80013da: 4610 mov r0, r2
+ 80013dc: 2105 movs r1, #5
+ 80013de: f7ff f8ae bl 800053e <core::slice::slice_index_len_fail>
+
+080013e2 <core::fmt::float::float_to_decimal_common_shortest>:
+}
+
+// Don't inline this so callers that call both this and the above won't wind
+// up using the combined stack space of both functions in some cases.
+#[inline(never)]
+fn float_to_decimal_common_shortest<T>(fmt: &mut Formatter,
+ 80013e2: b5f0 push {r4, r5, r6, r7, lr}
+ 80013e4: af03 add r7, sp, #12
+ 80013e6: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 80013ea: f5ad 6db3 sub.w sp, sp, #1432 ; 0x598
+ 80013ee: b081 sub sp, #4
+ const ZERO_CUTOFF: i64 = -326;
+ other_constants!(f64);
+
+ /// Returns the mantissa, exponent and sign as integers.
+ fn integer_decode(self) -> (u64, i16, i8) {
+ let bits: u64 = unsafe { transmute(self) };
+ 80013f0: ec56 3b10 vmov r3, r6, d0
+ 80013f4: 4684 mov ip, r0
+ 80013f6: 4630 mov r0, r6
+ let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 };
+ let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
+ 80013f8: f3c6 520a ubfx r2, r6, #20, #11
+ let mantissa = if exponent == 0 {
+ 80013fc: 469a mov sl, r3
+ 80013fe: f36f 501f bfc r0, #20, #12
+ 8001402: 2a00 cmp r2, #0
+ (bits & 0xfffffffffffff) << 1
+ 8001404: ea4f 0540 mov.w r5, r0, lsl #1
+ } else {
+ (bits & 0xfffffffffffff) | 0x10000000000000
+ 8001408: f440 1b80 orr.w fp, r0, #1048576 ; 0x100000
+ let mantissa = if exponent == 0 {
+ 800140c: bf04 itt eq
+ 800140e: ea45 7bd3 orreq.w fp, r5, r3, lsr #31
+ 8001412: ea4f 0a4a moveq.w sl, sl, lsl #1
+ const EXP_MASK: u64 = 0x7ff0000000000000;
+ const MAN_MASK: u64 = 0x000fffffffffffff;
+
+ let bits: u64 = unsafe { mem::transmute(self) };
+ match (bits & MAN_MASK, bits & EXP_MASK) {
+ (0, 0) => Fp::Zero,
+ 8001416: f026 4500 bic.w r5, r6, #2147483648 ; 0x80000000
+ 800141a: 431d orrs r5, r3
+ 800141c: d011 beq.n 8001442 <core::fmt::float::float_to_decimal_common_shortest+0x60>
+ (_, 0) => Fp::Subnormal,
+ 800141e: 2400 movs r4, #0
+ 8001420: f04f 0900 mov.w r9, #0
+ 8001424: f6c7 74f0 movt r4, #32752 ; 0x7ff0
+ 8001428: ea06 0504 and.w r5, r6, r4
+ 800142c: 42a5 cmp r5, r4
+ 800142e: d01c beq.n 800146a <core::fmt::float::float_to_decimal_common_shortest+0x88>
+ 8001430: 0068 lsls r0, r5, #1
+ 8001432: d125 bne.n 8001480 <core::fmt::float::float_to_decimal_common_shortest+0x9e>
+ };
+ // Exponent bias + mantissa shift
+ exponent -= 1023 + 52;
+ 8001434: f2a2 4e33 subw lr, r2, #1075 ; 0x433
+ 8001438: f04f 0801 mov.w r8, #1
+ 800143c: f8cd a03c str.w sl, [sp, #60] ; 0x3c
+ 8001440: e03a b.n 80014b8 <core::fmt::float::float_to_decimal_common_shortest+0xd6>
+ 8001442: f244 4598 movw r5, #17560 ; 0x4498
+ 8001446: b2c8 uxtb r0, r1
+ 8001448: f6c0 0500 movt r5, #2048 ; 0x800
+/// Returns the static byte string corresponding to the sign to be formatted.
+/// It can be either `b""`, `b"+"` or `b"-"`.
+fn determine_sign(sign: Sign, decoded: &FullDecoded, negative: bool) -> &'static [u8] {
+ match (*decoded, sign) {
+ (FullDecoded::Nan, _) => b"",
+ (FullDecoded::Zero, Sign::Minus) => b"",
+ 800144c: 2800 cmp r0, #0
+ 800144e: f000 821c beq.w 800188a <core::fmt::float::float_to_decimal_common_shortest+0x4a8>
+ 8001452: 2801 cmp r0, #1
+ 8001454: f000 821b beq.w 800188e <core::fmt::float::float_to_decimal_common_shortest+0x4ac>
+ 8001458: 2802 cmp r0, #2
+ 800145a: f040 8220 bne.w 800189e <core::fmt::float::float_to_decimal_common_shortest+0x4bc>
+ 800145e: f644 25b0 movw r5, #19120 ; 0x4ab0
+ 8001462: 2301 movs r3, #1
+ 8001464: f6c0 0500 movt r5, #2048 ; 0x800
+ 8001468: e226 b.n 80018b8 <core::fmt::float::float_to_decimal_common_shortest+0x4d6>
+/// from given floating point number.
+pub fn decode<T: DecodableFloat>(v: T) -> (/*negative?*/ bool, FullDecoded) {
+ let (mant, exp, sign) = v.integer_decode();
+ let even = (mant & 1) == 0;
+ let decoded = match v.classify() {
+ FpCategory::Nan => FullDecoded::Nan,
+ 800146a: 4318 orrs r0, r3
+ 800146c: bf08 it eq
+ 800146e: f04f 0901 moveq.w r9, #1
+ (FullDecoded::Nan, _) => b"",
+ 8001472: 2800 cmp r0, #0
+ 8001474: f040 8230 bne.w 80018d8 <core::fmt::float::float_to_decimal_common_shortest+0x4f6>
+ 8001478: 920f str r2, [sp, #60] ; 0x3c
+ buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>
+ where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8]) -> (usize, i16) {
+ assert!(parts.len() >= 4);
+ assert!(buf.len() >= MAX_SIG_DIGITS);
+
+ let (negative, full_decoded) = decode(v);
+ 800147a: 0ff0 lsrs r0, r6, #31
+ 800147c: 464a mov r2, r9
+ 800147e: e01d b.n 80014bc <core::fmt::float::float_to_decimal_common_shortest+0xda>
+ FullDecoded::Finite(Decoded { mant: mant, minus: 1, plus: 1,
+ exp: exp, inclusive: even })
+ }
+ FpCategory::Normal => {
+ let minnorm = <T as DecodableFloat>::min_pos_norm_value().integer_decode();
+ if mant == minnorm.0 {
+ 8001480: f48b 1080 eor.w r0, fp, #1048576 ; 0x100000
+ 8001484: ea50 000a orrs.w r0, r0, sl
+ 8001488: d109 bne.n 800149e <core::fmt::float::float_to_decimal_common_shortest+0xbc>
+ 800148a: 2000 movs r0, #0
+ // neighbors: (maxmant, exp - 1) -- (minnormmant, exp) -- (minnormmant + 1, exp)
+ // where maxmant = minnormmant * 2 - 1
+ FullDecoded::Finite(Decoded { mant: mant << 2, minus: 1, plus: 2,
+ exp: exp - 2, inclusive: even })
+ 800148c: f2a2 4e35 subw lr, r2, #1077 ; 0x435
+ 8001490: f04f 0802 mov.w r8, #2
+ 8001494: f44f 0b80 mov.w fp, #4194304 ; 0x400000
+ 8001498: f04f 0900 mov.w r9, #0
+ 800149c: e00b b.n 80014b6 <core::fmt::float::float_to_decimal_common_shortest+0xd4>
+ } else {
+ // neighbors: (mant - 1, exp) -- (mant, exp) -- (mant + 1, exp)
+ FullDecoded::Finite(Decoded { mant: mant << 1, minus: 1, plus: 1,
+ 800149e: ea4f 004b mov.w r0, fp, lsl #1
+ exp: exp - 1, inclusive: even })
+ 80014a2: f2a2 4e34 subw lr, r2, #1076 ; 0x434
+ 80014a6: f04f 0900 mov.w r9, #0
+ 80014aa: f04f 0801 mov.w r8, #1
+ FullDecoded::Finite(Decoded { mant: mant << 1, minus: 1, plus: 1,
+ 80014ae: ea40 7bda orr.w fp, r0, sl, lsr #31
+ 80014b2: ea4f 004a mov.w r0, sl, lsl #1
+ 80014b6: 900f str r0, [sp, #60] ; 0x3c
+ 80014b8: 0ff0 lsrs r0, r6, #31
+ 80014ba: 2203 movs r2, #3
+ (_, Sign::Minus) | (_, Sign::MinusRaw) => if negative { b"-" } else { b"" },
+ 80014bc: f244 4398 movw r3, #17560 ; 0x4498
+ 80014c0: f644 26b0 movw r6, #19120 ; 0x4ab0
+ 80014c4: b2c9 uxtb r1, r1
+ 80014c6: f644 25af movw r5, #19119 ; 0x4aaf
+ 80014ca: f6c0 0300 movt r3, #2048 ; 0x800
+ 80014ce: f6c0 0600 movt r6, #2048 ; 0x800
+ 80014d2: 2902 cmp r1, #2
+ 80014d4: f6c0 0500 movt r5, #2048 ; 0x800
+ 80014d8: bf38 it cc
+ 80014da: 461e movcc r6, r3
+ 80014dc: 2800 cmp r0, #0
+ 80014de: f04f 0300 mov.w r3, #0
+ 80014e2: bf08 it eq
+ 80014e4: 4635 moveq r5, r6
+ 80014e6: 2901 cmp r1, #1
+ 80014e8: bf88 it hi
+ 80014ea: 2301 movhi r3, #1
+ 80014ec: 4303 orrs r3, r0
+ let sign = determine_sign(sign, &full_decoded, negative);
+ match full_decoded {
+ FullDecoded::Nan => {
+ 80014ee: f002 0003 and.w r0, r2, #3
+ 80014f2: 2801 cmp r0, #1
+ 80014f4: d109 bne.n 800150a <core::fmt::float::float_to_decimal_common_shortest+0x128>
+ parts[0] = Part::Copy(b"NaN");
+ Formatted { sign: sign, parts: &parts[..1] }
+ }
+ FullDecoded::Infinite => {
+ parts[0] = Part::Copy(b"inf");
+ 80014f6: 2002 movs r0, #2
+ 80014f8: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 80014fc: f827 0cc0 strh.w r0, [r7, #-192]
+ 8001500: f644 306b movw r0, #19307 ; 0x4b6b
+ 8001504: f6c0 0000 movt r0, #2048 ; 0x800
+ 8001508: e1f4 b.n 80018f4 <core::fmt::float::float_to_decimal_common_shortest+0x512>
+ 800150a: 9c0f ldr r4, [sp, #60] ; 0x3c
+/// The shortest mode implementation for Grisu.
+///
+/// It returns `None` when it would return an inexact representation otherwise.
+pub fn format_shortest_opt(d: &Decoded,
+ buf: &mut [u8]) -> Option<(/*#digits*/ usize, /*exp*/ i16)> {
+ assert!(d.mant > 0);
+ 800150c: ea54 000b orrs.w r0, r4, fp
+ 8001510: f001 8149 beq.w 80027a6 <core::fmt::float::float_to_decimal_common_shortest+0x13c4>
+ 8001514: eb14 0108 adds.w r1, r4, r8
+ 8001518: f04f 0000 mov.w r0, #0
+ 800151c: eb4b 0209 adc.w r2, fp, r9
+ 8001520: 1b09 subs r1, r1, r4
+ 8001522: eb72 010b sbcs.w r1, r2, fp
+ 8001526: f04f 0100 mov.w r1, #0
+ 800152a: bf38 it cc
+ 800152c: 2101 movcc r1, #1
+ if b {None} else {Some(a)}
+ 800152e: 2900 cmp r1, #0
+ 8001530: f041 813f bne.w 80027b2 <core::fmt::float::float_to_decimal_common_shortest+0x13d0>
+ /// ```
+ #[inline]
+ #[stable(feature = "wrapping", since = "1.7.0")]
+ pub fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
+ unsafe {
+ let (a, b) = $sub_with_overflow(self as $ActualT,
+ 8001534: 1e61 subs r1, r4, #1
+ 8001536: f16b 0200 sbc.w r2, fp, #0
+ 800153a: 1a61 subs r1, r4, r1
+ 800153c: eb7b 0102 sbcs.w r1, fp, r2
+ 8001540: bf38 it cc
+ 8001542: 2001 movcc r0, #1
+ if b {None} else {Some(a)}
+ 8001544: 2800 cmp r0, #0
+ 8001546: f041 813a bne.w 80027be <core::fmt::float::float_to_decimal_common_shortest+0x13dc>
+ assert!(d.minus > 0);
+ assert!(d.plus > 0);
+ assert!(d.mant.checked_add(d.plus).is_some());
+ assert!(d.mant.checked_sub(d.minus).is_some());
+ assert!(buf.len() >= MAX_SIG_DIGITS);
+ assert!(d.mant + d.plus < (1 << 61)); // we need at least three bits of additional precision
+ 800154a: eb14 0208 adds.w r2, r4, r8
+ 800154e: f8cd a060 str.w sl, [sp, #96] ; 0x60
+ 8001552: e9cd 5c04 strd r5, ip, [sp, #16]
+ 8001556: 46a4 mov ip, r4
+ 8001558: e9cd 8302 strd r8, r3, [sp, #8]
+ 800155c: eb4b 0609 adc.w r6, fp, r9
+ 8001560: f1b6 5f00 cmp.w r6, #536870912 ; 0x20000000
+ 8001564: f081 8131 bcs.w 80027ca <core::fmt::float::float_to_decimal_common_shortest+0x13e8>
+
+ /// Normalizes itself so that the resulting mantissa is at least `2^63`.
+ pub fn normalize(&self) -> Fp {
+ let mut f = self.f;
+ let mut e = self.e;
+ if f >> (64 - 32) == 0 {
+ 8001568: 2e00 cmp r6, #0
+ 800156a: 4634 mov r4, r6
+ 800156c: bf04 itt eq
+ 800156e: 4614 moveq r4, r2
+ 8001570: 4632 moveq r2, r6
+ f <<= 32;
+ e -= 32;
+ }
+ if f >> (64 - 16) == 0 {
+ 8001572: f5b4 3f80 cmp.w r4, #65536 ; 0x10000
+ 8001576: 4613 mov r3, r2
+ f <<= 16;
+ 8001578: ea4f 4004 mov.w r0, r4, lsl #16
+ if f >> (64 - 16) == 0 {
+ 800157c: 4625 mov r5, r4
+ 800157e: bf38 it cc
+ 8001580: 041b lslcc r3, r3, #16
+ 8001582: bf38 it cc
+ 8001584: ea40 4512 orrcc.w r5, r0, r2, lsr #16
+ e -= 16;
+ }
+ if f >> (64 - 8) == 0 {
+ 8001588: f1b5 7f80 cmp.w r5, #16777216 ; 0x1000000
+ 800158c: 461a mov r2, r3
+ f <<= 8;
+ 800158e: ea4f 2105 mov.w r1, r5, lsl #8
+ if f >> (64 - 8) == 0 {
+ 8001592: 4628 mov r0, r5
+ 8001594: bf38 it cc
+ 8001596: 0212 lslcc r2, r2, #8
+ 8001598: bf38 it cc
+ 800159a: ea41 6013 orrcc.w r0, r1, r3, lsr #24
+ e -= 8;
+ }
+ if f >> (64 - 4) == 0 {
+ 800159e: f1b0 5f80 cmp.w r0, #268435456 ; 0x10000000
+ 80015a2: 4692 mov sl, r2
+ f <<= 4;
+ 80015a4: ea4f 1300 mov.w r3, r0, lsl #4
+ if f >> (64 - 4) == 0 {
+ 80015a8: 4601 mov r1, r0
+ 80015aa: bf38 it cc
+ 80015ac: ea4f 1a0a movcc.w sl, sl, lsl #4
+ 80015b0: bf38 it cc
+ 80015b2: ea43 7112 orrcc.w r1, r3, r2, lsr #28
+ e -= 4;
+ }
+ if f >> (64 - 2) == 0 {
+ f <<= 2;
+ 80015b6: 008a lsls r2, r1, #2
+ if f >> (64 - 2) == 0 {
+ 80015b8: f1b1 4f80 cmp.w r1, #1073741824 ; 0x40000000
+ 80015bc: 4688 mov r8, r1
+ 80015be: bf3c itt cc
+ 80015c0: ea42 789a orrcc.w r8, r2, sl, lsr #30
+ 80015c4: ea4f 0a8a movcc.w sl, sl, lsl #2
+ if f >> (64 - 32) == 0 {
+ 80015c8: 2e00 cmp r6, #0
+ 80015ca: 4672 mov r2, lr
+ 80015cc: bf08 it eq
+ 80015ce: 3a20 subeq r2, #32
+ if f >> (64 - 16) == 0 {
+ 80015d0: f5b4 3f80 cmp.w r4, #65536 ; 0x10000
+ 80015d4: bf38 it cc
+ 80015d6: 3a10 subcc r2, #16
+ if f >> (64 - 8) == 0 {
+ 80015d8: f1b5 7f80 cmp.w r5, #16777216 ; 0x1000000
+ 80015dc: bf38 it cc
+ 80015de: 3a08 subcc r2, #8
+ if f >> (64 - 4) == 0 {
+ 80015e0: f1b0 5f80 cmp.w r0, #268435456 ; 0x10000000
+ e -= 2;
+ }
+ if f >> (64 - 1) == 0 {
+ 80015e4: ea6f 70e8 mvn.w r0, r8, asr #31
+ if f >> (64 - 4) == 0 {
+ 80015e8: bf38 it cc
+ 80015ea: 3a04 subcc r2, #4
+ if f >> (64 - 2) == 0 {
+ 80015ec: f1b1 4f80 cmp.w r1, #1073741824 ; 0x40000000
+ 80015f0: bf38 it cc
+ 80015f2: 3a02 subcc r2, #2
+ if f >> (64 - 1) == 0 {
+ 80015f4: 4410 add r0, r2
+
+ // start with the normalized values with the shared exponent
+ let plus = Fp { f: d.mant + d.plus, e: d.exp }.normalize();
+ let minus = Fp { f: d.mant - d.minus, e: d.exp }.normalize_to(plus.e);
+ 80015f6: f1bc 0201 subs.w r2, ip, #1
+ 80015fa: 9019 str r0, [sp, #100] ; 0x64
+ }
+
+ /// Normalizes itself to have the shared exponent.
+ /// It can only decrease the exponent (and thus increase the mantissa).
+ pub fn normalize_to(&self, e: i16) -> Fp {
+ let edelta = self.e - e;
+ 80015fc: ebae 0000 sub.w r0, lr, r0
+ 8001600: f16b 0100 sbc.w r1, fp, #0
+ 8001604: b200 sxth r0, r0
+ assert!(edelta >= 0);
+ 8001606: f1b0 3fff cmp.w r0, #4294967295 ; 0xffffffff
+ 800160a: f341 80e4 ble.w 80027d6 <core::fmt::float::float_to_decimal_common_shortest+0x13f4>
+ let edelta = edelta as usize;
+ assert_eq!(self.f << edelta >> edelta, self.f);
+ 800160e: f000 003f and.w r0, r0, #63 ; 0x3f
+ 8001612: f8cd 9038 str.w r9, [sp, #56] ; 0x38
+ 8001616: f1c0 0420 rsb r4, r0, #32
+ 800161a: fa01 f300 lsl.w r3, r1, r0
+ 800161e: fa02 f900 lsl.w r9, r2, r0
+ 8001622: fa22 f604 lsr.w r6, r2, r4
+ 8001626: ea46 0c03 orr.w ip, r6, r3
+ 800162a: f1a0 0320 sub.w r3, r0, #32
+ 800162e: 2b00 cmp r3, #0
+ 8001630: bfa8 it ge
+ 8001632: fa02 fc03 lslge.w ip, r2, r3
+ 8001636: bfa8 it ge
+ 8001638: f04f 0900 movge.w r9, #0
+ 800163c: 2b00 cmp r3, #0
+ 800163e: fa0c f404 lsl.w r4, ip, r4
+ 8001642: fa29 f500 lsr.w r5, r9, r0
+ 8001646: ea44 0405 orr.w r4, r4, r5
+ 800164a: bfa8 it ge
+ 800164c: fa2c f403 lsrge.w r4, ip, r3
+ 8001650: fa2c f300 lsr.w r3, ip, r0
+ 8001654: bfa8 it ge
+ 8001656: 2300 movge r3, #0
+ 8001658: 4062 eors r2, r4
+ 800165a: 4059 eors r1, r3
+ 800165c: 4311 orrs r1, r2
+ 800165e: f041 80a0 bne.w 80027a2 <core::fmt::float::float_to_decimal_common_shortest+0x13c0>
+ 8001662: 9e0f ldr r6, [sp, #60] ; 0x3c
+ 8001664: b283 uxth r3, r0
+ 8001666: f1c3 0220 rsb r2, r3, #32
+ 800166a: fa0b f103 lsl.w r1, fp, r3
+ 800166e: fa26 f402 lsr.w r4, r6, r2
+ 8001672: 4321 orrs r1, r4
+ 8001674: f06f 041f mvn.w r4, #31
+ 8001678: fa14 f080 uxtah r0, r4, r0
+ 800167c: 2800 cmp r0, #0
+ 800167e: bfa8 it ge
+ 8001680: fa06 f100 lslge.w r1, r6, r0
+ 8001684: fa01 f402 lsl.w r4, r1, r2
+ 8001688: fa06 f203 lsl.w r2, r6, r3
+ 800168c: bfa8 it ge
+ 800168e: 2200 movge r2, #0
+ 8001690: 2800 cmp r0, #0
+ 8001692: fa22 f503 lsr.w r5, r2, r3
+ 8001696: fa21 f303 lsr.w r3, r1, r3
+ 800169a: ea44 0405 orr.w r4, r4, r5
+ 800169e: bfa8 it ge
+ 80016a0: fa21 f400 lsrge.w r4, r1, r0
+ 80016a4: bfa8 it ge
+ 80016a6: 2300 movge r3, #0
+ 80016a8: ea84 0006 eor.w r0, r4, r6
+ 80016ac: ea83 030b eor.w r3, r3, fp
+ 80016b0: 4318 orrs r0, r3
+ 80016b2: f041 8076 bne.w 80027a2 <core::fmt::float::float_to_decimal_common_shortest+0x13c0>
+ 80016b6: a815 add r0, sp, #84 ; 0x54
+ let idx = ((gamma as i32) - offset) * range / domain;
+ 80016b8: f245 33b0 movw r3, #21424 ; 0x53b0
+ 80016bc: e880 1204 stmia.w r0, {r2, r9, ip}
+ 80016c0: e9cd be08 strd fp, lr, [sp, #32]
+ 80016c4: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
+ 80016c8: f2c0 0301 movt r3, #1
+ 80016cc: f8dd 9064 ldr.w r9, [sp, #100] ; 0x64
+ // 2. the remainder of `floor(plus * cached)` repeatedly gets multiplied by 10,
+ // and it should not overflow.
+ //
+ // the first gives `64 + GAMMA <= 32`, while the second gives `10 * 2^-ALPHA <= 2^64`;
+ // -60 and -32 is the maximal range with this constraint, and V8 also uses them.
+ let (minusk, cached) = cached_power(ALPHA - plus.e - 64, GAMMA - plus.e - 64);
+ 80016d0: 385f subs r0, #95 ; 0x5f
+ 80016d2: eba0 0009 sub.w r0, r0, r9
+ let idx = ((gamma as i32) - offset) * range / domain;
+ 80016d6: b200 sxth r0, r0
+ 80016d8: eb00 0080 add.w r0, r0, r0, lsl #2
+ 80016dc: eb03 1000 add.w r0, r3, r0, lsl #4
+ 80016e0: f64c 1393 movw r3, #51603 ; 0xc993
+ 80016e4: f6c7 334d movt r3, #31565 ; 0x7b4d
+ 80016e8: fb50 f003 smmul r0, r0, r3
+ 80016ec: 1283 asrs r3, r0, #10
+ 80016ee: eb03 70d0 add.w r0, r3, r0, lsr #31
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 80016f2: 2851 cmp r0, #81 ; 0x51
+ 80016f4: f081 8075 bcs.w 80027e2 <core::fmt::float::float_to_decimal_common_shortest+0x1400>
+ 80016f8: 231e movs r3, #30
+ if f >> (64 - 1) == 0 {
+ 80016fa: ea4f 045a mov.w r4, sl, lsr #1
+ 80016fe: ea43 73d8 orr.w r3, r3, r8, lsr #31
+ 8001702: fa24 f303 lsr.w r3, r4, r3
+ 8001706: 2401 movs r4, #1
+ 8001708: ea84 74d8 eor.w r4, r4, r8, lsr #31
+ 800170c: fa08 f504 lsl.w r5, r8, r4
+ 8001710: f643 58c0 movw r8, #15808 ; 0x3dc0
+ 8001714: f6c0 0800 movt r8, #2048 ; 0x800
+ 8001718: 432b orrs r3, r5
+ 800171a: fa0a f504 lsl.w r5, sl, r4
+ 800171e: eb08 1200 add.w r2, r8, r0, lsl #4
+ 8001722: 0100 lsls r0, r0, #4
+ 8001724: 6856 ldr r6, [r2, #4]
+ 8001726: f858 0000 ldr.w r0, [r8, r0]
+ 800172a: 4614 mov r4, r2
+ let bc = b * c;
+ 800172c: 9414 str r4, [sp, #80] ; 0x50
+ 800172e: fba6 ae05 umull sl, lr, r6, r5
+ let ad = a * d;
+ 8001732: fba0 2803 umull r2, r8, r0, r3
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 8001736: fbe6 8e63 umaal r8, lr, r6, r3
+ let bd = b * d;
+ 800173a: fba0 3505 umull r3, r5, r0, r5
+ let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
+ 800173e: 1953 adds r3, r2, r5
+ 8001740: f04f 0200 mov.w r2, #0
+ 8001744: f142 0500 adc.w r5, r2, #0
+ 8001748: eb13 030a adds.w r3, r3, sl
+ 800174c: f145 0500 adc.w r5, r5, #0
+ 8001750: f113 4300 adds.w r3, r3, #2147483648 ; 0x80000000
+ 8001754: f145 0300 adc.w r3, r5, #0
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 8001758: eb13 0308 adds.w r3, r3, r8
+ 800175c: f14e 0500 adc.w r5, lr, #0
+ //
+ // the "unsafe region" is a liberal interval which we initially generate.
+ // the "safe region" is a conservative interval which we only accept.
+ // we start with the correct repr within the unsafe region, and try to find the closest repr
+ // to `v` which is also within the safe region. if we can't, we give up.
+ let plus1 = plus.f + 1;
+ 8001760: f113 0e01 adds.w lr, r3, #1
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 8001764: 8923 ldrh r3, [r4, #8]
+ let plus1 = plus.f + 1;
+ 8001766: f145 0c00 adc.w ip, r5, #0
+ let e = self.e + other.e + 64;
+ 800176a: 444b add r3, r9
+// let plus0 = plus.f - 1; // only for explanation
+// let minus0 = minus.f + 1; // only for explanation
+ let minus1 = minus.f - 1;
+ let e = -plus.e as usize; // shared exponent
+ 800176c: 425b negs r3, r3
+
+ // divide `plus1` into integral and fractional parts.
+ // integral parts are guaranteed to fit in u32, since cached power guarantees `plus < 2^32`
+ // and normalized `plus.f` is always less than `2^64 - 2^4` due to the precision requirement.
+ let plus1int = (plus1 >> e) as u32;
+ 800176e: f003 093f and.w r9, r3, #63 ; 0x3f
+ 8001772: f1c9 0220 rsb r2, r9, #32
+ 8001776: 9219 str r2, [sp, #100] ; 0x64
+ 8001778: fa0c f302 lsl.w r3, ip, r2
+ 800177c: fa2e f209 lsr.w r2, lr, r9
+ 8001780: ea42 0a03 orr.w sl, r2, r3
+ 8001784: f1a9 0320 sub.w r3, r9, #32
+ let ad = a * d;
+ 8001788: fba0 2b01 umull r2, fp, r0, r1
+ 800178c: 2b00 cmp r3, #0
+ 800178e: bfa8 it ge
+ 8001790: fa2c fa03 lsrge.w sl, ip, r3
+ 8001794: 9c15 ldr r4, [sp, #84] ; 0x54
+ let bc = b * c;
+ 8001796: fba6 8504 umull r8, r5, r6, r4
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 800179a: fbe6 b561 umaal fp, r5, r6, r1
+ let bd = b * d;
+ 800179e: fba0 1404 umull r1, r4, r0, r4
+ let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
+ 80017a2: 1911 adds r1, r2, r4
+ 80017a4: f04f 0200 mov.w r2, #0
+ 80017a8: f142 0200 adc.w r2, r2, #0
+ 80017ac: eb11 0108 adds.w r1, r1, r8
+ 80017b0: f142 0200 adc.w r2, r2, #0
+ 80017b4: f111 4100 adds.w r1, r1, #2147483648 ; 0x80000000
+ 80017b8: f142 0100 adc.w r1, r2, #0
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 80017bc: eb1b 0b01 adds.w fp, fp, r1
+ 80017c0: 9916 ldr r1, [sp, #88] ; 0x58
+ 80017c2: f145 0800 adc.w r8, r5, #0
+ let bc = b * c;
+ 80017c6: fba6 2401 umull r2, r4, r6, r1
+ let bd = b * d;
+ 80017ca: 9413 str r4, [sp, #76] ; 0x4c
+ 80017cc: fba0 1401 umull r1, r4, r0, r1
+ 80017d0: 9917 ldr r1, [sp, #92] ; 0x5c
+ let ad = a * d;
+ 80017d2: fba0 0501 umull r0, r5, r0, r1
+ let ac = a * c;
+ 80017d6: fba6 1601 umull r1, r6, r6, r1
+ let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
+ 80017da: 1900 adds r0, r0, r4
+ 80017dc: f04f 0400 mov.w r4, #0
+ 80017e0: 9510 str r5, [sp, #64] ; 0x40
+ 80017e2: f144 0400 adc.w r4, r4, #0
+ 80017e6: 1880 adds r0, r0, r2
+ 80017e8: f144 0200 adc.w r2, r4, #0
+ 80017ec: f110 4000 adds.w r0, r0, #2147483648 ; 0x80000000
+ 80017f0: f142 0000 adc.w r0, r2, #0
+ 80017f4: 2201 movs r2, #1
+ let plus1frac = plus1 & ((1 << e) - 1);
+ 80017f6: 2b00 cmp r3, #0
+ 80017f8: 900d str r0, [sp, #52] ; 0x34
+ 80017fa: 9819 ldr r0, [sp, #100] ; 0x64
+ 80017fc: fa22 f400 lsr.w r4, r2, r0
+ 8001800: bfa8 it ge
+ 8001802: fa02 f403 lslge.w r4, r2, r3
+ 8001806: fa02 f209 lsl.w r2, r2, r9
+ 800180a: f8cd 9054 str.w r9, [sp, #84] ; 0x54
+ 800180e: bfa8 it ge
+ 8001810: 2200 movge r2, #0
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 8001812: 9814 ldr r0, [sp, #80] ; 0x50
+ 8001814: f8cd e028 str.w lr, [sp, #40] ; 0x28
+ 8001818: 9400 str r4, [sp, #0]
+ 800181a: f8cd c02c str.w ip, [sp, #44] ; 0x2c
+ let ac = a * c;
+ 800181e: 920c str r2, [sp, #48] ; 0x30
+ let plus1frac = plus1 & ((1 << e) - 1);
+ 8001820: 3a01 subs r2, #1
+ 8001822: 9214 str r2, [sp, #80] ; 0x50
+ 8001824: ea02 020e and.w r2, r2, lr
+ 8001828: 9217 str r2, [sp, #92] ; 0x5c
+ 800182a: f164 0200 sbc.w r2, r4, #0
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 800182e: 8940 ldrh r0, [r0, #10]
+ 8001830: 9212 str r2, [sp, #72] ; 0x48
+ let plus1frac = plus1 & ((1 << e) - 1);
+ 8001832: ea02 020c and.w r2, r2, ip
+ if x < X4 {
+ 8001836: 9219 str r2, [sp, #100] ; 0x64
+ 8001838: f242 720f movw r2, #9999 ; 0x270f
+ 800183c: e9cd b806 strd fp, r8, [sp, #24]
+ 8001840: 9116 str r1, [sp, #88] ; 0x58
+ 8001842: 4592 cmp sl, r2
+ 8001844: 9011 str r0, [sp, #68] ; 0x44
+ 8001846: d80e bhi.n 8001866 <core::fmt::float::float_to_decimal_common_shortest+0x484>
+ if x < X2 { if x < X1 {(0, 1)} else {(1, X1)} }
+ 8001848: f1ba 0f64 cmp.w sl, #100 ; 0x64
+ 800184c: d25a bcs.n 8001904 <core::fmt::float::float_to_decimal_common_shortest+0x522>
+ 800184e: 250a movs r5, #10
+ 8001850: f1ba 0f0a cmp.w sl, #10
+ 8001854: f04f 0400 mov.w r4, #0
+ 8001858: bf38 it cc
+ 800185a: 2501 movcc r5, #1
+ 800185c: f1ba 0f09 cmp.w sl, #9
+ 8001860: bf88 it hi
+ 8001862: 2401 movhi r4, #1
+ 8001864: e058 b.n 8001918 <core::fmt::float::float_to_decimal_common_shortest+0x536>
+ 8001866: f244 2540 movw r5, #16960 ; 0x4240
+ 800186a: f2c0 050f movt r5, #15
+ if x < X6 { if x < X5 {(4, X4)} else {(5, X5)} }
+ 800186e: 45aa cmp sl, r5
+ 8001870: f080 8202 bcs.w 8001c78 <core::fmt::float::float_to_decimal_common_shortest+0x896>
+ 8001874: f248 65a0 movw r5, #34464 ; 0x86a0
+ 8001878: 2405 movs r4, #5
+ 800187a: f2c0 0501 movt r5, #1
+ 800187e: 45aa cmp sl, r5
+ 8001880: bf3c itt cc
+ 8001882: 2404 movcc r4, #4
+ 8001884: f242 7510 movwcc r5, #10000 ; 0x2710
+ 8001888: e046 b.n 8001918 <core::fmt::float::float_to_decimal_common_shortest+0x536>
+ 800188a: 2300 movs r3, #0
+ 800188c: e014 b.n 80018b8 <core::fmt::float::float_to_decimal_common_shortest+0x4d6>
+ (FullDecoded::Zero, Sign::MinusRaw) => if negative { b"-" } else { b"" },
+ 800188e: f644 20af movw r0, #19119 ; 0x4aaf
+ 8001892: 2e00 cmp r6, #0
+ let (negative, full_decoded) = decode(v);
+ 8001894: ea4f 73d6 mov.w r3, r6, lsr #31
+ (FullDecoded::Zero, Sign::MinusRaw) => if negative { b"-" } else { b"" },
+ 8001898: f6c0 0000 movt r0, #2048 ; 0x800
+ 800189c: e00a b.n 80018b4 <core::fmt::float::float_to_decimal_common_shortest+0x4d2>
+ (FullDecoded::Zero, Sign::MinusPlusRaw) => if negative { b"-" } else { b"+" },
+ 800189e: f644 20af movw r0, #19119 ; 0x4aaf
+ 80018a2: f644 25b0 movw r5, #19120 ; 0x4ab0
+ 80018a6: 2e00 cmp r6, #0
+ 80018a8: f04f 0301 mov.w r3, #1
+ 80018ac: f6c0 0000 movt r0, #2048 ; 0x800
+ 80018b0: f6c0 0500 movt r5, #2048 ; 0x800
+ 80018b4: bfb8 it lt
+ 80018b6: 4605 movlt r5, r0
+ if frac_digits > 0 { // [0.][0000]
+ parts[0] = Part::Copy(b"0.");
+ parts[1] = Part::Zero(frac_digits);
+ Formatted { sign: sign, parts: &parts[..2] }
+ } else {
+ parts[0] = Part::Copy(b"0");
+ 80018b8: 2002 movs r0, #2
+ 80018ba: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 80018be: f827 0cc0 strh.w r0, [r7, #-192]
+ 80018c2: f644 306e movw r0, #19310 ; 0x4b6e
+ 80018c6: f6c0 0000 movt r0, #2048 ; 0x800
+ 80018ca: f847 0cbc str.w r0, [r7, #-188]
+ 80018ce: 2001 movs r0, #1
+ 80018d0: f847 0cb8 str.w r0, [r7, #-184]
+ 80018d4: f000 bf19 b.w 800270a <core::fmt::float::float_to_decimal_common_shortest+0x1328>
+ parts[0] = Part::Copy(b"NaN");
+ 80018d8: 2002 movs r0, #2
+ 80018da: f244 4598 movw r5, #17560 ; 0x4498
+ 80018de: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 80018e2: 2300 movs r3, #0
+ 80018e4: f827 0cc0 strh.w r0, [r7, #-192]
+ 80018e8: f644 3068 movw r0, #19304 ; 0x4b68
+ 80018ec: f6c0 0500 movt r5, #2048 ; 0x800
+ 80018f0: f6c0 0000 movt r0, #2048 ; 0x800
+ 80018f4: f847 0cbc str.w r0, [r7, #-188]
+ 80018f8: 2003 movs r0, #3
+ 80018fa: f847 0cb8 str.w r0, [r7, #-184]
+ 80018fe: 2001 movs r0, #1
+ 8001900: f000 bf03 b.w 800270a <core::fmt::float::float_to_decimal_common_shortest+0x1328>
+ else { if x < X3 {(2, X2)} else {(3, X3)} }
+ 8001904: f44f 757a mov.w r5, #1000 ; 0x3e8
+ 8001908: f5ba 7f7a cmp.w sl, #1000 ; 0x3e8
+ 800190c: f04f 0403 mov.w r4, #3
+ 8001910: bf38 it cc
+ 8001912: 2564 movcc r5, #100 ; 0x64
+ 8001914: bf38 it cc
+ 8001916: 2402 movcc r4, #2
+ 8001918: f8dd e04c ldr.w lr, [sp, #76] ; 0x4c
+ 800191c: 9b10 ldr r3, [sp, #64] ; 0x40
+ 800191e: 980d ldr r0, [sp, #52] ; 0x34
+ 8001920: 2101 movs r1, #1
+ let even = (mant & 1) == 0;
+ 8001922: 9a18 ldr r2, [sp, #96] ; 0x60
+ 8001924: f04f 0c00 mov.w ip, #0
+ 8001928: f10d 096b add.w r9, sp, #107 ; 0x6b
+ 800192c: ea21 0202 bic.w r2, r1, r2
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 8001930: 9916 ldr r1, [sp, #88] ; 0x58
+ 8001932: 9213 str r2, [sp, #76] ; 0x4c
+ 8001934: f1d1 0201 rsbs r2, r1, #1
+ 8001938: eb6c 0606 sbc.w r6, ip, r6
+ 800193c: 1ad1 subs r1, r2, r3
+ 800193e: f166 0200 sbc.w r2, r6, #0
+ 8001942: ebb1 010e subs.w r1, r1, lr
+ 8001946: f162 0200 sbc.w r2, r2, #0
+ let minus1 = minus.f - 1;
+ 800194a: 1a08 subs r0, r1, r0
+ 800194c: f162 0100 sbc.w r1, r2, #0
+ //
+ // find the digit length `kappa` between `(minus1, plus1)` as per Theorem 6.2.
+ // Theorem 6.2 can be adopted to exclude `x` by requiring `y mod 10^k < y - x` instead.
+ // (e.g. `x` = 32000, `y` = 32777; `kappa` = 2 since `y mod 10^3 = 777 < y - x = 777`.)
+ // the algorithm relies on the later verification phase to exclude `y`.
+ let delta1 = plus1 - minus1;
+ 8001950: 9a0a ldr r2, [sp, #40] ; 0x28
+ 8001952: 1883 adds r3, r0, r2
+ 8001954: 980b ldr r0, [sp, #44] ; 0x2c
+ 8001956: 4141 adcs r1, r0
+// let delta1int = (delta1 >> e) as usize; // only for explanation
+ let delta1frac = delta1 & ((1 << e) - 1);
+ 8001958: 9812 ldr r0, [sp, #72] ; 0x48
+ 800195a: 9116 str r1, [sp, #88] ; 0x58
+ 800195c: 4008 ands r0, r1
+ let exp = max_kappa as i16 - minusk + 1;
+ 800195e: b2e1 uxtb r1, r4
+ let delta1frac = delta1 & ((1 << e) - 1);
+ 8001960: 9010 str r0, [sp, #64] ; 0x40
+ 8001962: 9814 ldr r0, [sp, #80] ; 0x50
+ 8001964: 4688 mov r8, r1
+ 8001966: 4018 ands r0, r3
+ let exp = max_kappa as i16 - minusk + 1;
+ 8001968: 9001 str r0, [sp, #4]
+ 800196a: 9811 ldr r0, [sp, #68] ; 0x44
+ 800196c: 1a09 subs r1, r1, r0
+ 800196e: 9815 ldr r0, [sp, #84] ; 0x54
+ 8001970: 3101 adds r1, #1
+ 8001972: 910d str r1, [sp, #52] ; 0x34
+ 8001974: f06f 011f mvn.w r1, #31
+ 8001978: fa11 f180 uxtah r1, r1, r0
+ let r = remainder % ten_kappa;
+ debug_assert!(q < 10);
+ buf[i] = b'0' + q as u8;
+ i += 1;
+
+ let plus1rem = ((r as u64) << e) + plus1frac; // == (plus1 % 10^kappa) * 2^e
+ 800197c: 9815 ldr r0, [sp, #84] ; 0x54
+ let r = remainder % ten_kappa;
+ 800197e: fbba f4f5 udiv r4, sl, r5
+ let plus1rem = ((r as u64) << e) + plus1frac; // == (plus1 % 10^kappa) * 2^e
+ 8001982: 2900 cmp r1, #0
+ let r = remainder % ten_kappa;
+ 8001984: fb04 aa15 mls sl, r4, r5, sl
+ buf[i] = b'0' + q as u8;
+ 8001988: f104 0e30 add.w lr, r4, #48 ; 0x30
+ 800198c: f809 e00c strb.w lr, [r9, ip]
+ let plus1rem = ((r as u64) << e) + plus1frac; // == (plus1 % 10^kappa) * 2^e
+ 8001990: fa1f fb80 uxth.w fp, r0
+ 8001994: f1cb 0020 rsb r0, fp, #32
+ 8001998: fa0a f40b lsl.w r4, sl, fp
+ 800199c: fa2a f600 lsr.w r6, sl, r0
+ 80019a0: 9018 str r0, [sp, #96] ; 0x60
+ 80019a2: bfa8 it ge
+ 80019a4: fa0a f601 lslge.w r6, sl, r1
+ 80019a8: bfa8 it ge
+ 80019aa: 2400 movge r4, #0
+ 80019ac: 9817 ldr r0, [sp, #92] ; 0x5c
+ 80019ae: 1824 adds r4, r4, r0
+ 80019b0: 9819 ldr r0, [sp, #100] ; 0x64
+ 80019b2: 4146 adcs r6, r0
+ if plus1rem < delta1 {
+ 80019b4: 1ae2 subs r2, r4, r3
+ i += 1;
+ 80019b6: f10c 0001 add.w r0, ip, #1
+ if plus1rem < delta1 {
+ 80019ba: 9a16 ldr r2, [sp, #88] ; 0x58
+ 80019bc: eb76 0202 sbcs.w r2, r6, r2
+ 80019c0: d314 bcc.n 80019ec <core::fmt::float::float_to_decimal_common_shortest+0x60a>
+ return round_and_weed(&mut buf[..i], exp, plus1rem, delta1, plus1 - v.f, ten_kappa, 1);
+ }
+
+ // break the loop when we have rendered all integral digits.
+ // the exact number of digits is `max_kappa + 1` as `plus1 < 10^(max_kappa+1)`.
+ if i > max_kappa as usize {
+ 80019c2: 4540 cmp r0, r8
+ 80019c4: f200 8092 bhi.w 8001aec <core::fmt::float::float_to_decimal_common_shortest+0x70a>
+ break;
+ }
+
+ // restore invariants
+ kappa -= 1;
+ ten_kappa /= 10;
+ 80019c8: f64c 42cd movw r2, #52429 ; 0xcccd
+ let q = remainder / ten_kappa;
+ 80019cc: 2d0a cmp r5, #10
+ 80019ce: 4684 mov ip, r0
+ ten_kappa /= 10;
+ 80019d0: f6cc 42cc movt r2, #52428 ; 0xcccc
+ 80019d4: fba5 2602 umull r2, r6, r5, r2
+ 80019d8: ea4f 02d6 mov.w r2, r6, lsr #3
+ 80019dc: 4615 mov r5, r2
+ 80019de: d2cd bcs.n 800197c <core::fmt::float::float_to_decimal_common_shortest+0x59a>
+ let q = remainder / ten_kappa;
+ 80019e0: f644 00b4 movw r0, #18612 ; 0x48b4
+ 80019e4: f6c0 0000 movt r0, #2048 ; 0x800
+ 80019e8: f7ff f883 bl 8000af2 <core::panicking::panic>
+ let ten_kappa = (ten_kappa as u64) << e; // scale 10^kappa back to the shared exponent
+ 80019ec: 9915 ldr r1, [sp, #84] ; 0x54
+ 80019ee: 9017 str r0, [sp, #92] ; 0x5c
+ 80019f0: f06f 001f mvn.w r0, #31
+ 80019f4: fa10 f081 uxtah r0, r0, r1
+ 80019f8: 9918 ldr r1, [sp, #96] ; 0x60
+ 80019fa: 2800 cmp r0, #0
+ 80019fc: fa25 fa01 lsr.w sl, r5, r1
+ 8001a00: f04f 0100 mov.w r1, #0
+ 8001a04: bfa8 it ge
+ 8001a06: fa05 fa00 lslge.w sl, r5, r0
+ 8001a0a: fa05 f50b lsl.w r5, r5, fp
+ 8001a0e: bfa8 it ge
+ 8001a10: 2500 movge r5, #0
+ // combined with TC3a.
+ //
+ // consequently, we should stop when `TC1 || TC2 || (TC3a && TC3b)`. the following is
+ // equal to its inverse, `!TC1 && !TC2 && (!TC3a || !TC3b)`.
+ while plus1w < plus1v_up &&
+ threshold - plus1w >= ten_kappa &&
+ 8001a12: 9816 ldr r0, [sp, #88] ; 0x58
+ 8001a14: ebb3 0904 subs.w r9, r3, r4
+ 8001a18: 9318 str r3, [sp, #96] ; 0x60
+ 8001a1a: eb60 0206 sbc.w r2, r0, r6
+ 8001a1e: ebb9 0005 subs.w r0, r9, r5
+ 8001a22: eb72 000a sbcs.w r0, r2, sl
+ 8001a26: 9211 str r2, [sp, #68] ; 0x44
+ 8001a28: bf38 it cc
+ 8001a2a: 2101 movcc r1, #1
+ return round_and_weed(&mut buf[..i], exp, plus1rem, delta1, plus1 - v.f, ten_kappa, 1);
+ 8001a2c: 980a ldr r0, [sp, #40] ; 0x28
+ 8001a2e: 9a06 ldr r2, [sp, #24]
+ 8001a30: 9b07 ldr r3, [sp, #28]
+ 8001a32: f8cd a054 str.w sl, [sp, #84] ; 0x54
+ 8001a36: 9519 str r5, [sp, #100] ; 0x64
+ 8001a38: 1a80 subs r0, r0, r2
+ 8001a3a: 9a0b ldr r2, [sp, #44] ; 0x2c
+ 8001a3c: 419a sbcs r2, r3
+ let plus1v_down = plus1v + ulp; // plus1 - (v - 1 ulp)
+ 8001a3e: 1c43 adds r3, r0, #1
+ 8001a40: 9314 str r3, [sp, #80] ; 0x50
+ 8001a42: f142 0300 adc.w r3, r2, #0
+ let plus1v_up = plus1v - ulp; // plus1 - (v + 1 ulp)
+ 8001a46: f1b0 0b01 subs.w fp, r0, #1
+ 8001a4a: f162 0200 sbc.w r2, r2, #0
+ while plus1w < plus1v_up &&
+ 8001a4e: ebb4 080b subs.w r8, r4, fp
+ let plus1v_up = plus1v - ulp; // plus1 - (v + 1 ulp)
+ 8001a52: 9312 str r3, [sp, #72] ; 0x48
+ while plus1w < plus1v_up &&
+ 8001a54: eb76 0302 sbcs.w r3, r6, r2
+ 8001a58: f080 810c bcs.w 8001c74 <core::fmt::float::float_to_decimal_common_shortest+0x892>
+ 8001a5c: 9811 ldr r0, [sp, #68] ; 0x44
+ 8001a5e: ebb9 0305 subs.w r3, r9, r5
+ 8001a62: eb70 030a sbcs.w r3, r0, sl
+ 8001a66: f0c0 8105 bcc.w 8001c74 <core::fmt::float::float_to_decimal_common_shortest+0x892>
+ 8001a6a: 9d0e ldr r5, [sp, #56] ; 0x38
+ 8001a6c: f8dd 9064 ldr.w r9, [sp, #100] ; 0x64
+ (plus1w + ten_kappa < plus1v_up ||
+ 8001a70: eb14 0809 adds.w r8, r4, r9
+ 8001a74: eb46 030a adc.w r3, r6, sl
+ 8001a78: ebb8 010b subs.w r1, r8, fp
+ 8001a7c: eb73 0102 sbcs.w r1, r3, r2
+ 8001a80: d310 bcc.n 8001aa4 <core::fmt::float::float_to_decimal_common_shortest+0x6c2>
+ plus1v_up - plus1w >= plus1w + ten_kappa - plus1v_up) {
+ 8001a82: ebb8 090b subs.w r9, r8, fp
+ 8001a86: 9d0e ldr r5, [sp, #56] ; 0x38
+ 8001a88: eb63 0002 sbc.w r0, r3, r2
+ 8001a8c: ebbb 0104 subs.w r1, fp, r4
+ 8001a90: eb62 0a06 sbc.w sl, r2, r6
+ (plus1w + ten_kappa < plus1v_up ||
+ 8001a94: ebb1 0109 subs.w r1, r1, r9
+ 8001a98: eb7a 0100 sbcs.w r1, sl, r0
+ 8001a9c: f8dd a054 ldr.w sl, [sp, #84] ; 0x54
+ 8001aa0: f0c0 810e bcc.w 8001cc0 <core::fmt::float::float_to_decimal_common_shortest+0x8de>
+ *last -= 1;
+ 8001aa4: f1ae 0e01 sub.w lr, lr, #1
+ 8001aa8: f10d 006b add.w r0, sp, #107 ; 0x6b
+ 8001aac: f8dd 9064 ldr.w r9, [sp, #100] ; 0x64
+ 8001ab0: f800 e00c strb.w lr, [r0, ip]
+ threshold - plus1w >= ten_kappa &&
+ 8001ab4: 9818 ldr r0, [sp, #96] ; 0x60
+ 8001ab6: ebb0 0408 subs.w r4, r0, r8
+ 8001aba: 9816 ldr r0, [sp, #88] ; 0x58
+ 8001abc: eb60 0603 sbc.w r6, r0, r3
+ 8001ac0: ebb4 0109 subs.w r1, r4, r9
+ 8001ac4: eb76 010a sbcs.w r1, r6, sl
+ 8001ac8: f04f 0100 mov.w r1, #0
+ 8001acc: bf38 it cc
+ 8001ace: 2101 movcc r1, #1
+ while plus1w < plus1v_up &&
+ 8001ad0: ebb8 000b subs.w r0, r8, fp
+ 8001ad4: eb73 0002 sbcs.w r0, r3, r2
+ 8001ad8: f080 80f5 bcs.w 8001cc6 <core::fmt::float::float_to_decimal_common_shortest+0x8e4>
+ 8001adc: ebb4 0009 subs.w r0, r4, r9
+ 8001ae0: 4644 mov r4, r8
+ 8001ae2: eb76 000a sbcs.w r0, r6, sl
+ 8001ae6: 461e mov r6, r3
+ 8001ae8: d2c2 bcs.n 8001a70 <core::fmt::float::float_to_decimal_common_shortest+0x68e>
+ 8001aea: e0ec b.n 8001cc6 <core::fmt::float::float_to_decimal_common_shortest+0x8e4>
+ 8001aec: 2100 movs r1, #0
+ 8001aee: f8dd 9004 ldr.w r9, [sp, #4]
+ 8001af2: 9c17 ldr r4, [sp, #92] ; 0x5c
+ 8001af4: 9b10 ldr r3, [sp, #64] ; 0x40
+ 8001af6: f06f 021f mvn.w r2, #31
+ 8001afa: 2501 movs r5, #1
+ 8001afc: 9116 str r1, [sp, #88] ; 0x58
+ 8001afe: 9915 ldr r1, [sp, #84] ; 0x54
+ 8001b00: fa12 f181 uxtah r1, r2, r1
+ 8001b04: 9111 str r1, [sp, #68] ; 0x44
+ 8001b06: 46ae mov lr, r5
+ buf[i] = b'0' + q as u8;
+ 8001b08: 2810 cmp r0, #16
+ 8001b0a: f200 8638 bhi.w 800277e <core::fmt::float::float_to_decimal_common_shortest+0x139c>
+ let r = remainder & ((1 << e) - 1);
+ 8001b0e: 9914 ldr r1, [sp, #80] ; 0x50
+ 8001b10: f04f 0c0a mov.w ip, #10
+ 8001b14: 46ca mov sl, r9
+ threshold *= 10;
+ 8001b16: eb03 0383 add.w r3, r3, r3, lsl #2
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8001b1a: fba4 250c umull r2, r5, r4, ip
+ let r = remainder & ((1 << e) - 1);
+ 8001b1e: ea02 0601 and.w r6, r2, r1
+ ulp *= 10;
+ 8001b22: fbae 140c umull r1, r4, lr, ip
+ let q = remainder >> e;
+ 8001b26: fa22 f20b lsr.w r2, r2, fp
+ ulp *= 10;
+ 8001b2a: 9115 str r1, [sp, #84] ; 0x54
+ 8001b2c: 9916 ldr r1, [sp, #88] ; 0x58
+ 8001b2e: eb01 0881 add.w r8, r1, r1, lsl #2
+ 8001b32: eb04 0148 add.w r1, r4, r8, lsl #1
+ threshold *= 10;
+ 8001b36: fbaa a40c umull sl, r4, sl, ip
+ 8001b3a: eb04 0c43 add.w ip, r4, r3, lsl #1
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8001b3e: 9b19 ldr r3, [sp, #100] ; 0x64
+ 8001b40: 9116 str r1, [sp, #88] ; 0x58
+ 8001b42: 9911 ldr r1, [sp, #68] ; 0x44
+ 8001b44: 4634 mov r4, r6
+ let r = remainder & ((1 << e) - 1);
+ 8001b46: 9e12 ldr r6, [sp, #72] ; 0x48
+ 8001b48: 46d1 mov r9, sl
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8001b4a: eb03 0383 add.w r3, r3, r3, lsl #2
+ let q = remainder >> e;
+ 8001b4e: 2900 cmp r1, #0
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8001b50: eb05 0343 add.w r3, r5, r3, lsl #1
+ let q = remainder >> e;
+ 8001b54: 9d18 ldr r5, [sp, #96] ; 0x60
+ let r = remainder & ((1 << e) - 1);
+ 8001b56: ea06 0603 and.w r6, r6, r3
+ let q = remainder >> e;
+ 8001b5a: fa03 f505 lsl.w r5, r3, r5
+ 8001b5e: ea42 0205 orr.w r2, r2, r5
+ 8001b62: 9d15 ldr r5, [sp, #84] ; 0x54
+ 8001b64: bfa8 it ge
+ 8001b66: fa23 f201 lsrge.w r2, r3, r1
+ 8001b6a: 4663 mov r3, ip
+ 8001b6c: 9619 str r6, [sp, #100] ; 0x64
+ buf[i] = b'0' + q as u8;
+ 8001b6e: f102 0c30 add.w ip, r2, #48 ; 0x30
+ 8001b72: f10d 026b add.w r2, sp, #107 ; 0x6b
+ 8001b76: f802 c000 strb.w ip, [r2, r0]
+ if r < threshold {
+ 8001b7a: ebb4 020a subs.w r2, r4, sl
+ i += 1;
+ 8001b7e: f100 0001 add.w r0, r0, #1
+ if r < threshold {
+ 8001b82: eb76 0203 sbcs.w r2, r6, r3
+ 8001b86: d2be bcs.n 8001b06 <core::fmt::float::float_to_decimal_common_shortest+0x724>
+ (plus1 - v.f) * ulp, ten_kappa, ulp);
+ 8001b88: 9017 str r0, [sp, #92] ; 0x5c
+ 8001b8a: 980a ldr r0, [sp, #40] ; 0x28
+ 8001b8c: 9906 ldr r1, [sp, #24]
+ 8001b8e: 4626 mov r6, r4
+ 8001b90: f8cd 8050 str.w r8, [sp, #80] ; 0x50
+ 8001b94: 46c8 mov r8, r9
+ 8001b96: f8cd e048 str.w lr, [sp, #72] ; 0x48
+ 8001b9a: 1a42 subs r2, r0, r1
+ 8001b9c: 4619 mov r1, r3
+ 8001b9e: 980b ldr r0, [sp, #44] ; 0x2c
+ 8001ba0: 9b07 ldr r3, [sp, #28]
+ 8001ba2: 9110 str r1, [sp, #64] ; 0x40
+ 8001ba4: eb60 0303 sbc.w r3, r0, r3
+ 8001ba8: fba5 0402 umull r0, r4, r5, r2
+ 8001bac: fb05 4303 mla r3, r5, r3, r4
+ 8001bb0: 4634 mov r4, r6
+ 8001bb2: 9e16 ldr r6, [sp, #88] ; 0x58
+ let plus1v_up = plus1v - ulp; // plus1 - (v + 1 ulp)
+ 8001bb4: ebb0 0a05 subs.w sl, r0, r5
+ (plus1 - v.f) * ulp, ten_kappa, ulp);
+ 8001bb8: fb06 3202 mla r2, r6, r2, r3
+ let plus1v_up = plus1v - ulp; // plus1 - (v + 1 ulp)
+ 8001bbc: eb62 0b06 sbc.w fp, r2, r6
+ let plus1v_down = plus1v + ulp; // plus1 - (v - 1 ulp)
+ 8001bc0: 1940 adds r0, r0, r5
+ 8001bc2: 9d0c ldr r5, [sp, #48] ; 0x30
+ 8001bc4: 9015 str r0, [sp, #84] ; 0x54
+ 8001bc6: eb42 0006 adc.w r0, r2, r6
+ 8001bca: 9e19 ldr r6, [sp, #100] ; 0x64
+ threshold - plus1w >= ten_kappa &&
+ 8001bcc: ebb8 0204 subs.w r2, r8, r4
+ 8001bd0: 9016 str r0, [sp, #88] ; 0x58
+ 8001bd2: 9800 ldr r0, [sp, #0]
+ 8001bd4: eb61 0306 sbc.w r3, r1, r6
+ 8001bd8: 1b52 subs r2, r2, r5
+ 8001bda: f04f 0100 mov.w r1, #0
+ 8001bde: eb73 0200 sbcs.w r2, r3, r0
+ 8001be2: 4681 mov r9, r0
+ 8001be4: bf38 it cc
+ 8001be6: 2101 movcc r1, #1
+ while plus1w < plus1v_up &&
+ 8001be8: 2900 cmp r1, #0
+ 8001bea: d15b bne.n 8001ca4 <core::fmt::float::float_to_decimal_common_shortest+0x8c2>
+ 8001bec: ebb4 020a subs.w r2, r4, sl
+ 8001bf0: eb76 020b sbcs.w r2, r6, fp
+ 8001bf4: d256 bcs.n 8001ca4 <core::fmt::float::float_to_decimal_common_shortest+0x8c2>
+ 8001bf6: 9a17 ldr r2, [sp, #92] ; 0x5c
+ 8001bf8: f10d 016b add.w r1, sp, #107 ; 0x6b
+ 8001bfc: 464b mov r3, r9
+ 8001bfe: 1888 adds r0, r1, r2
+ 8001c00: 9018 str r0, [sp, #96] ; 0x60
+ (plus1w + ten_kappa < plus1v_up ||
+ 8001c02: 1960 adds r0, r4, r5
+ 8001c04: eb46 0203 adc.w r2, r6, r3
+ 8001c08: ebb0 010a subs.w r1, r0, sl
+ 8001c0c: eb72 010b sbcs.w r1, r2, fp
+ 8001c10: d30d bcc.n 8001c2e <core::fmt::float::float_to_decimal_common_shortest+0x84c>
+ plus1v_up - plus1w >= plus1w + ten_kappa - plus1v_up) {
+ 8001c12: ebb0 010a subs.w r1, r0, sl
+ 8001c16: 4623 mov r3, r4
+ 8001c18: eb62 0e0b sbc.w lr, r2, fp
+ 8001c1c: ebba 0504 subs.w r5, sl, r4
+ 8001c20: eb6b 0406 sbc.w r4, fp, r6
+ (plus1w + ten_kappa < plus1v_up ||
+ 8001c24: 1a69 subs r1, r5, r1
+ 8001c26: 9d0c ldr r5, [sp, #48] ; 0x30
+ 8001c28: eb74 010e sbcs.w r1, r4, lr
+ 8001c2c: d37c bcc.n 8001d28 <core::fmt::float::float_to_decimal_common_shortest+0x946>
+ *last -= 1;
+ 8001c2e: 9918 ldr r1, [sp, #96] ; 0x60
+ 8001c30: f1ac 0c01 sub.w ip, ip, #1
+ threshold - plus1w >= ten_kappa &&
+ 8001c34: ebb8 0300 subs.w r3, r8, r0
+ 8001c38: 464e mov r6, r9
+ 8001c3a: 46ae mov lr, r5
+ *last -= 1;
+ 8001c3c: f801 cc01 strb.w ip, [r1, #-1]
+ threshold - plus1w >= ten_kappa &&
+ 8001c40: 9910 ldr r1, [sp, #64] ; 0x40
+ 8001c42: eb61 0402 sbc.w r4, r1, r2
+ 8001c46: 1b59 subs r1, r3, r5
+ 8001c48: eb74 0106 sbcs.w r1, r4, r6
+ 8001c4c: f04f 0100 mov.w r1, #0
+ 8001c50: bf38 it cc
+ 8001c52: 2101 movcc r1, #1
+ while plus1w < plus1v_up &&
+ 8001c54: ebb0 050a subs.w r5, r0, sl
+ 8001c58: eb72 050b sbcs.w r5, r2, fp
+ 8001c5c: f080 84de bcs.w 800261c <core::fmt::float::float_to_decimal_common_shortest+0x123a>
+ 8001c60: ebb3 030e subs.w r3, r3, lr
+ 8001c64: 4675 mov r5, lr
+ 8001c66: eb74 0306 sbcs.w r3, r4, r6
+ 8001c6a: 4604 mov r4, r0
+ 8001c6c: 4633 mov r3, r6
+ 8001c6e: 4616 mov r6, r2
+ 8001c70: d2c7 bcs.n 8001c02 <core::fmt::float::float_to_decimal_common_shortest+0x820>
+ 8001c72: e05c b.n 8001d2e <core::fmt::float::float_to_decimal_common_shortest+0x94c>
+ 8001c74: 9d0e ldr r5, [sp, #56] ; 0x38
+ 8001c76: e024 b.n 8001cc2 <core::fmt::float::float_to_decimal_common_shortest+0x8e0>
+ 8001c78: f8dd e04c ldr.w lr, [sp, #76] ; 0x4c
+ 8001c7c: 9b10 ldr r3, [sp, #64] ; 0x40
+ 8001c7e: 980d ldr r0, [sp, #52] ; 0x34
+ 8001c80: f24e 1200 movw r2, #57600 ; 0xe100
+ 8001c84: 2101 movs r1, #1
+ 8001c86: f2c0 52f5 movt r2, #1525 ; 0x5f5
+ else if x < X8 { if x < X7 {(6, X6)} else {(7, X7)} }
+ 8001c8a: 4592 cmp sl, r2
+ 8001c8c: d20c bcs.n 8001ca8 <core::fmt::float::float_to_decimal_common_shortest+0x8c6>
+ 8001c8e: f249 6280 movw r2, #38528 ; 0x9680
+ 8001c92: 2407 movs r4, #7
+ 8001c94: f2c0 0298 movt r2, #152 ; 0x98
+ 8001c98: 4592 cmp sl, r2
+ 8001c9a: bf28 it cs
+ 8001c9c: 4615 movcs r5, r2
+ 8001c9e: bf38 it cc
+ 8001ca0: 2406 movcc r4, #6
+ 8001ca2: e63e b.n 8001922 <core::fmt::float::float_to_decimal_common_shortest+0x540>
+ 8001ca4: 4620 mov r0, r4
+ 8001ca6: e041 b.n 8001d2c <core::fmt::float::float_to_decimal_common_shortest+0x94a>
+ else { if x < X9 {(8, X8)} else {(9, X9)} }
+ 8001ca8: f64c 2500 movw r5, #51712 ; 0xca00
+ 8001cac: 2409 movs r4, #9
+ 8001cae: f6c3 359a movt r5, #15258 ; 0x3b9a
+ 8001cb2: 45aa cmp sl, r5
+ 8001cb4: bf28 it cs
+ 8001cb6: 462a movcs r2, r5
+ 8001cb8: bf38 it cc
+ 8001cba: 2408 movcc r4, #8
+ 8001cbc: 4615 mov r5, r2
+ 8001cbe: e630 b.n 8001922 <core::fmt::float::float_to_decimal_common_shortest+0x540>
+ 8001cc0: 2100 movs r1, #0
+ 8001cc2: 46a0 mov r8, r4
+ 8001cc4: 4633 mov r3, r6
+ 8001cc6: 9e14 ldr r6, [sp, #80] ; 0x50
+ 8001cc8: f8dd c048 ldr.w ip, [sp, #72] ; 0x48
+ 8001ccc: f8dd a05c ldr.w sl, [sp, #92] ; 0x5c
+ 8001cd0: 9c08 ldr r4, [sp, #32]
+
+ // check if this representation is also the closest representation to `v - 1 ulp`.
+ //
+ // this is simply same to the terminating conditions for `v + 1 ulp`, with all `plus1v_up`
+ // replaced by `plus1v_down` instead. overflow analysis equally holds.
+ if plus1w < plus1v_down &&
+ 8001cd2: ebb8 0006 subs.w r0, r8, r6
+ 8001cd6: eb73 000c sbcs.w r0, r3, ip
+ 8001cda: d214 bcs.n 8001d06 <core::fmt::float::float_to_decimal_common_shortest+0x924>
+ 8001cdc: b999 cbnz r1, 8001d06 <core::fmt::float::float_to_decimal_common_shortest+0x924>
+ threshold - plus1w >= ten_kappa &&
+ (plus1w + ten_kappa < plus1v_down ||
+ 8001cde: 9819 ldr r0, [sp, #100] ; 0x64
+ 8001ce0: 9915 ldr r1, [sp, #84] ; 0x54
+ 8001ce2: eb10 0008 adds.w r0, r0, r8
+ 8001ce6: 4159 adcs r1, r3
+ 8001ce8: 1b82 subs r2, r0, r6
+ 8001cea: eb71 020c sbcs.w r2, r1, ip
+ 8001cee: d362 bcc.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+ plus1v_down - plus1w >= plus1w + ten_kappa - plus1v_down) {
+ 8001cf0: 1b80 subs r0, r0, r6
+ 8001cf2: eb61 010c sbc.w r1, r1, ip
+ 8001cf6: ebb6 0208 subs.w r2, r6, r8
+ 8001cfa: eb6c 0603 sbc.w r6, ip, r3
+ (plus1w + ten_kappa < plus1v_down ||
+ 8001cfe: 1a10 subs r0, r2, r0
+ 8001d00: eb76 0001 sbcs.w r0, r6, r1
+ 8001d04: d257 bcs.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+
+ // now we have the closest representation to `v` between `plus1` and `minus1`.
+ // this is too liberal, though, so we reject any `w(n)` not between `plus0` and `minus0`,
+ // i.e. `plus1 - plus1w(n) <= minus0` or `plus1 - plus1w(n) >= plus0`. we utilize the facts
+ // that `threshold = plus1 - minus1` and `plus1 - plus0 = minus0 - minus1 = 2 ulp`.
+ if 2 * ulp <= plus1w && plus1w <= threshold - 4 * ulp {
+ 8001d06: 9818 ldr r0, [sp, #96] ; 0x60
+ 8001d08: 9916 ldr r1, [sp, #88] ; 0x58
+ 8001d0a: 3804 subs r0, #4
+ 8001d0c: f161 0100 sbc.w r1, r1, #0
+ 8001d10: f1b8 0202 subs.w r2, r8, #2
+ 8001d14: f173 0200 sbcs.w r2, r3, #0
+ 8001d18: d34d bcc.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+ 8001d1a: ebb0 0008 subs.w r0, r0, r8
+ 8001d1e: eb71 0003 sbcs.w r0, r1, r3
+ 8001d22: f080 8495 bcs.w 8002650 <core::fmt::float::float_to_decimal_common_shortest+0x126e>
+ 8001d26: e046 b.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+ 8001d28: 2100 movs r1, #0
+ 8001d2a: 4618 mov r0, r3
+ 8001d2c: 4632 mov r2, r6
+ 8001d2e: 9e15 ldr r6, [sp, #84] ; 0x54
+ 8001d30: f8dd a058 ldr.w sl, [sp, #88] ; 0x58
+ if plus1w < plus1v_down &&
+ 8001d34: 1b83 subs r3, r0, r6
+ 8001d36: eb72 030a sbcs.w r3, r2, sl
+ 8001d3a: d21c bcs.n 8001d76 <core::fmt::float::float_to_decimal_common_shortest+0x994>
+ 8001d3c: b9d9 cbnz r1, 8001d76 <core::fmt::float::float_to_decimal_common_shortest+0x994>
+ (plus1w + ten_kappa < plus1v_down ||
+ 8001d3e: 1941 adds r1, r0, r5
+ 8001d40: 9c08 ldr r4, [sp, #32]
+ 8001d42: f8dd b050 ldr.w fp, [sp, #80] ; 0x50
+ 8001d46: eb42 0309 adc.w r3, r2, r9
+ 8001d4a: 1b8d subs r5, r1, r6
+ 8001d4c: eb73 050a sbcs.w r5, r3, sl
+ 8001d50: 9d0e ldr r5, [sp, #56] ; 0x38
+ 8001d52: d330 bcc.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+ plus1v_down - plus1w >= plus1w + ten_kappa - plus1v_down) {
+ 8001d54: ebb1 0c06 subs.w ip, r1, r6
+ 8001d58: eb63 0e0a sbc.w lr, r3, sl
+ 8001d5c: 1a31 subs r1, r6, r0
+ 8001d5e: 9e12 ldr r6, [sp, #72] ; 0x48
+ 8001d60: eb6a 0302 sbc.w r3, sl, r2
+ 8001d64: f8dd a05c ldr.w sl, [sp, #92] ; 0x5c
+ (plus1w + ten_kappa < plus1v_down ||
+ 8001d68: ebb1 010c subs.w r1, r1, ip
+ 8001d6c: eb73 010e sbcs.w r1, r3, lr
+ 8001d70: d221 bcs.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+ if 2 * ulp <= plus1w && plus1w <= threshold - 4 * ulp {
+ 8001d72: 2114 movs r1, #20
+ 8001d74: e007 b.n 8001d86 <core::fmt::float::float_to_decimal_common_shortest+0x9a4>
+ 8001d76: 9e12 ldr r6, [sp, #72] ; 0x48
+ 8001d78: f8dd b050 ldr.w fp, [sp, #80] ; 0x50
+ 8001d7c: 2114 movs r1, #20
+ 8001d7e: 9d0e ldr r5, [sp, #56] ; 0x38
+ 8001d80: f8dd a05c ldr.w sl, [sp, #92] ; 0x5c
+ 8001d84: 9c08 ldr r4, [sp, #32]
+ 8001d86: fba6 1301 umull r1, r3, r6, r1
+ 8001d8a: eb03 038b add.w r3, r3, fp, lsl #2
+ 8001d8e: 1a41 subs r1, r0, r1
+ 8001d90: eb72 0103 sbcs.w r1, r2, r3
+ 8001d94: d30f bcc.n 8001db6 <core::fmt::float::float_to_decimal_common_shortest+0x9d4>
+ 8001d96: f06f 0127 mvn.w r1, #39 ; 0x27
+ 8001d9a: fba6 1301 umull r1, r3, r6, r1
+ 8001d9e: 1b9b subs r3, r3, r6
+ 8001da0: eb11 0608 adds.w r6, r1, r8
+ 8001da4: 9910 ldr r1, [sp, #64] ; 0x40
+ 8001da6: eba3 03cb sub.w r3, r3, fp, lsl #3
+ 8001daa: 4159 adcs r1, r3
+///
+/// This should be used for most cases.
+pub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp*/ i16) {
+ use num::flt2dec::strategy::dragon::format_shortest as fallback;
+ match format_shortest_opt(d, buf) {
+ Some(ret) => ret,
+ 8001dac: 1a30 subs r0, r6, r0
+ 8001dae: eb71 0002 sbcs.w r0, r1, r2
+ 8001db2: f080 844d bcs.w 8002650 <core::fmt::float::float_to_decimal_common_shortest+0x126e>
+ 8001db6: f1a7 08c0 sub.w r8, r7, #192 ; 0xc0
+ let mut base = [0; $n];
+ 8001dba: 21a0 movs r1, #160 ; 0xa0
+ 8001dbc: 4640 mov r0, r8
+ 8001dbe: f001 fed9 bl 8003b74 <__aeabi_memclr4>
+ 8001dc2: 9e02 ldr r6, [sp, #8]
+ 8001dc4: 9a0f ldr r2, [sp, #60] ; 0x3c
+ // `a.cmp(&b) < rounding` is `if d.inclusive {a <= b} else {a < b}`
+ let rounding = if d.inclusive {Ordering::Greater} else {Ordering::Equal};
+
+ // estimate `k_0` from original inputs satisfying `10^(k_0-1) < high <= 10^(k_0+1)`.
+ // the tight bound `k` satisfying `10^(k-1) < high <= 10^k` is calculated later.
+ let mut k = estimate_scaling_factor(d.mant + d.plus, d.exp);
+ 8001dc6: 1990 adds r0, r2, r6
+ 8001dc8: eb44 0105 adc.w r1, r4, r5
+/// This is used to approximate `k = ceil(log_10 (mant * 2^exp))`;
+/// the true `k` is either `k_0` or `k_0+1`.
+#[doc(hidden)]
+pub fn estimate_scaling_factor(mant: u64, exp: i16) -> i16 {
+ // 2^(nbits-1) < mant <= 2^nbits if mant > 0
+ let nbits = 64 - (mant - 1).leading_zeros() as i64;
+ 8001dcc: 3801 subs r0, #1
+ unsafe { $ctlz(self as $ActualT) as u32 }
+ 8001dce: fab0 f080 clz r0, r0
+ 8001dd2: f171 0100 sbcs.w r1, r1, #0
+ 8001dd6: f100 0020 add.w r0, r0, #32
+ 8001dda: bf18 it ne
+ 8001ddc: fab1 f081 clzne r0, r1
+ // 1292913986 = floor(2^32 * log_10 2)
+ // therefore this always underestimates (or is exact), but not much.
+ (((nbits + exp as i64) * 1292913986) >> 32) as i16
+ 8001de0: 9909 ldr r1, [sp, #36] ; 0x24
+ 8001de2: fa0f fa81 sxth.w sl, r1
+ let nbits = 64 - (mant - 1).leading_zeros() as i64;
+ 8001de6: f10a 0140 add.w r1, sl, #64 ; 0x40
+ (((nbits + exp as i64) * 1292913986) >> 32) as i16
+ 8001dea: 1a08 subs r0, r1, r0
+ 8001dec: f644 5142 movw r1, #19778 ; 0x4d42
+ 8001df0: f6c4 5110 movt r1, #19728 ; 0x4d10
+ 8001df4: fb50 f001 smmul r0, r0, r1
+ 8001df8: b200 sxth r0, r0
+ 8001dfa: 900d str r0, [sp, #52] ; 0x34
+ 8001dfc: 2000 movs r0, #0
+ base[sz] = v as $ty;
+ 8001dfe: 2827 cmp r0, #39 ; 0x27
+ 8001e00: f200 8496 bhi.w 8002730 <core::fmt::float::float_to_decimal_common_shortest+0x134e>
+ 8001e04: f848 2020 str.w r2, [r8, r0, lsl #2]
+ sz += 1;
+ 8001e08: 3001 adds r0, #1
+ while v > 0 {
+ 8001e0a: 2c00 cmp r4, #0
+ 8001e0c: 4622 mov r2, r4
+ 8001e0e: f04f 0400 mov.w r4, #0
+ 8001e12: d1f4 bne.n 8001dfe <core::fmt::float::float_to_decimal_common_shortest+0xa1c>
+ $name { size: sz, base: base }
+ 8001e14: 901f str r0, [sp, #124] ; 0x7c
+ 8001e16: a81f add r0, sp, #124 ; 0x7c
+ 8001e18: 4641 mov r1, r8
+ 8001e1a: 22a0 movs r2, #160 ; 0xa0
+ 8001e1c: f100 0b04 add.w fp, r0, #4
+ 8001e20: 4658 mov r0, fp
+ 8001e22: f001 fe5f bl 8003ae4 <__aeabi_memcpy4>
+ let mut base = [0; $n];
+ 8001e26: 4640 mov r0, r8
+ 8001e28: 21a0 movs r1, #160 ; 0xa0
+ 8001e2a: f001 fea3 bl 8003b74 <__aeabi_memclr4>
+ base[sz] = v as $ty;
+ 8001e2e: 2001 movs r0, #1
+ $name { size: sz, base: base }
+ 8001e30: 4641 mov r1, r8
+ 8001e32: 22a0 movs r2, #160 ; 0xa0
+ base[sz] = v as $ty;
+ 8001e34: f847 0cc0 str.w r0, [r7, #-192]
+ $name { size: sz, base: base }
+ 8001e38: 9048 str r0, [sp, #288] ; 0x120
+ 8001e3a: a848 add r0, sp, #288 ; 0x120
+ 8001e3c: 3004 adds r0, #4
+ 8001e3e: 900e str r0, [sp, #56] ; 0x38
+ 8001e40: f001 fe50 bl 8003ae4 <__aeabi_memcpy4>
+ let mut base = [0; $n];
+ 8001e44: 4640 mov r0, r8
+ 8001e46: 21a0 movs r1, #160 ; 0xa0
+ 8001e48: f001 fe94 bl 8003b74 <__aeabi_memclr4>
+ 8001e4c: 2000 movs r0, #0
+ base[sz] = v as $ty;
+ 8001e4e: 2827 cmp r0, #39 ; 0x27
+ 8001e50: f200 846e bhi.w 8002730 <core::fmt::float::float_to_decimal_common_shortest+0x134e>
+ 8001e54: f848 6020 str.w r6, [r8, r0, lsl #2]
+ sz += 1;
+ 8001e58: 3001 adds r0, #1
+ while v > 0 {
+ 8001e5a: 2d00 cmp r5, #0
+ 8001e5c: 462e mov r6, r5
+ 8001e5e: f04f 0500 mov.w r5, #0
+ 8001e62: d1f4 bne.n 8001e4e <core::fmt::float::float_to_decimal_common_shortest+0xa6c>
+ $name { size: sz, base: base }
+ 8001e64: 9071 str r0, [sp, #452] ; 0x1c4
+ 8001e66: a871 add r0, sp, #452 ; 0x1c4
+ 8001e68: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 8001e6c: 22a0 movs r2, #160 ; 0xa0
+ 8001e6e: 3004 adds r0, #4
+ 8001e70: 9014 str r0, [sp, #80] ; 0x50
+ 8001e72: f001 fe37 bl 8003ae4 <__aeabi_memcpy4>
+ $name { size: 1, base: base }
+ 8001e76: 2001 movs r0, #1
+ 8001e78: ad9a add r5, sp, #616 ; 0x268
+ 8001e7a: 219c movs r1, #156 ; 0x9c
+ 8001e7c: e9cd 009a strd r0, r0, [sp, #616] ; 0x268
+ 8001e80: f105 0008 add.w r0, r5, #8
+ 8001e84: f001 fe76 bl 8003b74 <__aeabi_memclr4>
+ // - `high = (mant + plus) / scale`
+ let mut mant = Big::from_u64(d.mant);
+ let mut minus = Big::from_u64(d.minus);
+ let mut plus = Big::from_u64(d.plus);
+ let mut scale = Big::from_small(1);
+ if d.exp < 0 {
+ 8001e88: f1ba 3fff cmp.w sl, #4294967295 ; 0xffffffff
+ 8001e8c: dd0a ble.n 8001ea4 <core::fmt::float::float_to_decimal_common_shortest+0xac2>
+ 8001e8e: a81f add r0, sp, #124 ; 0x7c
+ scale.mul_pow2(-d.exp as usize);
+ } else {
+ mant.mul_pow2(d.exp as usize);
+ 8001e90: 4651 mov r1, sl
+ 8001e92: f7fe fe32 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 8001e96: a848 add r0, sp, #288 ; 0x120
+ minus.mul_pow2(d.exp as usize);
+ 8001e98: 4651 mov r1, sl
+ 8001e9a: f7fe fe2e bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 8001e9e: a871 add r0, sp, #452 ; 0x1c4
+ plus.mul_pow2(d.exp as usize);
+ 8001ea0: 4651 mov r1, sl
+ 8001ea2: e003 b.n 8001eac <core::fmt::float::float_to_decimal_common_shortest+0xaca>
+ scale.mul_pow2(-d.exp as usize);
+ 8001ea4: 9809 ldr r0, [sp, #36] ; 0x24
+ 8001ea6: 4240 negs r0, r0
+ 8001ea8: b201 sxth r1, r0
+ 8001eaa: a89a add r0, sp, #616 ; 0x268
+ 8001eac: f7fe fe25 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 8001eb0: f8dd 8034 ldr.w r8, [sp, #52] ; 0x34
+ }
+
+ // divide `mant` by `10^k`. now `scale / 10 < mant + plus <= scale * 10`.
+ if k >= 0 {
+ 8001eb4: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
+ 8001eb8: 4580 cmp r8, r0
+ 8001eba: dd02 ble.n 8001ec2 <core::fmt::float::float_to_decimal_common_shortest+0xae0>
+ 8001ebc: a89a add r0, sp, #616 ; 0x268
+ mul_pow10(&mut scale, k as usize);
+ 8001ebe: 4641 mov r1, r8
+ 8001ec0: e00c b.n 8001edc <core::fmt::float::float_to_decimal_common_shortest+0xafa>
+ } else {
+ mul_pow10(&mut mant, -k as usize);
+ 8001ec2: f1c8 0000 rsb r0, r8, #0
+ 8001ec6: b204 sxth r4, r0
+ 8001ec8: a81f add r0, sp, #124 ; 0x7c
+ 8001eca: 4621 mov r1, r4
+ 8001ecc: f7fe fa9c bl 8000408 <core::num::flt2dec::strategy::dragon::mul_pow10>
+ 8001ed0: a848 add r0, sp, #288 ; 0x120
+ mul_pow10(&mut minus, -k as usize);
+ 8001ed2: 4621 mov r1, r4
+ 8001ed4: f7fe fa98 bl 8000408 <core::num::flt2dec::strategy::dragon::mul_pow10>
+ 8001ed8: a871 add r0, sp, #452 ; 0x1c4
+ mul_pow10(&mut plus, -k as usize);
+ 8001eda: 4621 mov r1, r4
+ 8001edc: f7fe fa94 bl 8000408 <core::num::flt2dec::strategy::dragon::mul_pow10>
+ }
+ }
+
+ impl ::clone::Clone for $name {
+ fn clone(&self) -> $name {
+ $name { size: self.size, base: self.base }
+ 8001ee0: f8dd 907c ldr.w r9, [sp, #124] ; 0x7c
+ 8001ee4: f1a7 00c0 sub.w r0, r7, #192 ; 0xc0
+ 8001ee8: 4659 mov r1, fp
+ 8001eea: 22a0 movs r2, #160 ; 0xa0
+ 8001eec: 3004 adds r0, #4
+ 8001eee: 9015 str r0, [sp, #84] ; 0x54
+ 8001ef0: f847 9cc0 str.w r9, [r7, #-192]
+ 8001ef4: f001 fdf6 bl 8003ae4 <__aeabi_memcpy4>
+ let mut sz = cmp::max(self.size, other.size);
+ 8001ef8: 9871 ldr r0, [sp, #452] ; 0x1c4
+ if other >= self { other } else { self }
+ 8001efa: 46cc mov ip, r9
+ 8001efc: 4548 cmp r0, r9
+ 8001efe: bf28 it cs
+ 8001f00: 4684 movcs ip, r0
+ } else if self.end > slice.len() {
+ 8001f02: f1bc 0f29 cmp.w ip, #41 ; 0x29
+ 8001f06: f080 8420 bcs.w 800274a <core::fmt::float::float_to_decimal_common_shortest+0x1368>
+ Some(diff / size as isize)
+ 8001f0a: f34c 0e1d sbfx lr, ip, #0, #30
+ 8001f0e: 9914 ldr r1, [sp, #80] ; 0x50
+ if self.index < self.len {
+ 8001f10: 2203 movs r2, #3
+ 8001f12: ea42 038c orr.w r3, r2, ip, lsl #2
+ 8001f16: 2b07 cmp r3, #7
+ 8001f18: d32d bcc.n 8001f76 <core::fmt::float::float_to_decimal_common_shortest+0xb94>
+ 8001f1a: 9a15 ldr r2, [sp, #84] ; 0x54
+ 8001f1c: 2400 movs r4, #0
+ 8001f1e: 2300 movs r3, #0
+ let (c, v) = (*a).full_add(*b, carry);
+ 8001f20: f851 6023 ldr.w r6, [r1, r3, lsl #2]
+ 8001f24: f852 5023 ldr.w r5, [r2, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8001f28: f004 0401 and.w r4, r4, #1
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8001f2c: 442e add r6, r5
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8001f2e: 4434 add r4, r6
+ *a = v;
+ 8001f30: f842 4023 str.w r4, [r2, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8001f34: 42b4 cmp r4, r6
+ 8001f36: f04f 0401 mov.w r4, #1
+ self.index += 1;
+ 8001f3a: f103 0301 add.w r3, r3, #1
+ 8001f3e: bf28 it cs
+ 8001f40: 2400 movcs r4, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8001f42: 42ae cmp r6, r5
+ 8001f44: f04f 0601 mov.w r6, #1
+ 8001f48: bf28 it cs
+ 8001f4a: 2600 movcs r6, #0
+ if self.index < self.len {
+ 8001f4c: 4573 cmp r3, lr
+ (carry1 || carry2, v)
+ 8001f4e: ea44 0406 orr.w r4, r4, r6
+ 8001f52: d3e5 bcc.n 8001f20 <core::fmt::float::float_to_decimal_common_shortest+0xb3e>
+ if carry {
+ 8001f54: 2c01 cmp r4, #1
+ 8001f56: d10d bne.n 8001f74 <core::fmt::float::float_to_decimal_common_shortest+0xb92>
+ self.base[sz] = 1;
+ 8001f58: f1bc 0f27 cmp.w ip, #39 ; 0x27
+ 8001f5c: ad9a add r5, sp, #616 ; 0x268
+ 8001f5e: f200 841c bhi.w 800279a <core::fmt::float::float_to_decimal_common_shortest+0x13b8>
+ 8001f62: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 8001f66: 2301 movs r3, #1
+ 8001f68: eb01 028c add.w r2, r1, ip, lsl #2
+ sz += 1;
+ 8001f6c: f10c 0c01 add.w ip, ip, #1
+ self.base[sz] = 1;
+ 8001f70: 6053 str r3, [r2, #4]
+ 8001f72: e000 b.n 8001f76 <core::fmt::float::float_to_decimal_common_shortest+0xb94>
+ 8001f74: ad9a add r5, sp, #616 ; 0x268
+ let sz = max(self.size, other.size);
+ 8001f76: f8dd e268 ldr.w lr, [sp, #616] ; 0x268
+ self.size = sz;
+ 8001f7a: f847 ccc0 str.w ip, [r7, #-192]
+ 8001f7e: 45f4 cmp ip, lr
+ 8001f80: bf38 it cc
+ 8001f82: 46f4 movcc ip, lr
+ } else if self.end > slice.len() {
+ 8001f84: f1bc 0f29 cmp.w ip, #41 ; 0x29
+ 8001f88: f080 83df bcs.w 800274a <core::fmt::float::float_to_decimal_common_shortest+0x1368>
+ Self::Item: Ord,
+ Self: Sized,
+ {
+ let mut other = other.into_iter();
+
+ loop {
+ 8001f8c: ea4f 018c mov.w r1, ip, lsl #2
+ 8001f90: ae48 add r6, sp, #288 ; 0x120
+ if self.end == self.ptr {
+ 8001f92: 2900 cmp r1, #0
+ 8001f94: d00d beq.n 8001fb2 <core::fmt::float::float_to_decimal_common_shortest+0xbd0>
+ 8001f96: d018 beq.n 8001fca <core::fmt::float::float_to_decimal_common_shortest+0xbe8>
+ 8001f98: f1a7 03c0 sub.w r3, r7, #192 ; 0xc0
+ 8001f9c: 586a ldr r2, [r5, r1]
+ 8001f9e: 585b ldr r3, [r3, r1]
+ None => return Ordering::Greater,
+ Some(val) => val,
+ };
+
+ match x.cmp(&y) {
+ Ordering::Equal => (),
+ 8001fa0: 3904 subs r1, #4
+ 8001fa2: 429a cmp r2, r3
+ 8001fa4: d0f5 beq.n 8001f92 <core::fmt::float::float_to_decimal_common_shortest+0xbb0>
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Ord for $t {
+ #[inline]
+ fn cmp(&self, other: &$t) -> Ordering {
+ if *self == *other { Equal }
+ else if *self < *other { Less }
+ 8001fa6: f04f 0101 mov.w r1, #1
+ 8001faa: bf38 it cc
+ 8001fac: f04f 31ff movcc.w r1, #4294967295 ; 0xffffffff
+ 8001fb0: e002 b.n 8001fb8 <core::fmt::float::float_to_decimal_common_shortest+0xbd6>
+ return Ordering::Equal
+ 8001fb2: bf18 it ne
+ 8001fb4: f04f 31ff movne.w r1, #4294967295 ; 0xffffffff
+ // we are not actually modifying `scale`, since we can skip the initial multiplication instead.
+ // now `scale < mant + plus <= scale * 10` and we are ready to generate digits.
+ //
+ // note that `d[0]` *can* be zero, when `scale - plus < mant < scale`.
+ // in this case rounding-up condition (`up` below) will be triggered immediately.
+ if scale.cmp(mant.clone().add(&plus)) < rounding {
+ 8001fb8: 9a13 ldr r2, [sp, #76] ; 0x4c
+ 8001fba: b249 sxtb r1, r1
+ 8001fbc: 4291 cmp r1, r2
+ 8001fbe: da04 bge.n 8001fca <core::fmt::float::float_to_decimal_common_shortest+0xbe8>
+ // equivalent to scaling `scale` by 10
+ k += 1;
+ 8001fc0: f108 0801 add.w r8, r8, #1
+ 8001fc4: f8cd 8034 str.w r8, [sp, #52] ; 0x34
+ 8001fc8: e075 b.n 80020b6 <core::fmt::float::float_to_decimal_common_shortest+0xcd4>
+ } else if self.end > slice.len() {
+ 8001fca: f1b9 0f29 cmp.w r9, #41 ; 0x29
+ 8001fce: f080 83c0 bcs.w 8002752 <core::fmt::float::float_to_decimal_common_shortest+0x1370>
+ 8001fd2: 2100 movs r1, #0
+ if self.ptr == self.end {
+ 8001fd4: f1b9 0f00 cmp.w r9, #0
+ 8001fd8: d020 beq.n 800201c <core::fmt::float::float_to_decimal_common_shortest+0xc3a>
+ intrinsics::offset(self, count) as *mut T
+ 8001fda: aa1f add r2, sp, #124 ; 0x7c
+ 8001fdc: ea4f 0489 mov.w r4, r9, lsl #2
+ 8001fe0: 230a movs r3, #10
+ 8001fe2: 465e mov r6, fp
+ 8001fe4: eb02 0289 add.w r2, r2, r9, lsl #2
+ 8001fe8: f102 0c04 add.w ip, r2, #4
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8001fec: 6835 ldr r5, [r6, #0]
+ 8001fee: 2200 movs r2, #0
+ 8001ff0: 3c04 subs r4, #4
+ 8001ff2: fbe5 1203 umlal r1, r2, r5, r3
+ *a = v;
+ 8001ff6: f846 1b04 str.w r1, [r6], #4
+ 8001ffa: 4611 mov r1, r2
+ 8001ffc: d1f6 bne.n 8001fec <core::fmt::float::float_to_decimal_common_shortest+0xc0a>
+ if carry > 0 {
+ 8001ffe: 2a00 cmp r2, #0
+ 8002000: ac48 add r4, sp, #288 ; 0x120
+ 8002002: d008 beq.n 8002016 <core::fmt::float::float_to_decimal_common_shortest+0xc34>
+ self.base[sz] = carry;
+ 8002004: f1b9 0f27 cmp.w r9, #39 ; 0x27
+ 8002008: f200 8405 bhi.w 8002816 <core::fmt::float::float_to_decimal_common_shortest+0x1434>
+ 800200c: f8cc 2000 str.w r2, [ip]
+ sz += 1;
+ 8002010: f109 0101 add.w r1, r9, #1
+ 8002014: e000 b.n 8002018 <core::fmt::float::float_to_decimal_common_shortest+0xc36>
+ 8002016: 4649 mov r1, r9
+ 8002018: ad9a add r5, sp, #616 ; 0x268
+ 800201a: 4626 mov r6, r4
+ let mut sz = self.size;
+ 800201c: f8dd 8120 ldr.w r8, [sp, #288] ; 0x120
+ self.size = sz;
+ 8002020: 911f str r1, [sp, #124] ; 0x7c
+ } else if self.end > slice.len() {
+ 8002022: f1b8 0f29 cmp.w r8, #41 ; 0x29
+ 8002026: f080 83ef bcs.w 8002808 <core::fmt::float::float_to_decimal_common_shortest+0x1426>
+ 800202a: 2100 movs r1, #0
+ if self.ptr == self.end {
+ 800202c: f1b8 0f00 cmp.w r8, #0
+ 8002030: d01d beq.n 800206e <core::fmt::float::float_to_decimal_common_shortest+0xc8c>
+ 8002032: eb06 0288 add.w r2, r6, r8, lsl #2
+ 8002036: 9e0e ldr r6, [sp, #56] ; 0x38
+ 8002038: ea4f 0488 mov.w r4, r8, lsl #2
+ 800203c: f102 0c04 add.w ip, r2, #4
+ 8002040: 220a movs r2, #10
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8002042: 6835 ldr r5, [r6, #0]
+ 8002044: 2300 movs r3, #0
+ 8002046: 3c04 subs r4, #4
+ 8002048: fbe5 1302 umlal r1, r3, r5, r2
+ *a = v;
+ 800204c: f846 1b04 str.w r1, [r6], #4
+ 8002050: 4619 mov r1, r3
+ 8002052: d1f6 bne.n 8002042 <core::fmt::float::float_to_decimal_common_shortest+0xc60>
+ 8002054: b14b cbz r3, 800206a <core::fmt::float::float_to_decimal_common_shortest+0xc88>
+ self.base[sz] = carry;
+ 8002056: f1b8 0f27 cmp.w r8, #39 ; 0x27
+ 800205a: ad9a add r5, sp, #616 ; 0x268
+ 800205c: f200 83df bhi.w 800281e <core::fmt::float::float_to_decimal_common_shortest+0x143c>
+ sz += 1;
+ 8002060: f108 0101 add.w r1, r8, #1
+ self.base[sz] = carry;
+ 8002064: f8cc 3000 str.w r3, [ip]
+ 8002068: e001 b.n 800206e <core::fmt::float::float_to_decimal_common_shortest+0xc8c>
+ 800206a: 4641 mov r1, r8
+ 800206c: ad9a add r5, sp, #616 ; 0x268
+ } else if self.end > slice.len() {
+ 800206e: 2829 cmp r0, #41 ; 0x29
+ self.size = sz;
+ 8002070: 9148 str r1, [sp, #288] ; 0x120
+ 8002072: f080 83cd bcs.w 8002810 <core::fmt::float::float_to_decimal_common_shortest+0x142e>
+ 8002076: 2300 movs r3, #0
+ if self.ptr == self.end {
+ 8002078: 2800 cmp r0, #0
+ 800207a: d01b beq.n 80020b4 <core::fmt::float::float_to_decimal_common_shortest+0xcd2>
+ 800207c: 9e14 ldr r6, [sp, #80] ; 0x50
+ 800207e: a971 add r1, sp, #452 ; 0x1c4
+ 8002080: 0084 lsls r4, r0, #2
+ 8002082: 220a movs r2, #10
+ 8002084: eb01 0180 add.w r1, r1, r0, lsl #2
+ 8002088: f101 0c04 add.w ip, r1, #4
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 800208c: 6835 ldr r5, [r6, #0]
+ 800208e: 2100 movs r1, #0
+ 8002090: 3c04 subs r4, #4
+ 8002092: fbe5 3102 umlal r3, r1, r5, r2
+ *a = v;
+ 8002096: f846 3b04 str.w r3, [r6], #4
+ 800209a: 460b mov r3, r1
+ 800209c: d1f6 bne.n 800208c <core::fmt::float::float_to_decimal_common_shortest+0xcaa>
+ 800209e: b139 cbz r1, 80020b0 <core::fmt::float::float_to_decimal_common_shortest+0xcce>
+ self.base[sz] = carry;
+ 80020a0: 2827 cmp r0, #39 ; 0x27
+ 80020a2: ad9a add r5, sp, #616 ; 0x268
+ 80020a4: f200 83bf bhi.w 8002826 <core::fmt::float::float_to_decimal_common_shortest+0x1444>
+ sz += 1;
+ 80020a8: 1c43 adds r3, r0, #1
+ self.base[sz] = carry;
+ 80020aa: f8cc 1000 str.w r1, [ip]
+ 80020ae: e001 b.n 80020b4 <core::fmt::float::float_to_decimal_common_shortest+0xcd2>
+ 80020b0: 4603 mov r3, r0
+ 80020b2: ad9a add r5, sp, #616 ; 0x268
+ self.size = sz;
+ 80020b4: 9371 str r3, [sp, #452] ; 0x1c4
+ 80020b6: f50d 7843 add.w r8, sp, #780 ; 0x30c
+ $name { size: self.size, base: self.base }
+ 80020ba: 1d2e adds r6, r5, #4
+ 80020bc: 22a0 movs r2, #160 ; 0xa0
+ 80020be: f8cd e30c str.w lr, [sp, #780] ; 0x30c
+ 80020c2: f108 0904 add.w r9, r8, #4
+ 80020c6: 4631 mov r1, r6
+ 80020c8: 4648 mov r0, r9
+ 80020ca: f001 fd0b bl 8003ae4 <__aeabi_memcpy4>
+ minus.mul_small(10);
+ plus.mul_small(10);
+ }
+
+ // cache `(2, 4, 8) * scale` for digit generation.
+ let mut scale2 = scale.clone(); scale2.mul_pow2(1);
+ 80020ce: 4640 mov r0, r8
+ 80020d0: 2101 movs r1, #1
+ 80020d2: f7fe fd12 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 80020d6: 989a ldr r0, [sp, #616] ; 0x268
+ 80020d8: f50d 7a6c add.w sl, sp, #944 ; 0x3b0
+ 80020dc: 4631 mov r1, r6
+ 80020de: 22a0 movs r2, #160 ; 0xa0
+ 80020e0: 90ec str r0, [sp, #944] ; 0x3b0
+ 80020e2: f10a 0004 add.w r0, sl, #4
+ 80020e6: 9012 str r0, [sp, #72] ; 0x48
+ 80020e8: f001 fcfc bl 8003ae4 <__aeabi_memcpy4>
+ let mut scale4 = scale.clone(); scale4.mul_pow2(2);
+ 80020ec: 4650 mov r0, sl
+ 80020ee: 2102 movs r1, #2
+ 80020f0: f7fe fd03 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 80020f4: 989a ldr r0, [sp, #616] ; 0x268
+ 80020f6: f20d 4454 addw r4, sp, #1108 ; 0x454
+ 80020fa: 4631 mov r1, r6
+ 80020fc: 22a0 movs r2, #160 ; 0xa0
+ 80020fe: 9611 str r6, [sp, #68] ; 0x44
+ 8002100: f8cd 0454 str.w r0, [sp, #1108] ; 0x454
+ 8002104: 1d20 adds r0, r4, #4
+ 8002106: 9018 str r0, [sp, #96] ; 0x60
+ 8002108: f001 fcec bl 8003ae4 <__aeabi_memcpy4>
+ let mut scale8 = scale.clone(); scale8.mul_pow2(3);
+ 800210c: 4620 mov r0, r4
+ 800210e: 2103 movs r1, #3
+ 8002110: f7fe fcf3 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ let sz = max(self.size, other.size);
+ 8002114: f8dd 1454 ldr.w r1, [sp, #1108] ; 0x454
+ 8002118: f8dd a07c ldr.w sl, [sp, #124] ; 0x7c
+ if other >= self { other } else { self }
+ 800211c: 4551 cmp r1, sl
+ 800211e: 4650 mov r0, sl
+ 8002120: 910f str r1, [sp, #60] ; 0x3c
+ 8002122: bf28 it cs
+ 8002124: 4608 movcs r0, r1
+ } else if self.end > slice.len() {
+ 8002126: 2828 cmp r0, #40 ; 0x28
+ 8002128: f200 824f bhi.w 80025ca <core::fmt::float::float_to_decimal_common_shortest+0x11e8>
+ 800212c: f8dd c060 ldr.w ip, [sp, #96] ; 0x60
+ 8002130: 2100 movs r1, #0
+ 8002132: f10d 0e7c add.w lr, sp, #124 ; 0x7c
+ 8002136: f8cd 9040 str.w r9, [sp, #64] ; 0x40
+ 800213a: 9117 str r1, [sp, #92] ; 0x5c
+ 800213c: 9917 ldr r1, [sp, #92] ; 0x5c
+ loop {
+ 800213e: 9116 str r1, [sp, #88] ; 0x58
+ 8002140: 0081 lsls r1, r0, #2
+ if self.end == self.ptr {
+ 8002142: 2900 cmp r1, #0
+ 8002144: d008 beq.n 8002158 <core::fmt::float::float_to_decimal_common_shortest+0xd76>
+ 8002146: d00f beq.n 8002168 <core::fmt::float::float_to_decimal_common_shortest+0xd86>
+ 8002148: f85e 2001 ldr.w r2, [lr, r1]
+ 800214c: 5863 ldr r3, [r4, r1]
+ Ordering::Equal => (),
+ 800214e: 3904 subs r1, #4
+ 8002150: 429a cmp r2, r3
+ 8002152: d0f6 beq.n 8002142 <core::fmt::float::float_to_decimal_common_shortest+0xd60>
+ 8002154: d301 bcc.n 800215a <core::fmt::float::float_to_decimal_common_shortest+0xd78>
+ 8002156: e007 b.n 8002168 <core::fmt::float::float_to_decimal_common_shortest+0xd86>
+ 8002158: d006 beq.n 8002168 <core::fmt::float::float_to_decimal_common_shortest+0xd86>
+ 800215a: 4650 mov r0, sl
+ 800215c: f8dd a048 ldr.w sl, [sp, #72] ; 0x48
+ 8002160: f04f 0c00 mov.w ip, #0
+ 8002164: acec add r4, sp, #944 ; 0x3b0
+ 8002166: e02d b.n 80021c4 <core::fmt::float::float_to_decimal_common_shortest+0xde2>
+ 8002168: 2103 movs r1, #3
+ 800216a: acec add r4, sp, #944 ; 0x3b0
+ 800216c: ea41 0280 orr.w r2, r1, r0, lsl #2
+ Some(diff / size as isize)
+ 8002170: f340 011d sbfx r1, r0, #0, #30
+ 8002174: f8dd a048 ldr.w sl, [sp, #72] ; 0x48
+ 8002178: 2a07 cmp r2, #7
+ 800217a: d320 bcc.n 80021be <core::fmt::float::float_to_decimal_common_shortest+0xddc>
+ 800217c: 2200 movs r2, #0
+ 800217e: 2301 movs r3, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 8002180: f85c 5022 ldr.w r5, [ip, r2, lsl #2]
+ 8002184: f85b 6022 ldr.w r6, [fp, r2, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002188: f003 0301 and.w r3, r3, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 800218c: 43ed mvns r5, r5
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 800218e: 4435 add r5, r6
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002190: 442b add r3, r5
+ *a = v;
+ 8002192: f84b 3022 str.w r3, [fp, r2, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002196: 42ab cmp r3, r5
+ 8002198: f04f 0301 mov.w r3, #1
+ self.index += 1;
+ 800219c: f102 0201 add.w r2, r2, #1
+ 80021a0: bf28 it cs
+ 80021a2: 2300 movcs r3, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80021a4: 42b5 cmp r5, r6
+ 80021a6: f04f 0601 mov.w r6, #1
+ 80021aa: bf28 it cs
+ 80021ac: 2600 movcs r6, #0
+ if self.index < self.len {
+ 80021ae: 428a cmp r2, r1
+ (carry1 || carry2, v)
+ 80021b0: ea43 0306 orr.w r3, r3, r6
+ 80021b4: d3e4 bcc.n 8002180 <core::fmt::float::float_to_decimal_common_shortest+0xd9e>
+ assert!(noborrow);
+ 80021b6: 2b00 cmp r3, #0
+ 80021b8: ad9a add r5, sp, #616 ; 0x268
+ 80021ba: f000 82c0 beq.w 800273e <core::fmt::float::float_to_decimal_common_shortest+0x135c>
+ 80021be: f04f 0c08 mov.w ip, #8
+ self.size = sz;
+ 80021c2: 901f str r0, [sp, #124] ; 0x7c
+ let sz = max(self.size, other.size);
+ 80021c4: 99ec ldr r1, [sp, #944] ; 0x3b0
+ 80021c6: 4281 cmp r1, r0
+ 80021c8: bf38 it cc
+ 80021ca: 4601 movcc r1, r0
+ } else if self.end > slice.len() {
+ 80021cc: 2929 cmp r1, #41 ; 0x29
+ 80021ce: f080 82c4 bcs.w 800275a <core::fmt::float::float_to_decimal_common_shortest+0x1378>
+ loop {
+ 80021d2: 008a lsls r2, r1, #2
+ if self.end == self.ptr {
+ 80021d4: 2a00 cmp r2, #0
+ 80021d6: d009 beq.n 80021ec <core::fmt::float::float_to_decimal_common_shortest+0xe0a>
+ 80021d8: d00b beq.n 80021f2 <core::fmt::float::float_to_decimal_common_shortest+0xe10>
+ 80021da: f85e 3002 ldr.w r3, [lr, r2]
+ 80021de: 58a6 ldr r6, [r4, r2]
+ Ordering::Equal => (),
+ 80021e0: 3a04 subs r2, #4
+ 80021e2: 42b3 cmp r3, r6
+ 80021e4: d0f6 beq.n 80021d4 <core::fmt::float::float_to_decimal_common_shortest+0xdf2>
+ 80021e6: d204 bcs.n 80021f2 <core::fmt::float::float_to_decimal_common_shortest+0xe10>
+ let sz = cmp::max(self.size, other.size);
+ 80021e8: 4601 mov r1, r0
+ 80021ea: e02d b.n 8002248 <core::fmt::float::float_to_decimal_common_shortest+0xe66>
+ 80021ec: d001 beq.n 80021f2 <core::fmt::float::float_to_decimal_common_shortest+0xe10>
+ 80021ee: 4601 mov r1, r0
+ 80021f0: e02a b.n 8002248 <core::fmt::float::float_to_decimal_common_shortest+0xe66>
+ 80021f2: 2003 movs r0, #3
+ 80021f4: ea40 0281 orr.w r2, r0, r1, lsl #2
+ 80021f8: f341 001d sbfx r0, r1, #0, #30
+ 80021fc: 2a07 cmp r2, #7
+ 80021fe: d320 bcc.n 8002242 <core::fmt::float::float_to_decimal_common_shortest+0xe60>
+ 8002200: 2300 movs r3, #0
+ 8002202: 2201 movs r2, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 8002204: f85a 5023 ldr.w r5, [sl, r3, lsl #2]
+ 8002208: f85b 6023 ldr.w r6, [fp, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 800220c: f002 0201 and.w r2, r2, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 8002210: 43ed mvns r5, r5
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8002212: 4435 add r5, r6
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002214: 442a add r2, r5
+ *a = v;
+ 8002216: f84b 2023 str.w r2, [fp, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 800221a: 42aa cmp r2, r5
+ 800221c: f04f 0201 mov.w r2, #1
+ self.index += 1;
+ 8002220: f103 0301 add.w r3, r3, #1
+ 8002224: bf28 it cs
+ 8002226: 2200 movcs r2, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8002228: 42b5 cmp r5, r6
+ 800222a: f04f 0601 mov.w r6, #1
+ 800222e: bf28 it cs
+ 8002230: 2600 movcs r6, #0
+ if self.index < self.len {
+ 8002232: 4283 cmp r3, r0
+ (carry1 || carry2, v)
+ 8002234: ea42 0206 orr.w r2, r2, r6
+ 8002238: d3e4 bcc.n 8002204 <core::fmt::float::float_to_decimal_common_shortest+0xe22>
+ assert!(noborrow);
+ 800223a: 2a00 cmp r2, #0
+ 800223c: ad9a add r5, sp, #616 ; 0x268
+ 800223e: f000 827e beq.w 800273e <core::fmt::float::float_to_decimal_common_shortest+0x135c>
+ if *x >= *scale4 { x.sub(scale4); d += 4; }
+ 8002242: f04c 0c04 orr.w ip, ip, #4
+ self.size = sz;
+ 8002246: 911f str r1, [sp, #124] ; 0x7c
+ let sz = max(self.size, other.size);
+ 8002248: 98c3 ldr r0, [sp, #780] ; 0x30c
+ 800224a: 4288 cmp r0, r1
+ 800224c: bf38 it cc
+ 800224e: 4608 movcc r0, r1
+ } else if self.end > slice.len() {
+ 8002250: 2829 cmp r0, #41 ; 0x29
+ 8002252: f080 8283 bcs.w 800275c <core::fmt::float::float_to_decimal_common_shortest+0x137a>
+ loop {
+ 8002256: 0082 lsls r2, r0, #2
+ if self.end == self.ptr {
+ 8002258: 2a00 cmp r2, #0
+ 800225a: d009 beq.n 8002270 <core::fmt::float::float_to_decimal_common_shortest+0xe8e>
+ 800225c: d00e beq.n 800227c <core::fmt::float::float_to_decimal_common_shortest+0xe9a>
+ 800225e: f85e 3002 ldr.w r3, [lr, r2]
+ 8002262: f858 6002 ldr.w r6, [r8, r2]
+ Ordering::Equal => (),
+ 8002266: 3a04 subs r2, #4
+ 8002268: 42b3 cmp r3, r6
+ 800226a: d0f5 beq.n 8002258 <core::fmt::float::float_to_decimal_common_shortest+0xe76>
+ 800226c: d301 bcc.n 8002272 <core::fmt::float::float_to_decimal_common_shortest+0xe90>
+ 800226e: e005 b.n 800227c <core::fmt::float::float_to_decimal_common_shortest+0xe9a>
+ 8002270: d004 beq.n 800227c <core::fmt::float::float_to_decimal_common_shortest+0xe9a>
+ 8002272: 9c11 ldr r4, [sp, #68] ; 0x44
+ 8002274: f8dd 8058 ldr.w r8, [sp, #88] ; 0x58
+ 8002278: 4608 mov r0, r1
+ 800227a: e02d b.n 80022d8 <core::fmt::float::float_to_decimal_common_shortest+0xef6>
+ 800227c: 2103 movs r1, #3
+ 800227e: ea41 0280 orr.w r2, r1, r0, lsl #2
+ 8002282: f340 011d sbfx r1, r0, #0, #30
+ 8002286: 9c11 ldr r4, [sp, #68] ; 0x44
+ 8002288: f8dd 8058 ldr.w r8, [sp, #88] ; 0x58
+ 800228c: 2a07 cmp r2, #7
+ 800228e: d320 bcc.n 80022d2 <core::fmt::float::float_to_decimal_common_shortest+0xef0>
+ 8002290: 2300 movs r3, #0
+ 8002292: 2201 movs r2, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 8002294: f859 5023 ldr.w r5, [r9, r3, lsl #2]
+ 8002298: f85b 6023 ldr.w r6, [fp, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 800229c: f002 0201 and.w r2, r2, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 80022a0: 43ed mvns r5, r5
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80022a2: 4435 add r5, r6
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80022a4: 442a add r2, r5
+ *a = v;
+ 80022a6: f84b 2023 str.w r2, [fp, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80022aa: 42aa cmp r2, r5
+ 80022ac: f04f 0201 mov.w r2, #1
+ self.index += 1;
+ 80022b0: f103 0301 add.w r3, r3, #1
+ 80022b4: bf28 it cs
+ 80022b6: 2200 movcs r2, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80022b8: 42b5 cmp r5, r6
+ 80022ba: f04f 0601 mov.w r6, #1
+ 80022be: bf28 it cs
+ 80022c0: 2600 movcs r6, #0
+ if self.index < self.len {
+ 80022c2: 428b cmp r3, r1
+ (carry1 || carry2, v)
+ 80022c4: ea42 0206 orr.w r2, r2, r6
+ 80022c8: d3e4 bcc.n 8002294 <core::fmt::float::float_to_decimal_common_shortest+0xeb2>
+ assert!(noborrow);
+ 80022ca: 2a00 cmp r2, #0
+ 80022cc: ad9a add r5, sp, #616 ; 0x268
+ 80022ce: f000 8236 beq.w 800273e <core::fmt::float::float_to_decimal_common_shortest+0x135c>
+ if *x >= *scale2 { x.sub(scale2); d += 2; }
+ 80022d2: f10c 0c02 add.w ip, ip, #2
+ self.size = sz;
+ 80022d6: 901f str r0, [sp, #124] ; 0x7c
+ let sz = max(self.size, other.size);
+ 80022d8: f8dd 9268 ldr.w r9, [sp, #616] ; 0x268
+ 80022dc: 4682 mov sl, r0
+ 80022de: 4581 cmp r9, r0
+ 80022e0: bf28 it cs
+ 80022e2: 46ca movcs sl, r9
+ } else if self.end > slice.len() {
+ 80022e4: f1ba 0f29 cmp.w sl, #41 ; 0x29
+ 80022e8: f080 8225 bcs.w 8002736 <core::fmt::float::float_to_decimal_common_shortest+0x1354>
+ loop {
+ 80022ec: ea4f 018a mov.w r1, sl, lsl #2
+ if self.end == self.ptr {
+ 80022f0: 2900 cmp r1, #0
+ 80022f2: d009 beq.n 8002308 <core::fmt::float::float_to_decimal_common_shortest+0xf26>
+ 80022f4: d00b beq.n 800230e <core::fmt::float::float_to_decimal_common_shortest+0xf2c>
+ 80022f6: f85e 2001 ldr.w r2, [lr, r1]
+ 80022fa: 586b ldr r3, [r5, r1]
+ Ordering::Equal => (),
+ 80022fc: 3904 subs r1, #4
+ 80022fe: 429a cmp r2, r3
+ 8002300: d0f6 beq.n 80022f0 <core::fmt::float::float_to_decimal_common_shortest+0xf0e>
+ 8002302: d204 bcs.n 800230e <core::fmt::float::float_to_decimal_common_shortest+0xf2c>
+ let mut sz = self.size;
+ 8002304: 4682 mov sl, r0
+ 8002306: e02d b.n 8002364 <core::fmt::float::float_to_decimal_common_shortest+0xf82>
+ 8002308: d001 beq.n 800230e <core::fmt::float::float_to_decimal_common_shortest+0xf2c>
+ 800230a: 4682 mov sl, r0
+ 800230c: e02a b.n 8002364 <core::fmt::float::float_to_decimal_common_shortest+0xf82>
+ 800230e: 2003 movs r0, #3
+ 8002310: ea40 018a orr.w r1, r0, sl, lsl #2
+ 8002314: f34a 001d sbfx r0, sl, #0, #30
+ 8002318: 2907 cmp r1, #7
+ 800231a: d31f bcc.n 800235c <core::fmt::float::float_to_decimal_common_shortest+0xf7a>
+ 800231c: 2100 movs r1, #0
+ 800231e: 2201 movs r2, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 8002320: f854 6021 ldr.w r6, [r4, r1, lsl #2]
+ 8002324: f85b 3021 ldr.w r3, [fp, r1, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002328: f002 0201 and.w r2, r2, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 800232c: 43f6 mvns r6, r6
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 800232e: 441e add r6, r3
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002330: 4432 add r2, r6
+ *a = v;
+ 8002332: f84b 2021 str.w r2, [fp, r1, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002336: 42b2 cmp r2, r6
+ 8002338: f04f 0201 mov.w r2, #1
+ self.index += 1;
+ 800233c: f101 0101 add.w r1, r1, #1
+ 8002340: bf28 it cs
+ 8002342: 2200 movcs r2, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8002344: 429e cmp r6, r3
+ 8002346: f04f 0301 mov.w r3, #1
+ 800234a: bf28 it cs
+ 800234c: 2300 movcs r3, #0
+ if self.index < self.len {
+ 800234e: 4281 cmp r1, r0
+ (carry1 || carry2, v)
+ 8002350: ea42 0203 orr.w r2, r2, r3
+ 8002354: d3e4 bcc.n 8002320 <core::fmt::float::float_to_decimal_common_shortest+0xf3e>
+ assert!(noborrow);
+ 8002356: 2a00 cmp r2, #0
+ 8002358: f000 81f1 beq.w 800273e <core::fmt::float::float_to_decimal_common_shortest+0x135c>
+ if *x >= *scale { x.sub(scale); d += 1; }
+ 800235c: f10c 0c01 add.w ip, ip, #1
+ self.size = sz;
+ 8002360: f8cd a07c str.w sl, [sp, #124] ; 0x7c
+ // where `d[i..j]` is a shorthand for `d[i] * 10^(j-i) + ... + d[j-1] * 10 + d[j]`.
+
+ // generate one digit: `d[n] = floor(mant / scale) < 10`.
+ let (d, _) = div_rem_upto_16(&mut mant, &scale, &scale2, &scale4, &scale8);
+ debug_assert!(d < 10);
+ buf[i] = b'0' + d;
+ 8002364: f1b8 0f10 cmp.w r8, #16
+ 8002368: f10d 016b add.w r1, sp, #107 ; 0x6b
+ 800236c: f20d 4454 addw r4, sp, #1108 ; 0x454
+ 8002370: f200 81f7 bhi.w 8002762 <core::fmt::float::float_to_decimal_common_shortest+0x1380>
+ 8002374: f10c 0030 add.w r0, ip, #48 ; 0x30
+ 8002378: f801 0008 strb.w r0, [r1, r8]
+ let sz = max(self.size, other.size);
+ 800237c: 9948 ldr r1, [sp, #288] ; 0x120
+ 800237e: 4650 mov r0, sl
+ 8002380: 4551 cmp r1, sl
+ 8002382: 9119 str r1, [sp, #100] ; 0x64
+ 8002384: bf28 it cs
+ 8002386: 4608 movcs r0, r1
+ } else if self.end > slice.len() {
+ 8002388: 2829 cmp r0, #41 ; 0x29
+ 800238a: f080 81ee bcs.w 800276a <core::fmt::float::float_to_decimal_common_shortest+0x1388>
+ i += 1;
+ 800238e: f108 0101 add.w r1, r8, #1
+ loop {
+ 8002392: ea4f 0880 mov.w r8, r0, lsl #2
+ 8002396: aa48 add r2, sp, #288 ; 0x120
+ 8002398: 9117 str r1, [sp, #92] ; 0x5c
+ if self.end == self.ptr {
+ 800239a: f1b8 0f00 cmp.w r8, #0
+ 800239e: d011 beq.n 80023c4 <core::fmt::float::float_to_decimal_common_shortest+0xfe2>
+ 80023a0: f1b8 0f00 cmp.w r8, #0
+ 80023a4: d012 beq.n 80023cc <core::fmt::float::float_to_decimal_common_shortest+0xfea>
+ 80023a6: f85e 0008 ldr.w r0, [lr, r8]
+ 80023aa: f852 1008 ldr.w r1, [r2, r8]
+ Ordering::Equal => (),
+ 80023ae: f1a8 0804 sub.w r8, r8, #4
+ else if *self < *other { Less }
+ 80023b2: 4288 cmp r0, r1
+ 80023b4: f04f 0001 mov.w r0, #1
+ 80023b8: bf38 it cc
+ 80023ba: f04f 30ff movcc.w r0, #4294967295 ; 0xffffffff
+ 80023be: d0ec beq.n 800239a <core::fmt::float::float_to_decimal_common_shortest+0xfb8>
+ 80023c0: 4680 mov r8, r0
+ 80023c2: e005 b.n 80023d0 <core::fmt::float::float_to_decimal_common_shortest+0xfee>
+ return Ordering::Equal
+ 80023c4: bf18 it ne
+ 80023c6: f04f 38ff movne.w r8, #4294967295 ; 0xffffffff
+ 80023ca: e001 b.n 80023d0 <core::fmt::float::float_to_decimal_common_shortest+0xfee>
+ 80023cc: f04f 0801 mov.w r8, #1
+ $name { size: self.size, base: self.base }
+ 80023d0: 9815 ldr r0, [sp, #84] ; 0x54
+ 80023d2: 4659 mov r1, fp
+ 80023d4: 22a0 movs r2, #160 ; 0xa0
+ 80023d6: f847 acc0 str.w sl, [r7, #-192]
+ 80023da: f001 fb83 bl 8003ae4 <__aeabi_memcpy4>
+ let mut sz = cmp::max(self.size, other.size);
+ 80023de: 9871 ldr r0, [sp, #452] ; 0x1c4
+ if other >= self { other } else { self }
+ 80023e0: 46d4 mov ip, sl
+ 80023e2: 4550 cmp r0, sl
+ 80023e4: bf28 it cs
+ 80023e6: 4684 movcs ip, r0
+ } else if self.end > slice.len() {
+ 80023e8: f1bc 0f29 cmp.w ip, #41 ; 0x29
+ 80023ec: f080 81ad bcs.w 800274a <core::fmt::float::float_to_decimal_common_shortest+0x1368>
+ 80023f0: 2103 movs r1, #3
+ 80023f2: f34c 0e1d sbfx lr, ip, #0, #30
+ 80023f6: ea41 038c orr.w r3, r1, ip, lsl #2
+ 80023fa: 2b07 cmp r3, #7
+ 80023fc: d202 bcs.n 8002404 <core::fmt::float::float_to_decimal_common_shortest+0x1022>
+ 80023fe: f10d 0e7c add.w lr, sp, #124 ; 0x7c
+ 8002402: e032 b.n 800246a <core::fmt::float::float_to_decimal_common_shortest+0x1088>
+ 8002404: e9dd 1214 ldrd r1, r2, [sp, #80] ; 0x50
+ 8002408: 2500 movs r5, #0
+ 800240a: 2300 movs r3, #0
+ let (c, v) = (*a).full_add(*b, carry);
+ 800240c: f851 6023 ldr.w r6, [r1, r3, lsl #2]
+ 8002410: f852 4023 ldr.w r4, [r2, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002414: f005 0501 and.w r5, r5, #1
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8002418: 4426 add r6, r4
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 800241a: 4435 add r5, r6
+ *a = v;
+ 800241c: f842 5023 str.w r5, [r2, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8002420: 42b5 cmp r5, r6
+ 8002422: f04f 0501 mov.w r5, #1
+ self.index += 1;
+ 8002426: f103 0301 add.w r3, r3, #1
+ 800242a: bf28 it cs
+ 800242c: 2500 movcs r5, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 800242e: 42a6 cmp r6, r4
+ 8002430: f04f 0601 mov.w r6, #1
+ 8002434: bf28 it cs
+ 8002436: 2600 movcs r6, #0
+ if self.index < self.len {
+ 8002438: 4573 cmp r3, lr
+ (carry1 || carry2, v)
+ 800243a: ea45 0506 orr.w r5, r5, r6
+ 800243e: d3e5 bcc.n 800240c <core::fmt::float::float_to_decimal_common_shortest+0x102a>
+ if carry {
+ 8002440: 2d01 cmp r5, #1
+ 8002442: f10d 0e7c add.w lr, sp, #124 ; 0x7c
+ 8002446: d10d bne.n 8002464 <core::fmt::float::float_to_decimal_common_shortest+0x1082>
+ self.base[sz] = 1;
+ 8002448: f1bc 0f27 cmp.w ip, #39 ; 0x27
+ 800244c: ad9a add r5, sp, #616 ; 0x268
+ 800244e: f200 81a4 bhi.w 800279a <core::fmt::float::float_to_decimal_common_shortest+0x13b8>
+ 8002452: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 8002456: eb01 028c add.w r2, r1, ip, lsl #2
+ 800245a: 2101 movs r1, #1
+ sz += 1;
+ 800245c: f10c 0c01 add.w ip, ip, #1
+ self.base[sz] = 1;
+ 8002460: 6051 str r1, [r2, #4]
+ 8002462: e000 b.n 8002466 <core::fmt::float::float_to_decimal_common_shortest+0x1084>
+ 8002464: ad9a add r5, sp, #616 ; 0x268
+ 8002466: f20d 4454 addw r4, sp, #1108 ; 0x454
+ 800246a: 45cc cmp ip, r9
+ self.size = sz;
+ 800246c: f847 ccc0 str.w ip, [r7, #-192]
+ 8002470: bf28 it cs
+ 8002472: 46e1 movcs r9, ip
+ } else if self.end > slice.len() {
+ 8002474: f1b9 0f29 cmp.w r9, #41 ; 0x29
+ 8002478: f080 816b bcs.w 8002752 <core::fmt::float::float_to_decimal_common_shortest+0x1370>
+ loop {
+ 800247c: ea4f 0189 mov.w r1, r9, lsl #2
+ 8002480: f8dd 9040 ldr.w r9, [sp, #64] ; 0x40
+ 8002484: f8dd c060 ldr.w ip, [sp, #96] ; 0x60
+ 8002488: f1a7 06c0 sub.w r6, r7, #192 ; 0xc0
+ if self.end == self.ptr {
+ 800248c: 2900 cmp r1, #0
+ 800248e: d00c beq.n 80024aa <core::fmt::float::float_to_decimal_common_shortest+0x10c8>
+ 8002490: b179 cbz r1, 80024b2 <core::fmt::float::float_to_decimal_common_shortest+0x10d0>
+ 8002492: 586a ldr r2, [r5, r1]
+ 8002494: 5873 ldr r3, [r6, r1]
+ Ordering::Equal => (),
+ 8002496: 3904 subs r1, #4
+ else if *self < *other { Less }
+ 8002498: 429a cmp r2, r3
+ 800249a: f04f 0201 mov.w r2, #1
+ 800249e: bf38 it cc
+ 80024a0: f04f 32ff movcc.w r2, #4294967295 ; 0xffffffff
+ 80024a4: d0f2 beq.n 800248c <core::fmt::float::float_to_decimal_common_shortest+0x10aa>
+ 80024a6: 4611 mov r1, r2
+ 80024a8: e004 b.n 80024b4 <core::fmt::float::float_to_decimal_common_shortest+0x10d2>
+ return Ordering::Equal
+ 80024aa: bf18 it ne
+ 80024ac: f04f 31ff movne.w r1, #4294967295 ; 0xffffffff
+ 80024b0: e000 b.n 80024b4 <core::fmt::float::float_to_decimal_common_shortest+0x10d2>
+ 80024b2: 2101 movs r1, #1
+ 80024b4: 9e13 ldr r6, [sp, #76] ; 0x4c
+ 80024b6: fa4f f288 sxtb.w r2, r8
+ // - stop and round `down` (keep digits as is) when `mant < minus` (or `<=`).
+ // - stop and round `up` (increase the last digit) when `scale < mant + plus` (or `<=`).
+ // - keep generating otherwise.
+ down = mant.cmp(&minus) < rounding;
+ up = scale.cmp(mant.clone().add(&plus)) < rounding;
+ if down || up { break; } // we have the shortest representation, proceed to the rounding
+ 80024ba: 42b2 cmp r2, r6
+ 80024bc: bfa4 itt ge
+ 80024be: b24b sxtbge r3, r1
+ 80024c0: 42b3 cmpge r3, r6
+ 80024c2: f2c0 8085 blt.w 80025d0 <core::fmt::float::float_to_decimal_common_shortest+0x11ee>
+ } else if self.end > slice.len() {
+ 80024c6: f1ba 0f29 cmp.w sl, #41 ; 0x29
+ 80024ca: f080 8134 bcs.w 8002736 <core::fmt::float::float_to_decimal_common_shortest+0x1354>
+ if self.ptr == self.end {
+ 80024ce: f1ba 0f00 cmp.w sl, #0
+ 80024d2: f50d 7843 add.w r8, sp, #780 ; 0x30c
+ 80024d6: d01f beq.n 8002518 <core::fmt::float::float_to_decimal_common_shortest+0x1136>
+ intrinsics::offset(self, count) as *mut T
+ 80024d8: eb0e 018a add.w r1, lr, sl, lsl #2
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 80024dc: ea4f 028a mov.w r2, sl, lsl #2
+ 80024e0: 2300 movs r3, #0
+ 80024e2: 465d mov r5, fp
+ 80024e4: f04f 0c0a mov.w ip, #10
+ 80024e8: 3104 adds r1, #4
+ 80024ea: 9116 str r1, [sp, #88] ; 0x58
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 80024ec: 682e ldr r6, [r5, #0]
+ 80024ee: 2100 movs r1, #0
+ if self.ptr == self.end {
+ 80024f0: 3a04 subs r2, #4
+ 80024f2: fbe6 310c umlal r3, r1, r6, ip
+ *a = v;
+ 80024f6: f845 3b04 str.w r3, [r5], #4
+ 80024fa: 460b mov r3, r1
+ 80024fc: d1f6 bne.n 80024ec <core::fmt::float::float_to_decimal_common_shortest+0x110a>
+ 80024fe: 9a19 ldr r2, [sp, #100] ; 0x64
+ 8002500: b139 cbz r1, 8002512 <core::fmt::float::float_to_decimal_common_shortest+0x1130>
+ self.base[sz] = carry;
+ 8002502: f1ba 0f27 cmp.w sl, #39 ; 0x27
+ 8002506: f200 813d bhi.w 8002784 <core::fmt::float::float_to_decimal_common_shortest+0x13a2>
+ 800250a: 9b16 ldr r3, [sp, #88] ; 0x58
+ sz += 1;
+ 800250c: f10a 0a01 add.w sl, sl, #1
+ self.base[sz] = carry;
+ 8002510: 6019 str r1, [r3, #0]
+ 8002512: f8dd c060 ldr.w ip, [sp, #96] ; 0x60
+ 8002516: e002 b.n 800251e <core::fmt::float::float_to_decimal_common_shortest+0x113c>
+ 8002518: 9a19 ldr r2, [sp, #100] ; 0x64
+ 800251a: f04f 0a00 mov.w sl, #0
+ } else if self.end > slice.len() {
+ 800251e: 2a29 cmp r2, #41 ; 0x29
+ self.size = sz;
+ 8002520: f8cd a07c str.w sl, [sp, #124] ; 0x7c
+ 8002524: f080 8124 bcs.w 8002770 <core::fmt::float::float_to_decimal_common_shortest+0x138e>
+ if self.ptr == self.end {
+ 8002528: 2a00 cmp r2, #0
+ 800252a: d01d beq.n 8002568 <core::fmt::float::float_to_decimal_common_shortest+0x1186>
+ 800252c: 9d0e ldr r5, [sp, #56] ; 0x38
+ 800252e: a948 add r1, sp, #288 ; 0x120
+ 8002530: f04f 0c0a mov.w ip, #10
+ 8002534: 2300 movs r3, #0
+ 8002536: eb01 0182 add.w r1, r1, r2, lsl #2
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 800253a: 0092 lsls r2, r2, #2
+ 800253c: 3104 adds r1, #4
+ 800253e: 9116 str r1, [sp, #88] ; 0x58
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8002540: 682e ldr r6, [r5, #0]
+ 8002542: 2100 movs r1, #0
+ if self.ptr == self.end {
+ 8002544: 3a04 subs r2, #4
+ 8002546: fbe6 310c umlal r3, r1, r6, ip
+ *a = v;
+ 800254a: f845 3b04 str.w r3, [r5], #4
+ 800254e: 460b mov r3, r1
+ 8002550: d1f6 bne.n 8002540 <core::fmt::float::float_to_decimal_common_shortest+0x115e>
+ 8002552: b159 cbz r1, 800256c <core::fmt::float::float_to_decimal_common_shortest+0x118a>
+ 8002554: 9a19 ldr r2, [sp, #100] ; 0x64
+ self.base[sz] = carry;
+ 8002556: 2a27 cmp r2, #39 ; 0x27
+ 8002558: f200 8118 bhi.w 800278c <core::fmt::float::float_to_decimal_common_shortest+0x13aa>
+ 800255c: 9b16 ldr r3, [sp, #88] ; 0x58
+ 800255e: f8dd c060 ldr.w ip, [sp, #96] ; 0x60
+ sz += 1;
+ 8002562: 3201 adds r2, #1
+ self.base[sz] = carry;
+ 8002564: 6019 str r1, [r3, #0]
+ 8002566: e003 b.n 8002570 <core::fmt::float::float_to_decimal_common_shortest+0x118e>
+ 8002568: 2200 movs r2, #0
+ 800256a: e001 b.n 8002570 <core::fmt::float::float_to_decimal_common_shortest+0x118e>
+ 800256c: e9dd c218 ldrd ip, r2, [sp, #96] ; 0x60
+ } else if self.end > slice.len() {
+ 8002570: 2829 cmp r0, #41 ; 0x29
+ self.size = sz;
+ 8002572: 9248 str r2, [sp, #288] ; 0x120
+ 8002574: f080 8100 bcs.w 8002778 <core::fmt::float::float_to_decimal_common_shortest+0x1396>
+ if self.ptr == self.end {
+ 8002578: 2800 cmp r0, #0
+ 800257a: d01b beq.n 80025b4 <core::fmt::float::float_to_decimal_common_shortest+0x11d2>
+ 800257c: a971 add r1, sp, #452 ; 0x1c4
+ 800257e: 9e14 ldr r6, [sp, #80] ; 0x50
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 8002580: 0082 lsls r2, r0, #2
+ 8002582: 2300 movs r3, #0
+ 8002584: eb01 0180 add.w r1, r1, r0, lsl #2
+ 8002588: 3104 adds r1, #4
+ 800258a: 9119 str r1, [sp, #100] ; 0x64
+ 800258c: 210a movs r1, #10
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 800258e: 6834 ldr r4, [r6, #0]
+ 8002590: 2500 movs r5, #0
+ if self.ptr == self.end {
+ 8002592: 3a04 subs r2, #4
+ 8002594: fbe4 3501 umlal r3, r5, r4, r1
+ *a = v;
+ 8002598: f846 3b04 str.w r3, [r6], #4
+ 800259c: 462b mov r3, r5
+ 800259e: d1f6 bne.n 800258e <core::fmt::float::float_to_decimal_common_shortest+0x11ac>
+ 80025a0: b12d cbz r5, 80025ae <core::fmt::float::float_to_decimal_common_shortest+0x11cc>
+ self.base[sz] = carry;
+ 80025a2: 2827 cmp r0, #39 ; 0x27
+ 80025a4: f200 80f6 bhi.w 8002794 <core::fmt::float::float_to_decimal_common_shortest+0x13b2>
+ 80025a8: 9919 ldr r1, [sp, #100] ; 0x64
+ sz += 1;
+ 80025aa: 3001 adds r0, #1
+ self.base[sz] = carry;
+ 80025ac: 600d str r5, [r1, #0]
+ 80025ae: f20d 4454 addw r4, sp, #1108 ; 0x454
+ 80025b2: e000 b.n 80025b6 <core::fmt::float::float_to_decimal_common_shortest+0x11d4>
+ 80025b4: 2000 movs r0, #0
+ 80025b6: 990f ldr r1, [sp, #60] ; 0x3c
+ self.size = sz;
+ 80025b8: 9071 str r0, [sp, #452] ; 0x1c4
+ if other >= self { other } else { self }
+ 80025ba: 4650 mov r0, sl
+ 80025bc: ad9a add r5, sp, #616 ; 0x268
+ 80025be: 4551 cmp r1, sl
+ 80025c0: bf28 it cs
+ 80025c2: 4608 movcs r0, r1
+ } else if self.end > slice.len() {
+ 80025c4: 2828 cmp r0, #40 ; 0x28
+ 80025c6: f67f adb9 bls.w 800213c <core::fmt::float::float_to_decimal_common_shortest+0xd5a>
+ slice_index_len_fail(self.end, slice.len());
+ 80025ca: 2128 movs r1, #40 ; 0x28
+ 80025cc: f7fd ffb7 bl 800053e <core::slice::slice_index_len_fail>
+ else if *self < *other { Less }
+ 80025d0: b248 sxtb r0, r1
+ }
+
+ // rounding up happens when
+ // i) only the rounding-up condition was triggered, or
+ // ii) both conditions were triggered and tie breaking prefers rounding up.
+ if up && (!down || *mant.mul_pow2(1) >= scale) {
+ 80025d2: 42b0 cmp r0, r6
+ 80025d4: da1c bge.n 8002610 <core::fmt::float::float_to_decimal_common_shortest+0x122e>
+ 80025d6: 9d0d ldr r5, [sp, #52] ; 0x34
+ 80025d8: e9dd 8a16 ldrd r8, sl, [sp, #88] ; 0x58
+ 80025dc: 42b2 cmp r2, r6
+ 80025de: da21 bge.n 8002624 <core::fmt::float::float_to_decimal_common_shortest+0x1242>
+ 80025e0: a81f add r0, sp, #124 ; 0x7c
+ 80025e2: 2101 movs r1, #1
+ 80025e4: f7fe fa89 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ let sz = max(self.size, other.size);
+ 80025e8: 9a9a ldr r2, [sp, #616] ; 0x268
+ 80025ea: 991f ldr r1, [sp, #124] ; 0x7c
+ if other >= self { other } else { self }
+ 80025ec: 428a cmp r2, r1
+ 80025ee: bf28 it cs
+ 80025f0: 4611 movcs r1, r2
+ } else if self.end > slice.len() {
+ 80025f2: 2929 cmp r1, #41 ; 0x29
+ 80025f4: f080 80b1 bcs.w 800275a <core::fmt::float::float_to_decimal_common_shortest+0x1378>
+ loop {
+ 80025f8: 0089 lsls r1, r1, #2
+ if self.end == self.ptr {
+ 80025fa: 2900 cmp r1, #0
+ 80025fc: d011 beq.n 8002622 <core::fmt::float::float_to_decimal_common_shortest+0x1240>
+ 80025fe: d011 beq.n 8002624 <core::fmt::float::float_to_decimal_common_shortest+0x1242>
+ 8002600: ab9a add r3, sp, #616 ; 0x268
+ 8002602: 5842 ldr r2, [r0, r1]
+ 8002604: 585b ldr r3, [r3, r1]
+ Ordering::Equal => (),
+ 8002606: 3904 subs r1, #4
+ 8002608: 429a cmp r2, r3
+ 800260a: d0f6 beq.n 80025fa <core::fmt::float::float_to_decimal_common_shortest+0x1218>
+ 800260c: d20a bcs.n 8002624 <core::fmt::float::float_to_decimal_common_shortest+0x1242>
+ 800260e: e01f b.n 8002650 <core::fmt::float::float_to_decimal_common_shortest+0x126e>
+ 8002610: f8dd a05c ldr.w sl, [sp, #92] ; 0x5c
+ } else if self.end > slice.len() {
+ 8002614: f1ba 0f12 cmp.w sl, #18
+ 8002618: d31e bcc.n 8002658 <core::fmt::float::float_to_decimal_common_shortest+0x1276>
+ 800261a: e0e5 b.n 80027e8 <core::fmt::float::float_to_decimal_common_shortest+0x1406>
+ 800261c: 4675 mov r5, lr
+ 800261e: f7ff bb86 b.w 8001d2e <core::fmt::float::float_to_decimal_common_shortest+0x94c>
+ 8002622: d115 bne.n 8002650 <core::fmt::float::float_to_decimal_common_shortest+0x126e>
+ 8002624: f10d 046b add.w r4, sp, #107 ; 0x6b
+ // if rounding up changes the length, the exponent should also change.
+ // it seems that this condition is very hard to satisfy (possibly impossible),
+ // but we are just being safe and consistent here.
+ if let Some(c) = round_up(buf, i) {
+ 8002628: 2111 movs r1, #17
+ 800262a: 4652 mov r2, sl
+ 800262c: 4620 mov r0, r4
+ 800262e: f7fe faea bl 8000c06 <core::num::flt2dec::round_up>
+ 8002632: f3c0 2107 ubfx r1, r0, #8, #8
+ 8002636: b2c0 uxtb r0, r0
+ 8002638: 2801 cmp r0, #1
+ 800263a: d109 bne.n 8002650 <core::fmt::float::float_to_decimal_common_shortest+0x126e>
+ buf[i] = c;
+ 800263c: f1ba 0f10 cmp.w sl, #16
+ 8002640: f200 80f4 bhi.w 800282c <core::fmt::float::float_to_decimal_common_shortest+0x144a>
+ i += 1;
+ k += 1;
+ 8002644: 3501 adds r5, #1
+ buf[i] = c;
+ 8002646: f804 100a strb.w r1, [r4, sl]
+ i += 1;
+ 800264a: f108 0a02 add.w sl, r8, #2
+ 800264e: 950d str r5, [sp, #52] ; 0x34
+ 8002650: f1ba 0f12 cmp.w sl, #18
+ 8002654: f080 80c8 bcs.w 80027e8 <core::fmt::float::float_to_decimal_common_shortest+0x1406>
+ 8002658: f10d 0c0c add.w ip, sp, #12
+ assert!(!buf.is_empty());
+ 800265c: f1ba 0f00 cmp.w sl, #0
+ 8002660: e89c 1028 ldmia.w ip, {r3, r5, ip}
+ 8002664: 990d ldr r1, [sp, #52] ; 0x34
+ 8002666: f000 80c3 beq.w 80027f0 <core::fmt::float::float_to_decimal_common_shortest+0x140e>
+ assert!(buf[0] > b'0');
+ 800266a: f89d 006b ldrb.w r0, [sp, #107] ; 0x6b
+ 800266e: 2830 cmp r0, #48 ; 0x30
+ 8002670: f240 80c4 bls.w 80027fc <core::fmt::float::float_to_decimal_common_shortest+0x141a>
+ if exp <= 0 {
+ 8002674: b208 sxth r0, r1
+ parts[0] = Part::Copy(b"0.");
+ 8002676: 2102 movs r1, #2
+ if exp <= 0 {
+ 8002678: 2801 cmp r0, #1
+ 800267a: db1c blt.n 80026b6 <core::fmt::float::float_to_decimal_common_shortest+0x12d4>
+ 800267c: f10d 066b add.w r6, sp, #107 ; 0x6b
+ if exp < buf.len() {
+ 8002680: 4550 cmp r0, sl
+ 8002682: f827 1cc0 strh.w r1, [r7, #-192]
+ 8002686: f847 6cbc str.w r6, [r7, #-188]
+ 800268a: d22e bcs.n 80026ea <core::fmt::float::float_to_decimal_common_shortest+0x1308>
+ parts[1] = Part::Copy(b".");
+ 800268c: f644 2286 movw r2, #19078 ; 0x4a86
+ parts[0] = Part::Copy(&buf[..exp]);
+ 8002690: f847 0cb8 str.w r0, [r7, #-184]
+ parts[1] = Part::Copy(b".");
+ 8002694: f827 1cb4 strh.w r1, [r7, #-180]
+ from_raw_parts(slice.as_ptr().offset(self.start as isize), self.end - self.start)
+ 8002698: ebaa 0a00 sub.w sl, sl, r0
+ 800269c: f6c0 0200 movt r2, #2048 ; 0x800
+ 80026a0: f847 2cb0 str.w r2, [r7, #-176]
+ 80026a4: 2201 movs r2, #1
+ 80026a6: f847 2cac str.w r2, [r7, #-172]
+ parts[2] = Part::Copy(&buf[exp..]);
+ 80026aa: f827 1ca8 strh.w r1, [r7, #-168]
+ intrinsics::offset(self, count)
+ 80026ae: 1831 adds r1, r6, r0
+ 80026b0: f847 1ca4 str.w r1, [r7, #-164]
+ 80026b4: e013 b.n 80026de <core::fmt::float::float_to_decimal_common_shortest+0x12fc>
+ parts[0] = Part::Copy(b"0.");
+ 80026b6: f644 2284 movw r2, #19076 ; 0x4a84
+ 80026ba: f827 1cc0 strh.w r1, [r7, #-192]
+ let minus_exp = -(exp as i32) as usize;
+ 80026be: 4240 negs r0, r0
+ parts[0] = Part::Copy(b"0.");
+ 80026c0: f6c0 0200 movt r2, #2048 ; 0x800
+ 80026c4: e947 212f strd r2, r1, [r7, #-188] ; 0xbc
+ 80026c8: 2200 movs r2, #0
+ parts[1] = Part::Zero(minus_exp);
+ 80026ca: f827 2cb4 strh.w r2, [r7, #-180]
+ 80026ce: f847 0cb0 str.w r0, [r7, #-176]
+ parts[2] = Part::Copy(buf);
+ 80026d2: f10d 006b add.w r0, sp, #107 ; 0x6b
+ 80026d6: f827 1ca8 strh.w r1, [r7, #-168]
+ 80026da: f847 0ca4 str.w r0, [r7, #-164]
+ 80026de: f1a7 00c0 sub.w r0, r7, #192 ; 0xc0
+ 80026e2: f100 0120 add.w r1, r0, #32
+ 80026e6: 2003 movs r0, #3
+ 80026e8: e00b b.n 8002702 <core::fmt::float::float_to_decimal_common_shortest+0x1320>
+ parts[0] = Part::Copy(buf);
+ 80026ea: f847 acb8 str.w sl, [r7, #-184]
+ parts[1] = Part::Zero(exp - buf.len());
+ 80026ee: 2100 movs r1, #0
+ 80026f0: eba0 0a0a sub.w sl, r0, sl
+ 80026f4: f1a7 00c0 sub.w r0, r7, #192 ; 0xc0
+ 80026f8: f827 1cb4 strh.w r1, [r7, #-180]
+ 80026fc: f100 0110 add.w r1, r0, #16
+ 8002700: 2002 movs r0, #2
+ 8002702: f8c1 a000 str.w sl, [r1]
+ 8002706: f1a7 01c0 sub.w r1, r7, #192 ; 0xc0
+ 800270a: f8cd 5454 str.w r5, [sp, #1108] ; 0x454
+ 800270e: f8cd 3458 str.w r3, [sp, #1112] ; 0x458
+ 8002712: f8cd 145c str.w r1, [sp, #1116] ; 0x45c
+ 8002716: f8cd 0460 str.w r0, [sp, #1120] ; 0x460
+ 800271a: f20d 4154 addw r1, sp, #1108 ; 0x454
+ // enough for f32 and f64
+ let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();
+ let mut parts: [flt2dec::Part; 4] = mem::uninitialized();
+ let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest,
+ *num, sign, 0, false, &mut buf, &mut parts);
+ fmt.pad_formatted_parts(&formatted)
+ 800271e: 4660 mov r0, ip
+ 8002720: f7fe fc7e bl 8001020 <core::fmt::Formatter::pad_formatted_parts>
+ }
+}
+ 8002724: f50d 6db3 add.w sp, sp, #1432 ; 0x598
+ 8002728: b001 add sp, #4
+ 800272a: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 800272e: bdf0 pop {r4, r5, r6, r7, pc}
+ 8002730: 2128 movs r1, #40 ; 0x28
+ 8002732: f7fd ff08 bl 8000546 <core::panicking::panic_bounds_check>
+ 8002736: 4650 mov r0, sl
+ 8002738: 2128 movs r1, #40 ; 0x28
+ 800273a: f7fd ff00 bl 800053e <core::slice::slice_index_len_fail>
+ 800273e: f244 500c movw r0, #17676 ; 0x450c
+ 8002742: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002746: f7fe f9d4 bl 8000af2 <core::panicking::panic>
+ 800274a: 4660 mov r0, ip
+ 800274c: 2128 movs r1, #40 ; 0x28
+ 800274e: f7fd fef6 bl 800053e <core::slice::slice_index_len_fail>
+ 8002752: 4648 mov r0, r9
+ 8002754: 2128 movs r1, #40 ; 0x28
+ 8002756: f7fd fef2 bl 800053e <core::slice::slice_index_len_fail>
+ 800275a: 4608 mov r0, r1
+ 800275c: 2128 movs r1, #40 ; 0x28
+ 800275e: f7fd feee bl 800053e <core::slice::slice_index_len_fail>
+ buf[i] = b'0' + d;
+ 8002762: 4640 mov r0, r8
+ 8002764: 2111 movs r1, #17
+ 8002766: f7fd feee bl 8000546 <core::panicking::panic_bounds_check>
+ slice_index_len_fail(self.end, slice.len());
+ 800276a: 2128 movs r1, #40 ; 0x28
+ 800276c: f7fd fee7 bl 800053e <core::slice::slice_index_len_fail>
+ slice_index_len_fail(self.end, slice.len());
+ 8002770: 4610 mov r0, r2
+ 8002772: 2128 movs r1, #40 ; 0x28
+ 8002774: f7fd fee3 bl 800053e <core::slice::slice_index_len_fail>
+ 8002778: 2128 movs r1, #40 ; 0x28
+ 800277a: f7fd fee0 bl 800053e <core::slice::slice_index_len_fail>
+ buf[i] = b'0' + q as u8;
+ 800277e: 2111 movs r1, #17
+ 8002780: f7fd fee1 bl 8000546 <core::panicking::panic_bounds_check>
+ self.base[sz] = carry;
+ 8002784: 4650 mov r0, sl
+ 8002786: 2128 movs r1, #40 ; 0x28
+ 8002788: f7fd fedd bl 8000546 <core::panicking::panic_bounds_check>
+ 800278c: 4610 mov r0, r2
+ 800278e: 2128 movs r1, #40 ; 0x28
+ 8002790: f7fd fed9 bl 8000546 <core::panicking::panic_bounds_check>
+ 8002794: 2128 movs r1, #40 ; 0x28
+ 8002796: f7fd fed6 bl 8000546 <core::panicking::panic_bounds_check>
+ 800279a: 4660 mov r0, ip
+ 800279c: 2128 movs r1, #40 ; 0x28
+ 800279e: f7fd fed2 bl 8000546 <core::panicking::panic_bounds_check>
+ 80027a2: f7fd ffb5 bl 8000710 <core::panicking::panic_fmt>
+ assert!(d.mant > 0);
+ 80027a6: f644 003c movw r0, #18492 ; 0x483c
+ 80027aa: f6c0 0000 movt r0, #2048 ; 0x800
+ 80027ae: f7fe f9a0 bl 8000af2 <core::panicking::panic>
+ assert!(d.mant.checked_add(d.plus).is_some());
+ 80027b2: f644 0054 movw r0, #18516 ; 0x4854
+ 80027b6: f6c0 0000 movt r0, #2048 ; 0x800
+ 80027ba: f7fe f99a bl 8000af2 <core::panicking::panic>
+ assert!(d.mant.checked_sub(d.minus).is_some());
+ 80027be: f644 006c movw r0, #18540 ; 0x486c
+ 80027c2: f6c0 0000 movt r0, #2048 ; 0x800
+ 80027c6: f7fe f994 bl 8000af2 <core::panicking::panic>
+ assert!(d.mant + d.plus < (1 << 61)); // we need at least three bits of additional precision
+ 80027ca: f644 0084 movw r0, #18564 ; 0x4884
+ 80027ce: f6c0 0000 movt r0, #2048 ; 0x800
+ 80027d2: f7fe f98e bl 8000af2 <core::panicking::panic>
+ assert!(edelta >= 0);
+ 80027d6: f644 009c movw r0, #18588 ; 0x489c
+ 80027da: f6c0 0000 movt r0, #2048 ; 0x800
+ 80027de: f7fe f988 bl 8000af2 <core::panicking::panic>
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 80027e2: 2151 movs r1, #81 ; 0x51
+ 80027e4: f7fd feaf bl 8000546 <core::panicking::panic_bounds_check>
+ slice_index_len_fail(self.end, slice.len());
+ 80027e8: 4650 mov r0, sl
+ 80027ea: 2111 movs r1, #17
+ 80027ec: f7fd fea7 bl 800053e <core::slice::slice_index_len_fail>
+ assert!(!buf.is_empty());
+ 80027f0: f644 2054 movw r0, #19028 ; 0x4a54
+ 80027f4: f6c0 0000 movt r0, #2048 ; 0x800
+ 80027f8: f7fe f97b bl 8000af2 <core::panicking::panic>
+ assert!(buf[0] > b'0');
+ 80027fc: f644 206c movw r0, #19052 ; 0x4a6c
+ 8002800: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002804: f7fe f975 bl 8000af2 <core::panicking::panic>
+ slice_index_len_fail(self.end, slice.len());
+ 8002808: 4640 mov r0, r8
+ 800280a: 2128 movs r1, #40 ; 0x28
+ 800280c: f7fd fe97 bl 800053e <core::slice::slice_index_len_fail>
+ 8002810: 2128 movs r1, #40 ; 0x28
+ 8002812: f7fd fe94 bl 800053e <core::slice::slice_index_len_fail>
+ 8002816: 4648 mov r0, r9
+ 8002818: 2128 movs r1, #40 ; 0x28
+ 800281a: f7fd fe94 bl 8000546 <core::panicking::panic_bounds_check>
+ 800281e: 4640 mov r0, r8
+ 8002820: 2128 movs r1, #40 ; 0x28
+ 8002822: f7fd fe90 bl 8000546 <core::panicking::panic_bounds_check>
+ 8002826: 2128 movs r1, #40 ; 0x28
+ 8002828: f7fd fe8d bl 8000546 <core::panicking::panic_bounds_check>
+ buf[i] = c;
+ 800282c: 4650 mov r0, sl
+ 800282e: 2111 movs r1, #17
+ 8002830: f7fd fe89 bl 8000546 <core::panicking::panic_bounds_check>
+
+08002834 <core::fmt::float::float_to_decimal_common_exact>:
+fn float_to_decimal_common_exact<T>(fmt: &mut Formatter, num: &T,
+ 8002834: b5f0 push {r4, r5, r6, r7, lr}
+ 8002836: af03 add r7, sp, #12
+ 8002838: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 800283c: f5ad 6df2 sub.w sp, sp, #1936 ; 0x790
+ 8002840: b081 sub sp, #4
+ let bits: u64 = unsafe { transmute(self) };
+ 8002842: ec55 3b10 vmov r3, r5, d0
+ 8002846: 4681 mov r9, r0
+ 8002848: 4628 mov r0, r5
+ let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
+ 800284a: f3c5 5c0a ubfx ip, r5, #20, #11
+ let mantissa = if exponent == 0 {
+ 800284e: 469a mov sl, r3
+ 8002850: f36f 501f bfc r0, #20, #12
+ 8002854: f1bc 0f00 cmp.w ip, #0
+ (bits & 0xfffffffffffff) << 1
+ 8002858: ea4f 0440 mov.w r4, r0, lsl #1
+ (bits & 0xfffffffffffff) | 0x10000000000000
+ 800285c: f440 1680 orr.w r6, r0, #1048576 ; 0x100000
+ let mantissa = if exponent == 0 {
+ 8002860: bf04 itt eq
+ 8002862: ea44 76d3 orreq.w r6, r4, r3, lsr #31
+ 8002866: ea4f 0a4a moveq.w sl, sl, lsl #1
+ (0, 0) => Fp::Zero,
+ 800286a: f025 4400 bic.w r4, r5, #2147483648 ; 0x80000000
+ 800286e: 431c orrs r4, r3
+ 8002870: d00f beq.n 8002892 <core::fmt::float::float_to_decimal_common_exact+0x5e>
+ (_, 0) => Fp::Subnormal,
+ 8002872: f240 0e00 movw lr, #0
+ 8002876: f04f 0800 mov.w r8, #0
+ 800287a: f6c7 7ef0 movt lr, #32752 ; 0x7ff0
+ 800287e: ea05 040e and.w r4, r5, lr
+ 8002882: 4574 cmp r4, lr
+ 8002884: d019 beq.n 80028ba <core::fmt::float::float_to_decimal_common_exact+0x86>
+ 8002886: 0060 lsls r0, r4, #1
+ 8002888: d123 bne.n 80028d2 <core::fmt::float::float_to_decimal_common_exact+0x9e>
+ 800288a: 2000 movs r0, #0
+ exponent -= 1023 + 52;
+ 800288c: f2ac 4b33 subw fp, ip, #1075 ; 0x433
+ 8002890: e037 b.n 8002902 <core::fmt::float::float_to_decimal_common_exact+0xce>
+ 8002892: f244 4e98 movw lr, #17560 ; 0x4498
+ 8002896: b2c8 uxtb r0, r1
+ 8002898: f6c0 0e00 movt lr, #2048 ; 0x800
+ (FullDecoded::Zero, Sign::Minus) => b"",
+ 800289c: 2800 cmp r0, #0
+ 800289e: f000 817c beq.w 8002b9a <core::fmt::float::float_to_decimal_common_exact+0x366>
+ 80028a2: 2801 cmp r0, #1
+ 80028a4: f000 817b beq.w 8002b9e <core::fmt::float::float_to_decimal_common_exact+0x36a>
+ 80028a8: 2802 cmp r0, #2
+ 80028aa: f040 8180 bne.w 8002bae <core::fmt::float::float_to_decimal_common_exact+0x37a>
+ 80028ae: f644 2eb0 movw lr, #19120 ; 0x4ab0
+ 80028b2: 2301 movs r3, #1
+ 80028b4: f6c0 0e00 movt lr, #2048 ; 0x800
+ 80028b8: e186 b.n 8002bc8 <core::fmt::float::float_to_decimal_common_exact+0x394>
+ FpCategory::Nan => FullDecoded::Nan,
+ 80028ba: 4318 orrs r0, r3
+ 80028bc: bf08 it eq
+ 80028be: f04f 0801 moveq.w r8, #1
+ (FullDecoded::Nan, _) => b"",
+ 80028c2: 2800 cmp r0, #0
+ 80028c4: f040 819f bne.w 8002c06 <core::fmt::float::float_to_decimal_common_exact+0x3d2>
+ 80028c8: 4643 mov r3, r8
+ sign: Sign, frac_digits: usize, _upper: bool,
+ buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>
+ where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16) {
+ assert!(parts.len() >= 4);
+
+ let (negative, full_decoded) = decode(v);
+ 80028ca: 0fe8 lsrs r0, r5, #31
+ 80028cc: 4644 mov r4, r8
+ 80028ce: 930a str r3, [sp, #40] ; 0x28
+ 80028d0: e01c b.n 800290c <core::fmt::float::float_to_decimal_common_exact+0xd8>
+ if mant == minnorm.0 {
+ 80028d2: f486 1080 eor.w r0, r6, #1048576 ; 0x100000
+ 80028d6: ea50 000a orrs.w r0, r0, sl
+ 80028da: d10a bne.n 80028f2 <core::fmt::float::float_to_decimal_common_exact+0xbe>
+ 80028dc: 2000 movs r0, #0
+ exp: exp - 2, inclusive: even })
+ 80028de: f2ac 4b35 subw fp, ip, #1077 ; 0x435
+ 80028e2: f04f 0a00 mov.w sl, #0
+ 80028e6: f04f 0c02 mov.w ip, #2
+ 80028ea: f44f 0680 mov.w r6, #4194304 ; 0x400000
+ if mant == minnorm.0 {
+ 80028ee: 900a str r0, [sp, #40] ; 0x28
+ 80028f0: e00a b.n 8002908 <core::fmt::float::float_to_decimal_common_exact+0xd4>
+ FullDecoded::Finite(Decoded { mant: mant << 1, minus: 1, plus: 1,
+ 80028f2: 0070 lsls r0, r6, #1
+ exp: exp - 1, inclusive: even })
+ 80028f4: f2ac 4b34 subw fp, ip, #1076 ; 0x434
+ FullDecoded::Finite(Decoded { mant: mant << 1, minus: 1, plus: 1,
+ 80028f8: ea40 76da orr.w r6, r0, sl, lsr #31
+ 80028fc: ea4f 0a4a mov.w sl, sl, lsl #1
+ 8002900: 2000 movs r0, #0
+ 8002902: 900a str r0, [sp, #40] ; 0x28
+ 8002904: f04f 0c01 mov.w ip, #1
+ 8002908: 0fe8 lsrs r0, r5, #31
+ 800290a: 2403 movs r4, #3
+ (_, Sign::Minus) | (_, Sign::MinusRaw) => if negative { b"-" } else { b"" },
+ 800290c: f244 4398 movw r3, #17560 ; 0x4498
+ 8002910: f644 25b0 movw r5, #19120 ; 0x4ab0
+ 8002914: b2c9 uxtb r1, r1
+ 8002916: f644 2eaf movw lr, #19119 ; 0x4aaf
+ 800291a: f6c0 0300 movt r3, #2048 ; 0x800
+ 800291e: f6c0 0500 movt r5, #2048 ; 0x800
+ 8002922: 2902 cmp r1, #2
+ 8002924: f6c0 0e00 movt lr, #2048 ; 0x800
+ 8002928: bf38 it cc
+ 800292a: 461d movcc r5, r3
+ 800292c: 2800 cmp r0, #0
+ 800292e: f04f 0300 mov.w r3, #0
+ 8002932: bf08 it eq
+ 8002934: 46ae moveq lr, r5
+ 8002936: 2901 cmp r1, #1
+ 8002938: bf88 it hi
+ 800293a: 2301 movhi r3, #1
+ 800293c: 4318 orrs r0, r3
+ let sign = determine_sign(sign, &full_decoded, negative);
+ match full_decoded {
+ FullDecoded::Nan => {
+ 800293e: 900c str r0, [sp, #48] ; 0x30
+ 8002940: f004 0003 and.w r0, r4, #3
+ 8002944: 2801 cmp r0, #1
+ 8002946: d10e bne.n 8002966 <core::fmt::float::float_to_decimal_common_exact+0x132>
+ parts[0] = Part::Copy(b"NaN");
+ Formatted { sign: sign, parts: &parts[..1] }
+ }
+ FullDecoded::Infinite => {
+ parts[0] = Part::Copy(b"inf");
+ 8002948: 2002 movs r0, #2
+ 800294a: f827 0cc4 strh.w r0, [r7, #-196]
+ 800294e: f644 306b movw r0, #19307 ; 0x4b6b
+ 8002952: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002956: f847 0cc0 str.w r0, [r7, #-192]
+ 800295a: 2003 movs r0, #3
+ 800295c: f847 0cbc str.w r0, [r7, #-188]
+/// ```
+#[inline]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub unsafe fn from_raw_parts<'a, T>(p: *const T, len: usize) -> &'a [T] {
+ mem::transmute(Repr { data: p, len: len })
+}
+ 8002960: 2001 movs r0, #1
+ 8002962: f000 bfe0 b.w 8003926 <core::fmt::float::float_to_decimal_common_exact+0x10f2>
+ 21 + ((if exp < 0 { -12 } else { 5 } * exp as i32) as usize >> 4)
+ 8002966: fa0f f38b sxth.w r3, fp
+ 800296a: 2005 movs r0, #5
+ 800296c: f8cd c010 str.w ip, [sp, #16]
+ 8002970: 2115 movs r1, #21
+ 8002972: 2b00 cmp r3, #0
+ 8002974: bfb8 it lt
+ 8002976: f06f 000b mvnlt.w r0, #11
+ 800297a: 4358 muls r0, r3
+ 800297c: eb01 1110 add.w r1, r1, r0, lsr #4
+ 8002980: 4608 mov r0, r1
+ Formatted { sign: sign, parts: &parts[..1] }
+ }
+ }
+ FullDecoded::Finite(ref decoded) => {
+ let maxlen = estimate_max_buf_len(decoded.exp);
+ assert!(buf.len() >= maxlen);
+ 8002982: f5b1 6f80 cmp.w r1, #1024 ; 0x400
+ 8002986: 9015 str r0, [sp, #84] ; 0x54
+ 8002988: f201 802f bhi.w 80039ea <core::fmt::float::float_to_decimal_common_exact+0x11b6>
+
+ // it *is* possible that `frac_digits` is ridiculously large.
+ // `format_exact` will end rendering digits much earlier in this case,
+ // because we are strictly limited by `maxlen`.
+ let limit = if frac_digits < 0x8000 { -(frac_digits as i16) } else { i16::MIN };
+ 800298c: f248 0c00 movw ip, #32768 ; 0x8000
+ 8002990: f5b2 4f00 cmp.w r2, #32768 ; 0x8000
+ 8002994: f6cf 7cff movt ip, #65535 ; 0xffff
+ 8002998: bf38 it cc
+ 800299a: f1c2 0c00 rsbcc ip, r2, #0
+/// The exact and fixed mode implementation for Grisu.
+///
+/// It returns `None` when it would return an inexact representation otherwise.
+pub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16)
+ -> Option<(/*#digits*/ usize, /*exp*/ i16)> {
+ assert!(d.mant > 0);
+ 800299e: ea5a 0006 orrs.w r0, sl, r6
+ 80029a2: f001 8028 beq.w 80039f6 <core::fmt::float::float_to_decimal_common_exact+0x11c2>
+ assert!(d.mant < (1 << 61)); // we need at least three bits of additional precision
+ 80029a6: f1b6 5f00 cmp.w r6, #536870912 ; 0x20000000
+ 80029aa: 9301 str r3, [sp, #4]
+ 80029ac: f8cd e01c str.w lr, [sp, #28]
+ 80029b0: f081 8027 bcs.w 8003a02 <core::fmt::float::float_to_decimal_common_exact+0x11ce>
+ 80029b4: e9cd 2902 strd r2, r9, [sp, #8]
+ if f >> (64 - 32) == 0 {
+ 80029b8: 2e00 cmp r6, #0
+ 80029ba: 46b6 mov lr, r6
+ 80029bc: 4632 mov r2, r6
+ 80029be: bf0c ite eq
+ 80029c0: 46d6 moveq lr, sl
+ 80029c2: 4652 movne r2, sl
+ if f >> (64 - 16) == 0 {
+ 80029c4: f5be 3f80 cmp.w lr, #65536 ; 0x10000
+ 80029c8: 4613 mov r3, r2
+ f <<= 16;
+ 80029ca: ea4f 450e mov.w r5, lr, lsl #16
+ if f >> (64 - 16) == 0 {
+ 80029ce: 46f0 mov r8, lr
+ 80029d0: bf38 it cc
+ 80029d2: 041b lslcc r3, r3, #16
+ 80029d4: bf38 it cc
+ 80029d6: ea45 4812 orrcc.w r8, r5, r2, lsr #16
+ if f >> (64 - 8) == 0 {
+ 80029da: f1b8 7f80 cmp.w r8, #16777216 ; 0x1000000
+ 80029de: 461d mov r5, r3
+ f <<= 8;
+ 80029e0: ea4f 2208 mov.w r2, r8, lsl #8
+ if f >> (64 - 8) == 0 {
+ 80029e4: 4641 mov r1, r8
+ 80029e6: bf38 it cc
+ 80029e8: 022d lslcc r5, r5, #8
+ 80029ea: bf38 it cc
+ 80029ec: ea42 6113 orrcc.w r1, r2, r3, lsr #24
+ if f >> (64 - 4) == 0 {
+ 80029f0: f1b1 5f80 cmp.w r1, #268435456 ; 0x10000000
+ 80029f4: 462a mov r2, r5
+ f <<= 4;
+ 80029f6: ea4f 1301 mov.w r3, r1, lsl #4
+ if f >> (64 - 4) == 0 {
+ 80029fa: 4608 mov r0, r1
+ 80029fc: bf38 it cc
+ 80029fe: 0112 lslcc r2, r2, #4
+ 8002a00: bf38 it cc
+ 8002a02: ea43 7015 orrcc.w r0, r3, r5, lsr #28
+ f <<= 2;
+ 8002a06: 0083 lsls r3, r0, #2
+ if f >> (64 - 2) == 0 {
+ 8002a08: f1b0 4f80 cmp.w r0, #1073741824 ; 0x40000000
+ 8002a0c: 4605 mov r5, r0
+ 8002a0e: bf3c itt cc
+ 8002a10: ea43 7592 orrcc.w r5, r3, r2, lsr #30
+ 8002a14: 0092 lslcc r2, r2, #2
+ if f >> (64 - 32) == 0 {
+ 8002a16: 2e00 cmp r6, #0
+ 8002a18: 465b mov r3, fp
+ 8002a1a: f8cd b018 str.w fp, [sp, #24]
+ 8002a1e: bf08 it eq
+ 8002a20: 3b20 subeq r3, #32
+ if f >> (64 - 16) == 0 {
+ 8002a22: f5be 3f80 cmp.w lr, #65536 ; 0x10000
+ 8002a26: bf38 it cc
+ 8002a28: 3b10 subcc r3, #16
+ if f >> (64 - 8) == 0 {
+ 8002a2a: f1b8 7f80 cmp.w r8, #16777216 ; 0x1000000
+ 8002a2e: bf38 it cc
+ 8002a30: 3b08 subcc r3, #8
+ if f >> (64 - 4) == 0 {
+ 8002a32: f1b1 5f80 cmp.w r1, #268435456 ; 0x10000000
+ let idx = ((gamma as i32) - offset) * range / domain;
+ 8002a36: f245 31b0 movw r1, #21424 ; 0x53b0
+ 8002a3a: bf38 it cc
+ 8002a3c: 3b04 subcc r3, #4
+ if f >> (64 - 2) == 0 {
+ 8002a3e: f1b0 4f80 cmp.w r0, #1073741824 ; 0x40000000
+ if f >> (64 - 1) == 0 {
+ 8002a42: ea6f 70e5 mvn.w r0, r5, asr #31
+ 8002a46: f2c0 0101 movt r1, #1
+ if f >> (64 - 2) == 0 {
+ 8002a4a: bf38 it cc
+ 8002a4c: 3b02 subcc r3, #2
+ if f >> (64 - 1) == 0 {
+ 8002a4e: eb03 0e00 add.w lr, r3, r0
+ 8002a52: f04f 30ff mov.w r0, #4294967295 ; 0xffffffff
+ assert!(!buf.is_empty());
+
+ // normalize and scale `v`.
+ let v = Fp { f: d.mant, e: d.exp }.normalize();
+ let (minusk, cached) = cached_power(ALPHA - v.e - 64, GAMMA - v.e - 64);
+ 8002a56: 385f subs r0, #95 ; 0x5f
+ 8002a58: eba0 000e sub.w r0, r0, lr
+ let idx = ((gamma as i32) - offset) * range / domain;
+ 8002a5c: b200 sxth r0, r0
+ 8002a5e: eb00 0080 add.w r0, r0, r0, lsl #2
+ 8002a62: eb01 1000 add.w r0, r1, r0, lsl #4
+ 8002a66: f64c 1193 movw r1, #51603 ; 0xc993
+ 8002a6a: f6c7 314d movt r1, #31565 ; 0x7b4d
+ 8002a6e: fb50 f001 smmul r0, r0, r1
+ 8002a72: 1281 asrs r1, r0, #10
+ 8002a74: eb01 70d0 add.w r0, r1, r0, lsr #31
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 8002a78: 2851 cmp r0, #81 ; 0x51
+ 8002a7a: f080 87c8 bcs.w 8003a0e <core::fmt::float::float_to_decimal_common_exact+0x11da>
+ 8002a7e: fa0f f18c sxth.w r1, ip
+ 8002a82: f643 58c0 movw r8, #15808 ; 0x3dc0
+ 8002a86: 0853 lsrs r3, r2, #1
+ 8002a88: f04f 0c01 mov.w ip, #1
+ 8002a8c: 910b str r1, [sp, #44] ; 0x2c
+ 8002a8e: 211e movs r1, #30
+ 8002a90: f6c0 0800 movt r8, #2048 ; 0x800
+ 8002a94: ea41 71d5 orr.w r1, r1, r5, lsr #31
+ 8002a98: eb08 1b00 add.w fp, r8, r0, lsl #4
+ 8002a9c: 0100 lsls r0, r0, #4
+ 8002a9e: fa23 f101 lsr.w r1, r3, r1
+ 8002aa2: ea8c 73d5 eor.w r3, ip, r5, lsr #31
+ 8002aa6: f858 0000 ldr.w r0, [r8, r0]
+ 8002aaa: 409d lsls r5, r3
+ 8002aac: fa02 f303 lsl.w r3, r2, r3
+ 8002ab0: ea45 0401 orr.w r4, r5, r1
+ 8002ab4: f8db 5004 ldr.w r5, [fp, #4]
+ let ad = a * d;
+ 8002ab8: fba0 8104 umull r8, r1, r0, r4
+ let bc = b * c;
+ 8002abc: fba5 9203 umull r9, r2, r5, r3
+ let bd = b * d;
+ 8002ac0: fba0 0303 umull r0, r3, r0, r3
+ 8002ac4: 2000 movs r0, #0
+ let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
+ 8002ac6: eb13 0308 adds.w r3, r3, r8
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 8002aca: fbe5 1264 umaal r1, r2, r5, r4
+ let v = v.mul(&cached);
+
+ // divide `v` into integral and fractional parts.
+ let e = -v.e as usize;
+ 8002ace: f06f 053f mvn.w r5, #63 ; 0x3f
+ let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;
+ 8002ad2: f140 0000 adc.w r0, r0, #0
+ 8002ad6: eb13 0309 adds.w r3, r3, r9
+ 8002ada: f140 0000 adc.w r0, r0, #0
+ 8002ade: f113 4300 adds.w r3, r3, #2147483648 ; 0x80000000
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 8002ae2: f8bb 3008 ldrh.w r3, [fp, #8]
+ 8002ae6: f140 0000 adc.w r0, r0, #0
+ let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+ 8002aea: 1840 adds r0, r0, r1
+ 8002aec: f142 0100 adc.w r1, r2, #0
+ let e = self.e + other.e + 64;
+ 8002af0: 4473 add r3, lr
+ let e = -v.e as usize;
+ 8002af2: 1aeb subs r3, r5, r3
+ 8002af4: fa0f f983 sxth.w r9, r3
+ let vint = (v.f >> e) as u32;
+ 8002af8: f009 043f and.w r4, r9, #63 ; 0x3f
+ 8002afc: f1c4 0320 rsb r3, r4, #32
+ 8002b00: fa20 f504 lsr.w r5, r0, r4
+ 8002b04: fa01 f203 lsl.w r2, r1, r3
+ let vfrac = v.f & ((1 << e) - 1);
+ 8002b08: fa2c fe03 lsr.w lr, ip, r3
+ let vint = (v.f >> e) as u32;
+ 8002b0c: 4315 orrs r5, r2
+ 8002b0e: f1a4 0220 sub.w r2, r4, #32
+ 8002b12: 2a00 cmp r2, #0
+ 8002b14: bfa8 it ge
+ 8002b16: fa21 f502 lsrge.w r5, r1, r2
+ 8002b1a: 9311 str r3, [sp, #68] ; 0x44
+ let vfrac = v.f & ((1 << e) - 1);
+ 8002b1c: bfa8 it ge
+ 8002b1e: fa0c fe02 lslge.w lr, ip, r2
+ 8002b22: fa0c f304 lsl.w r3, ip, r4
+ 8002b26: 2a00 cmp r2, #0
+ 8002b28: 9413 str r4, [sp, #76] ; 0x4c
+ 8002b2a: 9212 str r2, [sp, #72] ; 0x48
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 8002b2c: f8bb c00a ldrh.w ip, [fp, #10]
+ let vfrac = v.f & ((1 << e) - 1);
+ 8002b30: f8cd e020 str.w lr, [sp, #32]
+ 8002b34: bfa8 it ge
+ 8002b36: 2300 movge r3, #0
+ if x < X4 {
+ 8002b38: f8cd 9038 str.w r9, [sp, #56] ; 0x38
+ let vfrac = v.f & ((1 << e) - 1);
+ 8002b3c: 1e5a subs r2, r3, #1
+ 8002b3e: 9305 str r3, [sp, #20]
+ 8002b40: 9210 str r2, [sp, #64] ; 0x40
+ 8002b42: f16e 0200 sbc.w r2, lr, #0
+ if x < X4 {
+ 8002b46: 920f str r2, [sp, #60] ; 0x3c
+ 8002b48: f242 720f movw r2, #9999 ; 0x270f
+ 8002b4c: 4295 cmp r5, r2
+ 8002b4e: d810 bhi.n 8002b72 <core::fmt::float::float_to_decimal_common_exact+0x33e>
+ 8002b50: f8dd b028 ldr.w fp, [sp, #40] ; 0x28
+ if x < X2 { if x < X1 {(0, 1)} else {(1, X1)} }
+ 8002b54: 2d64 cmp r5, #100 ; 0x64
+ 8002b56: d26c bcs.n 8002c32 <core::fmt::float::float_to_decimal_common_exact+0x3fe>
+ 8002b58: f04f 080a mov.w r8, #10
+ 8002b5c: 2d0a cmp r5, #10
+ 8002b5e: f04f 0300 mov.w r3, #0
+ 8002b62: bf38 it cc
+ 8002b64: f04f 0801 movcc.w r8, #1
+ 8002b68: 2d09 cmp r5, #9
+ 8002b6a: bf88 it hi
+ 8002b6c: 2301 movhi r3, #1
+ 8002b6e: 9c06 ldr r4, [sp, #24]
+ 8002b70: e08a b.n 8002c88 <core::fmt::float::float_to_decimal_common_exact+0x454>
+ 8002b72: f8dd b028 ldr.w fp, [sp, #40] ; 0x28
+ 8002b76: f244 2840 movw r8, #16960 ; 0x4240
+ 8002b7a: f2c0 080f movt r8, #15
+ if x < X6 { if x < X5 {(4, X4)} else {(5, X5)} }
+ 8002b7e: 4545 cmp r5, r8
+ 8002b80: d264 bcs.n 8002c4c <core::fmt::float::float_to_decimal_common_exact+0x418>
+ 8002b82: f248 68a0 movw r8, #34464 ; 0x86a0
+ 8002b86: 2305 movs r3, #5
+ 8002b88: f2c0 0801 movt r8, #1
+ 8002b8c: 4545 cmp r5, r8
+ 8002b8e: bf3c itt cc
+ 8002b90: 2304 movcc r3, #4
+ 8002b92: f242 7810 movwcc r8, #10000 ; 0x2710
+ 8002b96: 9c06 ldr r4, [sp, #24]
+ 8002b98: e076 b.n 8002c88 <core::fmt::float::float_to_decimal_common_exact+0x454>
+ 8002b9a: 2300 movs r3, #0
+ 8002b9c: e014 b.n 8002bc8 <core::fmt::float::float_to_decimal_common_exact+0x394>
+ (FullDecoded::Zero, Sign::MinusRaw) => if negative { b"-" } else { b"" },
+ 8002b9e: f644 20af movw r0, #19119 ; 0x4aaf
+ 8002ba2: 2d00 cmp r5, #0
+ let (negative, full_decoded) = decode(v);
+ 8002ba4: ea4f 73d5 mov.w r3, r5, lsr #31
+ (FullDecoded::Zero, Sign::MinusRaw) => if negative { b"-" } else { b"" },
+ 8002ba8: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002bac: e00a b.n 8002bc4 <core::fmt::float::float_to_decimal_common_exact+0x390>
+ (FullDecoded::Zero, Sign::MinusPlusRaw) => if negative { b"-" } else { b"+" },
+ 8002bae: f644 20af movw r0, #19119 ; 0x4aaf
+ 8002bb2: f644 2eb0 movw lr, #19120 ; 0x4ab0
+ 8002bb6: 2d00 cmp r5, #0
+ 8002bb8: f04f 0301 mov.w r3, #1
+ 8002bbc: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002bc0: f6c0 0e00 movt lr, #2048 ; 0x800
+ 8002bc4: bfb8 it lt
+ 8002bc6: 4686 movlt lr, r0
+ 8002bc8: 2002 movs r0, #2
+ if frac_digits > 0 { // [0.][0000]
+ 8002bca: 2a00 cmp r2, #0
+ 8002bcc: f827 0cc4 strh.w r0, [r7, #-196]
+ 8002bd0: d00c beq.n 8002bec <core::fmt::float::float_to_decimal_common_exact+0x3b8>
+ parts[0] = Part::Copy(b"0.");
+ 8002bd2: f644 2184 movw r1, #19076 ; 0x4a84
+ 8002bd6: f6c0 0100 movt r1, #2048 ; 0x800
+ 8002bda: e947 1030 strd r1, r0, [r7, #-192] ; 0xc0
+ parts[1] = Part::Zero(frac_digits);
+ 8002bde: 2100 movs r1, #0
+ 8002be0: f827 1cb8 strh.w r1, [r7, #-184]
+ 8002be4: f847 2cb4 str.w r2, [r7, #-180]
+ 8002be8: f000 be9e b.w 8003928 <core::fmt::float::float_to_decimal_common_exact+0x10f4>
+ parts[0] = Part::Copy(b"0");
+ 8002bec: f644 306e movw r0, #19310 ; 0x4b6e
+ 8002bf0: f1a7 01c4 sub.w r1, r7, #196 ; 0xc4
+ 8002bf4: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002bf8: f847 0cc0 str.w r0, [r7, #-192]
+ 8002bfc: 2001 movs r0, #1
+ 8002bfe: f847 0cbc str.w r0, [r7, #-188]
+ 8002c02: f000 be93 b.w 800392c <core::fmt::float::float_to_decimal_common_exact+0x10f8>
+ parts[0] = Part::Copy(b"NaN");
+ 8002c06: 2002 movs r0, #2
+ 8002c08: f244 4e98 movw lr, #17560 ; 0x4498
+ 8002c0c: f1a7 01c4 sub.w r1, r7, #196 ; 0xc4
+ 8002c10: 2300 movs r3, #0
+ 8002c12: f827 0cc4 strh.w r0, [r7, #-196]
+ 8002c16: f644 3068 movw r0, #19304 ; 0x4b68
+ 8002c1a: f6c0 0e00 movt lr, #2048 ; 0x800
+ 8002c1e: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002c22: f847 0cc0 str.w r0, [r7, #-192]
+ 8002c26: 2003 movs r0, #3
+ 8002c28: f847 0cbc str.w r0, [r7, #-188]
+ 8002c2c: 2001 movs r0, #1
+ 8002c2e: f000 be7d b.w 800392c <core::fmt::float::float_to_decimal_common_exact+0x10f8>
+ else { if x < X3 {(2, X2)} else {(3, X3)} }
+ 8002c32: f44f 787a mov.w r8, #1000 ; 0x3e8
+ 8002c36: f5b5 7f7a cmp.w r5, #1000 ; 0x3e8
+ 8002c3a: f04f 0303 mov.w r3, #3
+ 8002c3e: bf38 it cc
+ 8002c40: f04f 0864 movcc.w r8, #100 ; 0x64
+ 8002c44: bf38 it cc
+ 8002c46: 2302 movcc r3, #2
+ 8002c48: 9c06 ldr r4, [sp, #24]
+ 8002c4a: e01d b.n 8002c88 <core::fmt::float::float_to_decimal_common_exact+0x454>
+ 8002c4c: 9c06 ldr r4, [sp, #24]
+ 8002c4e: f24e 1200 movw r2, #57600 ; 0xe100
+ 8002c52: f2c0 52f5 movt r2, #1525 ; 0x5f5
+ else if x < X8 { if x < X7 {(6, X6)} else {(7, X7)} }
+ 8002c56: 4295 cmp r5, r2
+ 8002c58: d20a bcs.n 8002c70 <core::fmt::float::float_to_decimal_common_exact+0x43c>
+ 8002c5a: f249 6280 movw r2, #38528 ; 0x9680
+ 8002c5e: 2307 movs r3, #7
+ 8002c60: f2c0 0298 movt r2, #152 ; 0x98
+ 8002c64: 4295 cmp r5, r2
+ 8002c66: bf28 it cs
+ 8002c68: 4690 movcs r8, r2
+ 8002c6a: bf38 it cc
+ 8002c6c: 2306 movcc r3, #6
+ 8002c6e: e00b b.n 8002c88 <core::fmt::float::float_to_decimal_common_exact+0x454>
+ else { if x < X9 {(8, X8)} else {(9, X9)} }
+ 8002c70: f64c 2300 movw r3, #51712 ; 0xca00
+ 8002c74: f6c3 339a movt r3, #15258 ; 0x3b9a
+ 8002c78: 429d cmp r5, r3
+ 8002c7a: bf28 it cs
+ 8002c7c: 461a movcs r2, r3
+ 8002c7e: f04f 0309 mov.w r3, #9
+ 8002c82: bf38 it cc
+ 8002c84: 2308 movcc r3, #8
+ 8002c86: 4690 mov r8, r2
+ // calculate the largest `10^max_kappa` no more than `v` (thus `v < 10^(max_kappa+1)`).
+ // this is an upper bound of `kappa` below.
+ let (max_kappa, max_ten_kappa) = max_pow10_no_more_than(vint);
+
+ let mut i = 0;
+ let exp = max_kappa as i16 - minusk + 1;
+ 8002c88: fa5f f983 uxtb.w r9, r3
+ 8002c8c: eba9 020c sub.w r2, r9, ip
+ 8002c90: 9200 str r2, [sp, #0]
+ 8002c92: 3201 adds r2, #1
+ 8002c94: b213 sxth r3, r2
+ 8002c96: 9a0b ldr r2, [sp, #44] ; 0x2c
+
+ // if we are working with the last-digit limitation, we need to shorten the buffer
+ // before the actual rendering in order to avoid double rounding.
+ // note that we have to enlarge the buffer again when rounding up happens!
+ let len = if exp <= limit {
+ 8002c98: 9309 str r3, [sp, #36] ; 0x24
+ 8002c9a: 4293 cmp r3, r2
+ 8002c9c: dd30 ble.n 8002d00 <core::fmt::float::float_to_decimal_common_exact+0x4cc>
+ let vfrac = v.f & ((1 << e) - 1);
+ 8002c9e: 9c10 ldr r4, [sp, #64] ; 0x40
+ 8002ca0: f64c 4ccd movw ip, #52429 ; 0xcccd
+ 8002ca4: f10d 0b5c add.w fp, sp, #92 ; 0x5c
+ 8002ca8: f6cc 4ccc movt ip, #52428 ; 0xcccc
+ 8002cac: 4020 ands r0, r4
+ 8002cae: 9016 str r0, [sp, #88] ; 0x58
+ 8002cb0: 980f ldr r0, [sp, #60] ; 0x3c
+ 8002cb2: ea01 0e00 and.w lr, r1, r0
+ 8002cb6: 9915 ldr r1, [sp, #84] ; 0x54
+ // but scaling `max_ten_kappa << e` by 10 can result in overflow.
+ // thus we are being sloppy here and widen the error range by a factor of 10.
+ // this will increase the false negative rate, but only very, *very* slightly;
+ // it can only matter noticeably when the mantissa is bigger than 60 bits.
+ return possibly_round(buf, 0, exp, limit, v.f / 10, (max_ten_kappa as u64) << e, err << e);
+ } else if ((exp as i32 - limit as i32) as usize) < buf.len() {
+ 8002cb8: 1a98 subs r0, r3, r2
+ 8002cba: 4288 cmp r0, r1
+ 8002cbc: 460c mov r4, r1
+ 8002cbe: bf38 it cc
+ 8002cc0: b204 sxthcc r4, r0
+ 8002cc2: 2001 movs r0, #1
+ // - `vint = d[0..n-1] * 10^(kappa+1) + remainder`
+ // (it follows that `remainder = vint % 10^(kappa+1)`)
+
+ // divide `remainder` by `10^kappa`. both are scaled by `2^-e`.
+ let q = remainder / ten_kappa;
+ let r = remainder % ten_kappa;
+ 8002cc4: fbb5 f2f8 udiv r2, r5, r8
+ debug_assert!(q < 10);
+ buf[i] = b'0' + q as u8;
+ 8002cc8: eb0b 0100 add.w r1, fp, r0
+ i += 1;
+
+ // is the buffer full? run the rounding pass with the remainder.
+ if i == len {
+ 8002ccc: 4284 cmp r4, r0
+ buf[i] = b'0' + q as u8;
+ 8002cce: f102 0330 add.w r3, r2, #48 ; 0x30
+ let r = remainder % ten_kappa;
+ 8002cd2: fb02 5518 mls r5, r2, r8, r5
+ buf[i] = b'0' + q as u8;
+ 8002cd6: f801 3c01 strb.w r3, [r1, #-1]
+ 8002cda: d07b beq.n 8002dd4 <core::fmt::float::float_to_decimal_common_exact+0x5a0>
+ return possibly_round(buf, len, exp, limit, vrem, (ten_kappa as u64) << e, err << e);
+ }
+
+ // break the loop when we have rendered all integral digits.
+ // the exact number of digits is `max_kappa + 1` as `plus1 < 10^(max_kappa+1)`.
+ if i > max_kappa as usize {
+ 8002cdc: 4548 cmp r0, r9
+ 8002cde: f200 80fc bhi.w 8002eda <core::fmt::float::float_to_decimal_common_exact+0x6a6>
+ break;
+ }
+
+ // restore invariants
+ kappa -= 1;
+ ten_kappa /= 10;
+ 8002ce2: fba8 120c umull r1, r2, r8, ip
+ let q = remainder / ten_kappa;
+ 8002ce6: 3001 adds r0, #1
+ 8002ce8: f1b8 0f0a cmp.w r8, #10
+ ten_kappa /= 10;
+ 8002cec: ea4f 01d2 mov.w r1, r2, lsr #3
+ 8002cf0: 4688 mov r8, r1
+ 8002cf2: d2e7 bcs.n 8002cc4 <core::fmt::float::float_to_decimal_common_exact+0x490>
+ let q = remainder / ten_kappa;
+ 8002cf4: f644 10e0 movw r0, #18912 ; 0x49e0
+ 8002cf8: f6c0 0000 movt r0, #2048 ; 0x800
+ 8002cfc: f7fd fef9 bl 8000af2 <core::panicking::panic>
+ return possibly_round(buf, 0, exp, limit, v.f / 10, (max_ten_kappa as u64) << e, err << e);
+ 8002d00: 220a movs r2, #10
+ 8002d02: 2300 movs r3, #0
+ 8002d04: 46a1 mov r9, r4
+ 8002d06: f000 fed9 bl 8003abc <__aeabi_uldivmod>
+ 8002d0a: 9a11 ldr r2, [sp, #68] ; 0x44
+ 8002d0c: 9b12 ldr r3, [sp, #72] ; 0x48
+ 8002d0e: fa28 f202 lsr.w r2, r8, r2
+ 8002d12: 2b00 cmp r3, #0
+ 8002d14: bfa8 it ge
+ 8002d16: fa08 f203 lslge.w r2, r8, r3
+ 8002d1a: 9b13 ldr r3, [sp, #76] ; 0x4c
+ 8002d1c: fa08 f303 lsl.w r3, r8, r3
+ 8002d20: bfa8 it ge
+ 8002d22: 2300 movge r3, #0
+ 8002d24: 9c05 ldr r4, [sp, #20]
+ 8002d26: f8dd 8020 ldr.w r8, [sp, #32]
+ // v - 1 ulp v + 1 ulp
+ //
+ // in fact, 1/2 ulp is enough to introduce two possible representations.
+ // (remember that we need a unique representation for both `v - 1 ulp` and `v + 1 ulp`.)
+ // this won't overflow, as `ulp < ten_kappa` from the first check.
+ if ten_kappa - ulp <= ulp { return None; }
+ 8002d2a: ebb3 0e04 subs.w lr, r3, r4
+ 8002d2e: eb62 0c08 sbc.w ip, r2, r8
+ if ulp >= ten_kappa { return None; }
+ 8002d32: 1ae5 subs r5, r4, r3
+ 8002d34: eb78 0502 sbcs.w r5, r8, r2
+ 8002d38: f080 8164 bcs.w 8003004 <core::fmt::float::float_to_decimal_common_exact+0x7d0>
+ 8002d3c: ebb4 050e subs.w r5, r4, lr
+ 8002d40: eb78 050c sbcs.w r5, r8, ip
+ 8002d44: f080 815e bcs.w 8003004 <core::fmt::float::float_to_decimal_common_exact+0x7d0>
+ //
+ // the condition equals to `remainder + ulp < 10^kappa / 2`.
+ // since this can easily overflow, first check if `remainder < 10^kappa / 2`.
+ // we've already verified that `ulp < 10^kappa / 2`, so as long as
+ // `10^kappa` did not overflow after all, the second check is fine.
+ if ten_kappa - remainder > remainder && ten_kappa - 2 * remainder >= 2 * ulp {
+ 8002d48: 1a1d subs r5, r3, r0
+ 8002d4a: eb62 0c01 sbc.w ip, r2, r1
+ 8002d4e: 1b45 subs r5, r0, r5
+ 8002d50: eb71 050c sbcs.w r5, r1, ip
+ 8002d54: d210 bcs.n 8002d78 <core::fmt::float::float_to_decimal_common_exact+0x544>
+ 8002d56: 004d lsls r5, r1, #1
+ 8002d58: ebb3 0c40 subs.w ip, r3, r0, lsl #1
+ 8002d5c: ea45 75d0 orr.w r5, r5, r0, lsr #31
+ 8002d60: eb62 0e05 sbc.w lr, r2, r5
+ 8002d64: 9d08 ldr r5, [sp, #32]
+ 8002d66: 006d lsls r5, r5, #1
+ 8002d68: ea45 78d4 orr.w r8, r5, r4, lsr #31
+ 8002d6c: ebbc 0544 subs.w r5, ip, r4, lsl #1
+ 8002d70: eb7e 0508 sbcs.w r5, lr, r8
+ 8002d74: f080 852c bcs.w 80037d0 <core::fmt::float::float_to_decimal_common_exact+0xf9c>
+ 8002d78: f8dd c020 ldr.w ip, [sp, #32]
+ //
+ // the condition equals to `remainder - ulp >= 10^kappa / 2`.
+ // again we first check if `remainder > ulp` (note that this is not `remainder >= ulp`,
+ // as `10^kappa` is never zero). also note that `remainder - ulp <= 10^kappa`,
+ // so the second check does not overflow.
+ if remainder > ulp && ten_kappa - (remainder - ulp) <= remainder - ulp {
+ 8002d7c: 1a25 subs r5, r4, r0
+ 8002d7e: eb7c 0501 sbcs.w r5, ip, r1
+ 8002d82: f080 813f bcs.w 8003004 <core::fmt::float::float_to_decimal_common_exact+0x7d0>
+ 8002d86: 1b00 subs r0, r0, r4
+ 8002d88: eb61 010c sbc.w r1, r1, ip
+ 8002d8c: 1a1b subs r3, r3, r0
+ 8002d8e: 418a sbcs r2, r1
+ 8002d90: 1ac0 subs r0, r0, r3
+ 8002d92: eb71 0002 sbcs.w r0, r1, r2
+ 8002d96: f0c0 8135 bcc.w 8003004 <core::fmt::float::float_to_decimal_common_exact+0x7d0>
+ if let Some(c) = round_up(buf, len) {
+ 8002d9a: 9915 ldr r1, [sp, #84] ; 0x54
+ 8002d9c: a817 add r0, sp, #92 ; 0x5c
+ 8002d9e: 2200 movs r2, #0
+ 8002da0: 2400 movs r4, #0
+ 8002da2: f7fd ff30 bl 8000c06 <core::num::flt2dec::round_up>
+ 8002da6: f3c0 2107 ubfx r1, r0, #8, #8
+ 8002daa: f8dd e01c ldr.w lr, [sp, #28]
+ 8002dae: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 8002db0: e9dd 8902 ldrd r8, r9, [sp, #8]
+ 8002db4: b2c0 uxtb r0, r0
+ 8002db6: 2801 cmp r0, #1
+ 8002db8: f040 8522 bne.w 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ // only add an additional digit when we've been requested the fixed precision.
+ // we also need to check that, if the original buffer was empty,
+ // the additional digit can only be added when `exp == limit` (edge case).
+ exp += 1;
+ 8002dbc: 9800 ldr r0, [sp, #0]
+ 8002dbe: 3002 adds r0, #2
+ 8002dc0: b200 sxth r0, r0
+ if exp > limit && len < buf.len() {
+ 8002dc2: 42b0 cmp r0, r6
+ 8002dc4: 9009 str r0, [sp, #36] ; 0x24
+ buf[len] = c;
+ 8002dc6: bfc6 itte gt
+ 8002dc8: f88d 105c strbgt.w r1, [sp, #92] ; 0x5c
+ 8002dcc: 2401 movgt r4, #1
+ 8002dce: 2400 movle r4, #0
+ 8002dd0: f000 bd16 b.w 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 8002dd4: 46a3 mov fp, r4
+ 8002dd6: 9c11 ldr r4, [sp, #68] ; 0x44
+ 8002dd8: 9b12 ldr r3, [sp, #72] ; 0x48
+ let vrem = ((r as u64) << e) + vfrac; // == (v % 10^kappa) * 2^e
+ 8002dda: fa25 f004 lsr.w r0, r5, r4
+ 8002dde: 2b00 cmp r3, #0
+ 8002de0: bfa8 it ge
+ 8002de2: fa05 f003 lslge.w r0, r5, r3
+ 8002de6: 9a13 ldr r2, [sp, #76] ; 0x4c
+ 8002de8: fa05 f102 lsl.w r1, r5, r2
+ 8002dec: bfa8 it ge
+ 8002dee: 2100 movge r1, #0
+ 8002df0: 9d16 ldr r5, [sp, #88] ; 0x58
+ 8002df2: eb11 0905 adds.w r9, r1, r5
+ 8002df6: eb40 0c0e adc.w ip, r0, lr
+ return possibly_round(buf, len, exp, limit, vrem, (ten_kappa as u64) << e, err << e);
+ 8002dfa: fa28 f004 lsr.w r0, r8, r4
+ 8002dfe: 2b00 cmp r3, #0
+ 8002e00: bfa8 it ge
+ 8002e02: fa08 f003 lslge.w r0, r8, r3
+ 8002e06: fa08 f302 lsl.w r3, r8, r2
+ 8002e0a: bfa8 it ge
+ 8002e0c: 2300 movge r3, #0
+ 8002e0e: 9905 ldr r1, [sp, #20]
+ 8002e10: 9c08 ldr r4, [sp, #32]
+ if ten_kappa - ulp <= ulp { return None; }
+ 8002e12: 1a5d subs r5, r3, r1
+ 8002e14: eb60 0204 sbc.w r2, r0, r4
+ if ulp >= ten_kappa { return None; }
+ 8002e18: 1ac9 subs r1, r1, r3
+ 8002e1a: eb74 0100 sbcs.w r1, r4, r0
+ 8002e1e: f080 80e8 bcs.w 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002e22: 9905 ldr r1, [sp, #20]
+ 8002e24: 1b49 subs r1, r1, r5
+ 8002e26: 9908 ldr r1, [sp, #32]
+ 8002e28: 4191 sbcs r1, r2
+ 8002e2a: f080 80e2 bcs.w 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002e2e: f8dd e01c ldr.w lr, [sp, #28]
+ if ten_kappa - remainder > remainder && ten_kappa - 2 * remainder >= 2 * ulp {
+ 8002e32: ebb3 0109 subs.w r1, r3, r9
+ 8002e36: eb60 020c sbc.w r2, r0, ip
+ 8002e3a: ebb9 0101 subs.w r1, r9, r1
+ 8002e3e: eb7c 0102 sbcs.w r1, ip, r2
+ 8002e42: d211 bcs.n 8002e68 <core::fmt::float::float_to_decimal_common_exact+0x634>
+ 8002e44: 9c08 ldr r4, [sp, #32]
+ 8002e46: ea4f 014c mov.w r1, ip, lsl #1
+ 8002e4a: ebb3 0249 subs.w r2, r3, r9, lsl #1
+ 8002e4e: ea41 71d9 orr.w r1, r1, r9, lsr #31
+ 8002e52: eb60 0101 sbc.w r1, r0, r1
+ 8002e56: 0065 lsls r5, r4, #1
+ 8002e58: 9c05 ldr r4, [sp, #20]
+ 8002e5a: ea45 75d4 orr.w r5, r5, r4, lsr #31
+ 8002e5e: ebb2 0244 subs.w r2, r2, r4, lsl #1
+ 8002e62: 41a9 sbcs r1, r5
+ 8002e64: f080 84bb bcs.w 80037de <core::fmt::float::float_to_decimal_common_exact+0xfaa>
+ if remainder > ulp && ten_kappa - (remainder - ulp) <= remainder - ulp {
+ 8002e68: 9905 ldr r1, [sp, #20]
+ 8002e6a: ebb1 0109 subs.w r1, r1, r9
+ 8002e6e: 9908 ldr r1, [sp, #32]
+ 8002e70: eb71 010c sbcs.w r1, r1, ip
+ 8002e74: f080 80bd bcs.w 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002e78: 9905 ldr r1, [sp, #20]
+ 8002e7a: 9a08 ldr r2, [sp, #32]
+ 8002e7c: ebb9 0101 subs.w r1, r9, r1
+ 8002e80: eb6c 0202 sbc.w r2, ip, r2
+ 8002e84: 1a5b subs r3, r3, r1
+ 8002e86: 4190 sbcs r0, r2
+ 8002e88: 1ac9 subs r1, r1, r3
+ 8002e8a: eb72 0000 sbcs.w r0, r2, r0
+ 8002e8e: f0c0 80b0 bcc.w 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002e92: f8dd a054 ldr.w sl, [sp, #84] ; 0x54
+ 8002e96: f10d 085c add.w r8, sp, #92 ; 0x5c
+ 8002e9a: 465c mov r4, fp
+ if let Some(c) = round_up(buf, len) {
+ 8002e9c: 4640 mov r0, r8
+ 8002e9e: 4622 mov r2, r4
+ 8002ea0: 4651 mov r1, sl
+ 8002ea2: f7fd feb0 bl 8000c06 <core::num::flt2dec::round_up>
+ 8002ea6: f3c0 2107 ubfx r1, r0, #8, #8
+ 8002eaa: b2c0 uxtb r0, r0
+ 8002eac: 2801 cmp r0, #1
+ 8002eae: f040 84a2 bne.w 80037f6 <core::fmt::float::float_to_decimal_common_exact+0xfc2>
+ exp += 1;
+ 8002eb2: 9800 ldr r0, [sp, #0]
+ 8002eb4: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 8002eb6: 3002 adds r0, #2
+ 8002eb8: b200 sxth r0, r0
+ 8002eba: 9009 str r0, [sp, #36] ; 0x24
+ if exp > limit && len < buf.len() {
+ 8002ebc: 42b0 cmp r0, r6
+ 8002ebe: e9dd 0902 ldrd r0, r9, [sp, #8]
+ 8002ec2: f8dd e01c ldr.w lr, [sp, #28]
+ 8002ec6: f340 856a ble.w 800399e <core::fmt::float::float_to_decimal_common_exact+0x116a>
+ 8002eca: 4554 cmp r4, sl
+ buf[len] = c;
+ 8002ecc: bf3c itt cc
+ 8002ece: f808 1004 strbcc.w r1, [r8, r4]
+ len += 1;
+ 8002ed2: 3401 addcc r4, #1
+ 8002ed4: 4680 mov r8, r0
+ 8002ed6: f000 bc93 b.w 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ let maxerr = 1 << (e - 1);
+ 8002eda: 990e ldr r1, [sp, #56] ; 0x38
+ 8002edc: f04f 0b01 mov.w fp, #1
+ 8002ee0: 9414 str r4, [sp, #80] ; 0x50
+ 8002ee2: 313f adds r1, #63 ; 0x3f
+ 8002ee4: f001 023f and.w r2, r1, #63 ; 0x3f
+ 8002ee8: f1a2 0320 sub.w r3, r2, #32
+ 8002eec: f1c2 0520 rsb r5, r2, #32
+ 8002ef0: fa2b f105 lsr.w r1, fp, r5
+ 8002ef4: 2b00 cmp r3, #0
+ 8002ef6: f04f 0500 mov.w r5, #0
+ 8002efa: bfa8 it ge
+ 8002efc: fa0b f103 lslge.w r1, fp, r3
+ 8002f00: 910e str r1, [sp, #56] ; 0x38
+ 8002f02: fa0b f102 lsl.w r1, fp, r2
+ 8002f06: bfa8 it ge
+ 8002f08: 2100 movge r1, #0
+ 8002f0a: 910d str r1, [sp, #52] ; 0x34
+ while err < maxerr {
+ 8002f0c: 990d ldr r1, [sp, #52] ; 0x34
+ 8002f0e: 465b mov r3, fp
+ 8002f10: 1a59 subs r1, r3, r1
+ 8002f12: 990e ldr r1, [sp, #56] ; 0x38
+ 8002f14: eb75 0101 sbcs.w r1, r5, r1
+ 8002f18: d26b bcs.n 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ buf[i] = b'0' + q as u8;
+ 8002f1a: 9915 ldr r1, [sp, #84] ; 0x54
+ 8002f1c: 4288 cmp r0, r1
+ 8002f1e: f080 8545 bcs.w 80039ac <core::fmt::float::float_to_decimal_common_exact+0x1178>
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8002f22: 9916 ldr r1, [sp, #88] ; 0x58
+ 8002f24: 240a movs r4, #10
+ err *= 10; // won't overflow, `err * 10 < 2^e * 5 < 2^64`
+ 8002f26: eb05 0985 add.w r9, r5, r5, lsl #2
+ 8002f2a: fba3 b804 umull fp, r8, r3, r4
+ 8002f2e: eb08 0549 add.w r5, r8, r9, lsl #1
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8002f32: fba1 2c04 umull r2, ip, r1, r4
+ let r = remainder & ((1 << e) - 1);
+ 8002f36: 9910 ldr r1, [sp, #64] ; 0x40
+ 8002f38: 9c0f ldr r4, [sp, #60] ; 0x3c
+ 8002f3a: 4011 ands r1, r2
+ err *= 10; // won't overflow, `err * 10 < 2^e * 5 < 2^64`
+ 8002f3c: 9116 str r1, [sp, #88] ; 0x58
+ remainder *= 10; // won't overflow, `2^e * 10 < 2^64`
+ 8002f3e: eb0e 018e add.w r1, lr, lr, lsl #2
+ 8002f42: eb0c 0141 add.w r1, ip, r1, lsl #1
+ let r = remainder & ((1 << e) - 1);
+ 8002f46: ea01 0e04 and.w lr, r1, r4
+ let q = remainder >> e;
+ 8002f4a: 9c13 ldr r4, [sp, #76] ; 0x4c
+ 8002f4c: 40e2 lsrs r2, r4
+ 8002f4e: 9c11 ldr r4, [sp, #68] ; 0x44
+ 8002f50: fa01 f404 lsl.w r4, r1, r4
+ 8002f54: 4322 orrs r2, r4
+ 8002f56: 9c12 ldr r4, [sp, #72] ; 0x48
+ 8002f58: 2c00 cmp r4, #0
+ 8002f5a: bfa8 it ge
+ 8002f5c: fa21 f204 lsrge.w r2, r1, r4
+ buf[i] = b'0' + q as u8;
+ 8002f60: f102 0130 add.w r1, r2, #48 ; 0x30
+ 8002f64: aa17 add r2, sp, #92 ; 0x5c
+ 8002f66: 5411 strb r1, [r2, r0]
+ if i == len {
+ 8002f68: 9914 ldr r1, [sp, #80] ; 0x50
+ i += 1;
+ 8002f6a: 3001 adds r0, #1
+ if i == len {
+ 8002f6c: 4281 cmp r1, r0
+ 8002f6e: d1cd bne.n 8002f0c <core::fmt::float::float_to_decimal_common_exact+0x6d8>
+ 8002f70: 9905 ldr r1, [sp, #20]
+ 8002f72: 9a08 ldr r2, [sp, #32]
+ if ten_kappa - ulp <= ulp { return None; }
+ 8002f74: ebb1 000b subs.w r0, r1, fp
+ 8002f78: eb62 0c05 sbc.w ip, r2, r5
+ if ulp >= ten_kappa { return None; }
+ 8002f7c: ebbb 0101 subs.w r1, fp, r1
+ 8002f80: eb75 0102 sbcs.w r1, r5, r2
+ 8002f84: d235 bcs.n 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002f86: ebbb 0000 subs.w r0, fp, r0
+ 8002f8a: eb75 000c sbcs.w r0, r5, ip
+ 8002f8e: d230 bcs.n 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002f90: 9c05 ldr r4, [sp, #20]
+ 8002f92: 9a08 ldr r2, [sp, #32]
+ 8002f94: 46f0 mov r8, lr
+ 8002f96: 46a4 mov ip, r4
+ 8002f98: 9c16 ldr r4, [sp, #88] ; 0x58
+ if ten_kappa - remainder > remainder && ten_kappa - 2 * remainder >= 2 * ulp {
+ 8002f9a: ebbc 0004 subs.w r0, ip, r4
+ 8002f9e: eb62 0108 sbc.w r1, r2, r8
+ 8002fa2: 1a20 subs r0, r4, r0
+ 8002fa4: eb78 0001 sbcs.w r0, r8, r1
+ 8002fa8: d210 bcs.n 8002fcc <core::fmt::float::float_to_decimal_common_exact+0x798>
+ 8002faa: ea4f 0048 mov.w r0, r8, lsl #1
+ 8002fae: ebbc 0144 subs.w r1, ip, r4, lsl #1
+ 8002fb2: ea40 70d4 orr.w r0, r0, r4, lsr #31
+ 8002fb6: eb62 0000 sbc.w r0, r2, r0
+ 8002fba: 2214 movs r2, #20
+ 8002fbc: fba3 2302 umull r2, r3, r3, r2
+ 8002fc0: eb03 0389 add.w r3, r3, r9, lsl #2
+ 8002fc4: 1a89 subs r1, r1, r2
+ 8002fc6: 4198 sbcs r0, r3
+ 8002fc8: f080 840e bcs.w 80037e8 <core::fmt::float::float_to_decimal_common_exact+0xfb4>
+ if remainder > ulp && ten_kappa - (remainder - ulp) <= remainder - ulp {
+ 8002fcc: ebbb 0004 subs.w r0, fp, r4
+ 8002fd0: eb75 0008 sbcs.w r0, r5, r8
+ 8002fd4: d20d bcs.n 8002ff2 <core::fmt::float::float_to_decimal_common_exact+0x7be>
+ 8002fd6: 9816 ldr r0, [sp, #88] ; 0x58
+ 8002fd8: 9a05 ldr r2, [sp, #20]
+ 8002fda: 9b08 ldr r3, [sp, #32]
+ 8002fdc: ebb0 000b subs.w r0, r0, fp
+ 8002fe0: eb6e 0105 sbc.w r1, lr, r5
+ 8002fe4: 1a12 subs r2, r2, r0
+ 8002fe6: 418b sbcs r3, r1
+ 8002fe8: 1a80 subs r0, r0, r2
+ 8002fea: eb71 0003 sbcs.w r0, r1, r3
+ 8002fee: f080 84b0 bcs.w 8003952 <core::fmt::float::float_to_decimal_common_exact+0x111e>
+ 8002ff2: f8dd b028 ldr.w fp, [sp, #40] ; 0x28
+
+/// The exact and fixed mode implementation for Dragon.
+pub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usize, /*exp*/ i16) {
+ assert!(d.mant > 0);
+ assert!(d.minus > 0);
+ assert!(d.plus > 0);
+ 8002ff6: 9804 ldr r0, [sp, #16]
+ 8002ff8: f8dd 9018 ldr.w r9, [sp, #24]
+ 8002ffc: ea50 000b orrs.w r0, r0, fp
+ 8003000: f000 852f beq.w 8003a62 <core::fmt::float::float_to_decimal_common_exact+0x122e>
+ let (a, b) = $add_with_overflow(self as $ActualT,
+ 8003004: 9804 ldr r0, [sp, #16]
+ 8003006: eb1a 0100 adds.w r1, sl, r0
+ 800300a: f04f 0000 mov.w r0, #0
+ 800300e: eb46 020b adc.w r2, r6, fp
+ 8003012: ebb1 010a subs.w r1, r1, sl
+ 8003016: eb72 0106 sbcs.w r1, r2, r6
+ 800301a: f04f 0100 mov.w r1, #0
+ 800301e: bf38 it cc
+ 8003020: 2101 movcc r1, #1
+ if b {None} else {Some(a)}
+ 8003022: 2900 cmp r1, #0
+ 8003024: f040 84f6 bne.w 8003a14 <core::fmt::float::float_to_decimal_common_exact+0x11e0>
+ let (a, b) = $sub_with_overflow(self as $ActualT,
+ 8003028: f1ba 0101 subs.w r1, sl, #1
+ 800302c: 464c mov r4, r9
+ 800302e: f166 0200 sbc.w r2, r6, #0
+ 8003032: ebba 0101 subs.w r1, sl, r1
+ 8003036: eb76 0102 sbcs.w r1, r6, r2
+ 800303a: bf38 it cc
+ 800303c: 2001 movcc r0, #1
+ if b {None} else {Some(a)}
+ 800303e: 2800 cmp r0, #0
+ 8003040: f040 84ee bne.w 8003a20 <core::fmt::float::float_to_decimal_common_exact+0x11ec>
+ 8003044: f1a7 05c4 sub.w r5, r7, #196 ; 0xc4
+ let mut base = [0; $n];
+ 8003048: 21a0 movs r1, #160 ; 0xa0
+ 800304a: 4628 mov r0, r5
+ 800304c: f000 fd92 bl 8003b74 <__aeabi_memclr4>
+ let nbits = 64 - (mant - 1).leading_zeros() as i64;
+ 8003050: f1ba 0001 subs.w r0, sl, #1
+ unsafe { $ctlz(self as $ActualT) as u32 }
+ 8003054: fab0 f080 clz r0, r0
+ 8003058: f176 0100 sbcs.w r1, r6, #0
+ 800305c: f100 0020 add.w r0, r0, #32
+ 8003060: bf18 it ne
+ 8003062: fab1 f081 clzne r0, r1
+ (((nbits + exp as i64) * 1292913986) >> 32) as i16
+ 8003066: f644 5142 movw r1, #19778 ; 0x4d42
+ let nbits = 64 - (mant - 1).leading_zeros() as i64;
+ 800306a: f1c0 0040 rsb r0, r0, #64 ; 0x40
+ (((nbits + exp as i64) * 1292913986) >> 32) as i16
+ 800306e: f6c4 5110 movt r1, #19728 ; 0x4d10
+ 8003072: fa00 f084 sxtah r0, r0, r4
+ 8003076: fb50 f001 smmul r0, r0, r1
+ 800307a: b201 sxth r1, r0
+ 800307c: 2000 movs r0, #0
+ base[sz] = v as $ty;
+ 800307e: 2827 cmp r0, #39 ; 0x27
+ 8003080: f200 8491 bhi.w 80039a6 <core::fmt::float::float_to_decimal_common_exact+0x1172>
+ 8003084: f845 a020 str.w sl, [r5, r0, lsl #2]
+ sz += 1;
+ 8003088: 3001 adds r0, #1
+ while v > 0 {
+ 800308a: 2e00 cmp r6, #0
+ 800308c: 46b2 mov sl, r6
+ 800308e: f04f 0600 mov.w r6, #0
+ 8003092: d1f4 bne.n 800307e <core::fmt::float::float_to_decimal_common_exact+0x84a>
+ $name { size: sz, base: base }
+ 8003094: f8cd 045c str.w r0, [sp, #1116] ; 0x45c
+ 8003098: f20d 405c addw r0, sp, #1116 ; 0x45c
+ 800309c: f1a7 08c4 sub.w r8, r7, #196 ; 0xc4
+ 80030a0: 468a mov sl, r1
+ 80030a2: 22a0 movs r2, #160 ; 0xa0
+ 80030a4: f100 0904 add.w r9, r0, #4
+ 80030a8: 4641 mov r1, r8
+ 80030aa: 4648 mov r0, r9
+ 80030ac: f000 fd1a bl 8003ae4 <__aeabi_memcpy4>
+ $name { size: 1, base: base }
+ 80030b0: 2001 movs r0, #1
+ 80030b2: 219c movs r1, #156 ; 0x9c
+ 80030b4: f8cd 0500 str.w r0, [sp, #1280] ; 0x500
+ 80030b8: f8cd 0504 str.w r0, [sp, #1284] ; 0x504
+ 80030bc: f50d 60a0 add.w r0, sp, #1280 ; 0x500
+ 80030c0: 3008 adds r0, #8
+ 80030c2: f000 fd57 bl 8003b74 <__aeabi_memclr4>
+ 80030c6: 9901 ldr r1, [sp, #4]
+ let mut k = estimate_scaling_factor(d.mant, d.exp);
+
+ // `v = mant / scale`.
+ let mut mant = Big::from_u64(d.mant);
+ let mut scale = Big::from_small(1);
+ if d.exp < 0 {
+ 80030c8: f1b1 3fff cmp.w r1, #4294967295 ; 0xffffffff
+ 80030cc: dd02 ble.n 80030d4 <core::fmt::float::float_to_decimal_common_exact+0x8a0>
+ 80030ce: f20d 405c addw r0, sp, #1116 ; 0x45c
+ 80030d2: e003 b.n 80030dc <core::fmt::float::float_to_decimal_common_exact+0x8a8>
+ scale.mul_pow2(-d.exp as usize);
+ 80030d4: 4260 negs r0, r4
+ 80030d6: b201 sxth r1, r0
+ 80030d8: f50d 60a0 add.w r0, sp, #1280 ; 0x500
+ 80030dc: f7fd fd0d bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 80030e0: f50d 60a0 add.w r0, sp, #1280 ; 0x500
+ 80030e4: f04f 32ff mov.w r2, #4294967295 ; 0xffffffff
+ 80030e8: 4651 mov r1, sl
+ 80030ea: f100 0b04 add.w fp, r0, #4
+ } else {
+ mant.mul_pow2(d.exp as usize);
+ }
+
+ // divide `mant` by `10^k`. now `scale / 10 < mant <= scale * 10`.
+ if k >= 0 {
+ 80030ee: 4291 cmp r1, r2
+ 80030f0: dd02 ble.n 80030f8 <core::fmt::float::float_to_decimal_common_exact+0x8c4>
+ 80030f2: f50d 60a0 add.w r0, sp, #1280 ; 0x500
+ 80030f6: e003 b.n 8003100 <core::fmt::float::float_to_decimal_common_exact+0x8cc>
+ mul_pow10(&mut scale, k as usize);
+ } else {
+ mul_pow10(&mut mant, -k as usize);
+ 80030f8: 4248 negs r0, r1
+ 80030fa: b201 sxth r1, r0
+ 80030fc: f20d 405c addw r0, sp, #1116 ; 0x45c
+ 8003100: f7fd f982 bl 8000408 <core::num::flt2dec::strategy::dragon::mul_pow10>
+ $name { size: self.size, base: self.base }
+ 8003104: f8dd 5500 ldr.w r5, [sp, #1280] ; 0x500
+ 8003108: f108 0004 add.w r0, r8, #4
+ 800310c: 4659 mov r1, fp
+ 800310e: 22a0 movs r2, #160 ; 0xa0
+ 8003110: 9016 str r0, [sp, #88] ; 0x58
+ 8003112: f847 5cc4 str.w r5, [r7, #-196]
+ 8003116: f000 fce5 bl 8003ae4 <__aeabi_memcpy4>
+ } else if self.end > slice.len() {
+ 800311a: 2d28 cmp r5, #40 ; 0x28
+ 800311c: d81e bhi.n 800315c <core::fmt::float::float_to_decimal_common_exact+0x928>
+ 800311e: e9dd 6c15 ldrd r6, ip, [sp, #84] ; 0x54
+ 8003122: f64c 2400 movw r4, #51712 ; 0xca00
+ 8003126: f6c3 349a movt r4, #15258 ; 0x3b9a
+ 800312a: b18d cbz r5, 8003150 <core::fmt::float::float_to_decimal_common_exact+0x91c>
+ if self.end == self.ptr {
+ 800312c: 00ad lsls r5, r5, #2
+ 800312e: 2200 movs r2, #0
+ let lhs = ((borrow as $bigty) << nbits) | (self as $bigty);
+ 8003130: f858 0005 ldr.w r0, [r8, r5]
+ ((lhs / rhs) as $ty, (lhs % rhs) as $ty)
+ 8003134: 4611 mov r1, r2
+ 8003136: 4622 mov r2, r4
+ 8003138: 2300 movs r3, #0
+ 800313a: f000 fcbf bl 8003abc <__aeabi_uldivmod>
+ *a = q;
+ 800313e: f848 0005 str.w r0, [r8, r5]
+ 8003142: 3d04 subs r5, #4
+ 8003144: d1f4 bne.n 8003130 <core::fmt::float::float_to_decimal_common_exact+0x8fc>
+ 8003146: f857 5cc4 ldr.w r5, [r7, #-196]
+ 800314a: f8dd c058 ldr.w ip, [sp, #88] ; 0x58
+ 800314e: e000 b.n 8003152 <core::fmt::float::float_to_decimal_common_exact+0x91e>
+ 8003150: 2500 movs r5, #0
+ n -= largest;
+ 8003152: 3e09 subs r6, #9
+ while n > largest {
+ 8003154: 2e0a cmp r6, #10
+ 8003156: d305 bcc.n 8003164 <core::fmt::float::float_to_decimal_common_exact+0x930>
+ } else if self.end > slice.len() {
+ 8003158: 2d28 cmp r5, #40 ; 0x28
+ 800315a: d9e6 bls.n 800312a <core::fmt::float::float_to_decimal_common_exact+0x8f6>
+ 800315c: 4628 mov r0, r5
+ 800315e: 2128 movs r1, #40 ; 0x28
+ 8003160: f7fd f9ed bl 800053e <core::slice::slice_index_len_fail>
+ 8003164: 2d29 cmp r5, #41 ; 0x29
+ 8003166: d2f9 bcs.n 800315c <core::fmt::float::float_to_decimal_common_exact+0x928>
+ 8003168: b1bd cbz r5, 800319a <core::fmt::float::float_to_decimal_common_exact+0x966>
+ x.div_rem_small(TWOPOW10[n]);
+ 800316a: f244 7094 movw r0, #18324 ; 0x4794
+ if self.end == self.ptr {
+ 800316e: 00ad lsls r5, r5, #2
+ 8003170: 2200 movs r2, #0
+ 8003172: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003176: f850 4026 ldr.w r4, [r0, r6, lsl #2]
+ let lhs = ((borrow as $bigty) << nbits) | (self as $bigty);
+ 800317a: f858 0005 ldr.w r0, [r8, r5]
+ ((lhs / rhs) as $ty, (lhs % rhs) as $ty)
+ 800317e: 4611 mov r1, r2
+ 8003180: 4622 mov r2, r4
+ 8003182: 2300 movs r3, #0
+ 8003184: f000 fc9a bl 8003abc <__aeabi_uldivmod>
+ *a = q;
+ 8003188: f848 0005 str.w r0, [r8, r5]
+ 800318c: 3d04 subs r5, #4
+ 800318e: d1f4 bne.n 800317a <core::fmt::float::float_to_decimal_common_exact+0x946>
+ 8003190: f857 1cc4 ldr.w r1, [r7, #-196]
+ 8003194: f8dd c058 ldr.w ip, [sp, #88] ; 0x58
+ 8003198: e000 b.n 800319c <core::fmt::float::float_to_decimal_common_exact+0x968>
+ 800319a: 2100 movs r1, #0
+ let mut sz = cmp::max(self.size, other.size);
+ 800319c: f8dd 045c ldr.w r0, [sp, #1116] ; 0x45c
+ 80031a0: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 80031a4: 4288 cmp r0, r1
+ 80031a6: bf28 it cs
+ 80031a8: 4601 movcs r1, r0
+ } else if self.end > slice.len() {
+ 80031aa: 2929 cmp r1, #41 ; 0x29
+ 80031ac: f080 8407 bcs.w 80039be <core::fmt::float::float_to_decimal_common_exact+0x118a>
+ 80031b0: 2203 movs r2, #3
+ 80031b2: ea42 0381 orr.w r3, r2, r1, lsl #2
+ Some(diff / size as isize)
+ 80031b6: f341 021d sbfx r2, r1, #0, #30
+ 80031ba: 2b07 cmp r3, #7
+ 80031bc: d32a bcc.n 8003214 <core::fmt::float::float_to_decimal_common_exact+0x9e0>
+ 80031be: 2600 movs r6, #0
+ 80031c0: 2300 movs r3, #0
+ let (c, v) = (*a).full_add(*b, carry);
+ 80031c2: f859 5023 ldr.w r5, [r9, r3, lsl #2]
+ 80031c6: f85c 4023 ldr.w r4, [ip, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80031ca: f006 0601 and.w r6, r6, #1
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80031ce: 4425 add r5, r4
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80031d0: 442e add r6, r5
+ *a = v;
+ 80031d2: f84c 6023 str.w r6, [ip, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80031d6: 42ae cmp r6, r5
+ 80031d8: f04f 0601 mov.w r6, #1
+ self.index += 1;
+ 80031dc: f103 0301 add.w r3, r3, #1
+ 80031e0: bf28 it cs
+ 80031e2: 2600 movcs r6, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80031e4: 42a5 cmp r5, r4
+ 80031e6: f04f 0501 mov.w r5, #1
+ 80031ea: bf28 it cs
+ 80031ec: 2500 movcs r5, #0
+ if self.index < self.len {
+ 80031ee: 4293 cmp r3, r2
+ (carry1 || carry2, v)
+ 80031f0: ea46 0605 orr.w r6, r6, r5
+ 80031f4: d3e5 bcc.n 80031c2 <core::fmt::float::float_to_decimal_common_exact+0x98e>
+ if carry {
+ 80031f6: 2e01 cmp r6, #1
+ 80031f8: d10a bne.n 8003210 <core::fmt::float::float_to_decimal_common_exact+0x9dc>
+ self.base[sz] = 1;
+ 80031fa: 2927 cmp r1, #39 ; 0x27
+ 80031fc: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 8003200: f200 843f bhi.w 8003a82 <core::fmt::float::float_to_decimal_common_exact+0x124e>
+ 8003204: eb08 0281 add.w r2, r8, r1, lsl #2
+ 8003208: 2301 movs r3, #1
+ sz += 1;
+ 800320a: 3101 adds r1, #1
+ self.base[sz] = 1;
+ 800320c: 6053 str r3, [r2, #4]
+ 800320e: e001 b.n 8003214 <core::fmt::float::float_to_decimal_common_exact+0x9e0>
+ 8003210: f20d 455c addw r5, sp, #1116 ; 0x45c
+ let sz = max(self.size, other.size);
+ 8003214: f8dd e500 ldr.w lr, [sp, #1280] ; 0x500
+ self.size = sz;
+ 8003218: f847 1cc4 str.w r1, [r7, #-196]
+ 800321c: 458e cmp lr, r1
+ 800321e: bf28 it cs
+ 8003220: 4671 movcs r1, lr
+ } else if self.end > slice.len() {
+ 8003222: 2929 cmp r1, #41 ; 0x29
+ 8003224: f080 83cb bcs.w 80039be <core::fmt::float::float_to_decimal_common_exact+0x118a>
+ loop {
+ 8003228: 0089 lsls r1, r1, #2
+ if self.end == self.ptr {
+ 800322a: 2900 cmp r1, #0
+ 800322c: d00a beq.n 8003244 <core::fmt::float::float_to_decimal_common_exact+0xa10>
+ 800322e: d02f beq.n 8003290 <core::fmt::float::float_to_decimal_common_exact+0xa5c>
+ 8003230: f50d 62a0 add.w r2, sp, #1280 ; 0x500
+ 8003234: f858 3001 ldr.w r3, [r8, r1]
+ 8003238: 5856 ldr r6, [r2, r1]
+ Ordering::Equal => (),
+ 800323a: 3904 subs r1, #4
+ 800323c: 42b3 cmp r3, r6
+ 800323e: d0f4 beq.n 800322a <core::fmt::float::float_to_decimal_common_exact+0x9f6>
+ 8003240: d301 bcc.n 8003246 <core::fmt::float::float_to_decimal_common_exact+0xa12>
+ 8003242: e025 b.n 8003290 <core::fmt::float::float_to_decimal_common_exact+0xa5c>
+ 8003244: d024 beq.n 8003290 <core::fmt::float::float_to_decimal_common_exact+0xa5c>
+ } else if self.end > slice.len() {
+ 8003246: 2829 cmp r0, #41 ; 0x29
+ 8003248: 4651 mov r1, sl
+ 800324a: f080 8410 bcs.w 8003a6e <core::fmt::float::float_to_decimal_common_exact+0x123a>
+ 800324e: 2400 movs r4, #0
+ 8003250: b310 cbz r0, 8003298 <core::fmt::float::float_to_decimal_common_exact+0xa64>
+ intrinsics::offset(self, count) as *mut T
+ 8003252: eb05 0180 add.w r1, r5, r0, lsl #2
+ if self.ptr == self.end {
+ 8003256: 0086 lsls r6, r0, #2
+ 8003258: 250a movs r5, #10
+ 800325a: f101 0c04 add.w ip, r1, #4
+ 800325e: 4649 mov r1, r9
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8003260: 680a ldr r2, [r1, #0]
+ 8003262: 2300 movs r3, #0
+ 8003264: 3e04 subs r6, #4
+ 8003266: fbe2 4305 umlal r4, r3, r2, r5
+ *a = v;
+ 800326a: f841 4b04 str.w r4, [r1], #4
+ 800326e: 461c mov r4, r3
+ 8003270: d1f6 bne.n 8003260 <core::fmt::float::float_to_decimal_common_exact+0xa2c>
+ if carry > 0 {
+ 8003272: 2b00 cmp r3, #0
+ 8003274: 4651 mov r1, sl
+ 8003276: d012 beq.n 800329e <core::fmt::float::float_to_decimal_common_exact+0xa6a>
+ 8003278: 9c0b ldr r4, [sp, #44] ; 0x2c
+ self.base[sz] = carry;
+ 800327a: 2827 cmp r0, #39 ; 0x27
+ 800327c: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 8003280: f200 8403 bhi.w 8003a8a <core::fmt::float::float_to_decimal_common_exact+0x1256>
+ 8003284: f8cc 3000 str.w r3, [ip]
+ 8003288: f8dd c058 ldr.w ip, [sp, #88] ; 0x58
+ sz += 1;
+ 800328c: 3001 adds r0, #1
+ 800328e: e00b b.n 80032a8 <core::fmt::float::float_to_decimal_common_exact+0xa74>
+ 8003290: 9c0b ldr r4, [sp, #44] ; 0x2c
+ 8003292: 4651 mov r1, sl
+ // in order to keep the fixed-size bignum, we actually use `mant + floor(plus) >= scale`.
+ // we are not actually modifying `scale`, since we can skip the initial multiplication instead.
+ // again with the shortest algorithm, `d[0]` can be zero but will be eventually rounded up.
+ if *div_2pow10(&mut scale.clone(), buf.len()).add(&mant) >= scale {
+ // equivalent to scaling `scale` by 10
+ k += 1;
+ 8003294: 3101 adds r1, #1
+ 8003296: e009 b.n 80032ac <core::fmt::float::float_to_decimal_common_exact+0xa78>
+ 8003298: 9c0b ldr r4, [sp, #44] ; 0x2c
+ 800329a: 2000 movs r0, #0
+ 800329c: e004 b.n 80032a8 <core::fmt::float::float_to_decimal_common_exact+0xa74>
+ 800329e: f8dd c058 ldr.w ip, [sp, #88] ; 0x58
+ 80032a2: 9c0b ldr r4, [sp, #44] ; 0x2c
+ 80032a4: f20d 455c addw r5, sp, #1116 ; 0x45c
+ self.size = sz;
+ 80032a8: f8cd 045c str.w r0, [sp, #1116] ; 0x45c
+ 80032ac: 460a mov r2, r1
+ }
+
+ // if we are working with the last-digit limitation, we need to shorten the buffer
+ // before the actual rendering in order to avoid double rounding.
+ // note that we have to enlarge the buffer again when rounding up happens!
+ let mut len = if k < limit {
+ 80032ae: b211 sxth r1, r2
+ 80032b0: 9209 str r2, [sp, #36] ; 0x24
+ 80032b2: 42a1 cmp r1, r4
+ 80032b4: da03 bge.n 80032be <core::fmt::float::float_to_decimal_common_exact+0xa8a>
+ 80032b6: 2101 movs r1, #1
+ 80032b8: 2400 movs r4, #0
+ 80032ba: 9113 str r1, [sp, #76] ; 0x4c
+ 80032bc: e20d b.n 80036da <core::fmt::float::float_to_decimal_common_exact+0xea6>
+ 80032be: 9b15 ldr r3, [sp, #84] ; 0x54
+ // oops, we cannot even produce *one* digit.
+ // this is possible when, say, we've got something like 9.5 and it's being rounded to 10.
+ // we return an empty buffer, with an exception of the later rounding-up case
+ // which occurs when `k == limit` and has to produce exactly one digit.
+ 0
+ } else if ((k as i32 - limit as i32) as usize) < buf.len() {
+ 80032c0: 1b09 subs r1, r1, r4
+ (k - limit) as usize
+ 80032c2: 1b12 subs r2, r2, r4
+ 80032c4: 2400 movs r4, #0
+ } else if ((k as i32 - limit as i32) as usize) < buf.len() {
+ 80032c6: 4299 cmp r1, r3
+ 80032c8: f04f 0101 mov.w r1, #1
+ 80032cc: bf38 it cc
+ 80032ce: b213 sxthcc r3, r2
+ } else {
+ buf.len()
+ };
+
+ if len > 0 {
+ 80032d0: 2b00 cmp r3, #0
+ 80032d2: e9cd 1313 strd r1, r3, [sp, #76] ; 0x4c
+ 80032d6: f000 8200 beq.w 80036da <core::fmt::float::float_to_decimal_common_exact+0xea6>
+ 80032da: f20d 56a4 addw r6, sp, #1444 ; 0x5a4
+ $name { size: self.size, base: self.base }
+ 80032de: 4659 mov r1, fp
+ 80032e0: 22a0 movs r2, #160 ; 0xa0
+ 80032e2: f8cd e5a4 str.w lr, [sp, #1444] ; 0x5a4
+ 80032e6: 4664 mov r4, ip
+ 80032e8: 1d30 adds r0, r6, #4
+ 80032ea: 9010 str r0, [sp, #64] ; 0x40
+ 80032ec: f000 fbfa bl 8003ae4 <__aeabi_memcpy4>
+ // cache `(2, 4, 8) * scale` for digit generation.
+ // (this can be expensive, so do not calculate them when the buffer is empty.)
+ let mut scale2 = scale.clone(); scale2.mul_pow2(1);
+ 80032f0: 4630 mov r0, r6
+ 80032f2: 2101 movs r1, #1
+ 80032f4: f7fd fc01 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 80032f8: f8dd 0500 ldr.w r0, [sp, #1280] ; 0x500
+ 80032fc: f50d 66c9 add.w r6, sp, #1608 ; 0x648
+ 8003300: 4659 mov r1, fp
+ 8003302: 22a0 movs r2, #160 ; 0xa0
+ 8003304: f8cd 0648 str.w r0, [sp, #1608] ; 0x648
+ 8003308: 1d30 adds r0, r6, #4
+ 800330a: 900e str r0, [sp, #56] ; 0x38
+ 800330c: f000 fbea bl 8003ae4 <__aeabi_memcpy4>
+ let mut scale4 = scale.clone(); scale4.mul_pow2(2);
+ 8003310: 4630 mov r0, r6
+ 8003312: 2102 movs r1, #2
+ 8003314: f7fd fbf1 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 8003318: f8dd 0500 ldr.w r0, [sp, #1280] ; 0x500
+ 800331c: 4659 mov r1, fp
+ 800331e: 22a0 movs r2, #160 ; 0xa0
+ 8003320: f847 0cc4 str.w r0, [r7, #-196]
+ 8003324: 4620 mov r0, r4
+ 8003326: f000 fbdd bl 8003ae4 <__aeabi_memcpy4>
+ let mut scale8 = scale.clone(); scale8.mul_pow2(3);
+ 800332a: 4640 mov r0, r8
+ 800332c: 2103 movs r1, #3
+ 800332e: f7fd fbe4 bl 8000afa <core::num::bignum::Big32x40::mul_pow2>
+ 8003332: f105 0008 add.w r0, r5, #8
+ 8003336: f1a7 041e sub.w r4, r7, #30
+ 800333a: 2100 movs r1, #0
+ 800333c: 9011 str r0, [sp, #68] ; 0x44
+ 800333e: f8dd 045c ldr.w r0, [sp, #1116] ; 0x45c
+ } else if self.end > slice.len() {
+ 8003342: 2829 cmp r0, #41 ; 0x29
+ 8003344: f080 833f bcs.w 80039c6 <core::fmt::float::float_to_decimal_common_exact+0x1192>
+ 8003348: 9113 str r1, [sp, #76] ; 0x4c
+ 800334a: 3101 adds r1, #1
+ 800334c: f8dd c058 ldr.w ip, [sp, #88] ; 0x58
+ intrinsics::offset(self, count)
+ 8003350: 0082 lsls r2, r0, #2
+ 8003352: f04f 0e01 mov.w lr, #1
+ 8003356: 9112 str r1, [sp, #72] ; 0x48
+ 8003358: eb05 0180 add.w r1, r5, r0, lsl #2
+ while ptrdistance(self.ptr, self.end) >= 4 {
+ 800335c: 9d11 ldr r5, [sp, #68] ; 0x44
+ 800335e: 1d0b adds r3, r1, #4
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 8003360: 1f2e subs r6, r5, #4
+ 8003362: 46a2 mov sl, r4
+ intrinsics::overflowing_sub(self, rhs)
+ 8003364: 1b99 subs r1, r3, r6
+ Some(diff / size as isize)
+ 8003366: 17cc asrs r4, r1, #31
+ 8003368: eb01 7194 add.w r1, r1, r4, lsr #30
+ 800336c: 1089 asrs r1, r1, #2
+ while ptrdistance(self.ptr, self.end) >= 4 {
+ 800336e: 2903 cmp r1, #3
+ 8003370: f240 818e bls.w 8003690 <core::fmt::float::float_to_decimal_common_exact+0xe5c>
+ 8003374: f855 1c04 ldr.w r1, [r5, #-4]
+ 8003378: 4654 mov r4, sl
+ 800337a: 2600 movs r6, #0
+ if predicate(elt) {
+ 800337c: 2900 cmp r1, #0
+ SearchWhile::Done(false)
+ 800337e: bf1a itte ne
+ 8003380: f807 ec1d strbne.w lr, [r7, #-29]
+ 8003384: 4621 movne r1, r4
+ 8003386: f1a7 011d subeq.w r1, r7, #29
+ 800338a: 700e strb r6, [r1, #0]
+ })
+ 800338c: f817 1c1d ldrb.w r1, [r7, #-29]
+ 8003390: bb31 cbnz r1, 80033e0 <core::fmt::float::float_to_decimal_common_exact+0xbac>
+ 8003392: 6829 ldr r1, [r5, #0]
+ if predicate(elt) {
+ 8003394: 2900 cmp r1, #0
+ SearchWhile::Done(false)
+ 8003396: bf1a itte ne
+ 8003398: f807 ec1d strbne.w lr, [r7, #-29]
+ 800339c: 4621 movne r1, r4
+ 800339e: f1a7 011d subeq.w r1, r7, #29
+ 80033a2: 700e strb r6, [r1, #0]
+ })
+ 80033a4: f817 1c1d ldrb.w r1, [r7, #-29]
+ 80033a8: b9d1 cbnz r1, 80033e0 <core::fmt::float::float_to_decimal_common_exact+0xbac>
+ 80033aa: 6869 ldr r1, [r5, #4]
+ if predicate(elt) {
+ 80033ac: 2900 cmp r1, #0
+ SearchWhile::Done(false)
+ 80033ae: bf1a itte ne
+ 80033b0: f807 ec1d strbne.w lr, [r7, #-29]
+ 80033b4: 4621 movne r1, r4
+ 80033b6: f1a7 011d subeq.w r1, r7, #29
+ 80033ba: 700e strb r6, [r1, #0]
+ })
+ 80033bc: f817 1c1d ldrb.w r1, [r7, #-29]
+ 80033c0: b971 cbnz r1, 80033e0 <core::fmt::float::float_to_decimal_common_exact+0xbac>
+ 80033c2: 68a9 ldr r1, [r5, #8]
+ search_while!(g($mkref!(self.ptr.post_inc())));
+ 80033c4: 3a10 subs r2, #16
+ 80033c6: 3510 adds r5, #16
+ if predicate(elt) {
+ 80033c8: 2900 cmp r1, #0
+ SearchWhile::Done(false)
+ 80033ca: bf1a itte ne
+ 80033cc: f807 ec1d strbne.w lr, [r7, #-29]
+ 80033d0: 4621 movne r1, r4
+ 80033d2: f1a7 011d subeq.w r1, r7, #29
+ 80033d6: 700e strb r6, [r1, #0]
+ })
+ 80033d8: f817 1c1d ldrb.w r1, [r7, #-29]
+ search_while!(g($mkref!(self.ptr.post_inc())));
+ 80033dc: 2900 cmp r1, #0
+ 80033de: d0bf beq.n 8003360 <core::fmt::float::float_to_decimal_common_exact+0xb2c>
+ 80033e0: f817 2c1e ldrb.w r2, [r7, #-30]
+ 80033e4: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 80033e8: ea41 2202 orr.w r2, r1, r2, lsl #8
+ 80033ec: 05d1 lsls r1, r2, #23
+ 80033ee: f100 819e bmi.w 800372e <core::fmt::float::float_to_decimal_common_exact+0xefa>
+ let sz = max(self.size, other.size);
+ 80033f2: f857 2cc4 ldr.w r2, [r7, #-196]
+ 80033f6: 4282 cmp r2, r0
+ 80033f8: bf38 it cc
+ 80033fa: 4602 movcc r2, r0
+ } else if self.end > slice.len() {
+ 80033fc: 2a29 cmp r2, #41 ; 0x29
+ 80033fe: f080 82e5 bcs.w 80039cc <core::fmt::float::float_to_decimal_common_exact+0x1198>
+ 8003402: f20d 54a4 addw r4, sp, #1444 ; 0x5a4
+ loop {
+ 8003406: 0091 lsls r1, r2, #2
+ 8003408: 46a6 mov lr, r4
+ 800340a: 9c10 ldr r4, [sp, #64] ; 0x40
+ if self.end == self.ptr {
+ 800340c: 2900 cmp r1, #0
+ 800340e: d008 beq.n 8003422 <core::fmt::float::float_to_decimal_common_exact+0xbee>
+ 8003410: d00c beq.n 800342c <core::fmt::float::float_to_decimal_common_exact+0xbf8>
+ 8003412: 586b ldr r3, [r5, r1]
+ 8003414: f858 6001 ldr.w r6, [r8, r1]
+ Ordering::Equal => (),
+ 8003418: 3904 subs r1, #4
+ 800341a: 42b3 cmp r3, r6
+ 800341c: d0f6 beq.n 800340c <core::fmt::float::float_to_decimal_common_exact+0xbd8>
+ 800341e: d301 bcc.n 8003424 <core::fmt::float::float_to_decimal_common_exact+0xbf0>
+ 8003420: e004 b.n 800342c <core::fmt::float::float_to_decimal_common_exact+0xbf8>
+ 8003422: d003 beq.n 800342c <core::fmt::float::float_to_decimal_common_exact+0xbf8>
+ 8003424: f04f 0c00 mov.w ip, #0
+ 8003428: 4602 mov r2, r0
+ 800342a: e02c b.n 8003486 <core::fmt::float::float_to_decimal_common_exact+0xc52>
+ 800342c: 2003 movs r0, #3
+ 800342e: ea40 0182 orr.w r1, r0, r2, lsl #2
+ 8003432: f342 001d sbfx r0, r2, #0, #30
+ 8003436: 2907 cmp r1, #7
+ 8003438: d321 bcc.n 800347e <core::fmt::float::float_to_decimal_common_exact+0xc4a>
+ 800343a: 2300 movs r3, #0
+ 800343c: 2601 movs r6, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 800343e: f85c 5023 ldr.w r5, [ip, r3, lsl #2]
+ 8003442: f859 1023 ldr.w r1, [r9, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8003446: f006 0601 and.w r6, r6, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 800344a: 43ed mvns r5, r5
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 800344c: 440d add r5, r1
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 800344e: 442e add r6, r5
+ *a = v;
+ 8003450: f849 6023 str.w r6, [r9, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8003454: 42ae cmp r6, r5
+ 8003456: f04f 0601 mov.w r6, #1
+ self.index += 1;
+ 800345a: f103 0301 add.w r3, r3, #1
+ 800345e: bf28 it cs
+ 8003460: 2600 movcs r6, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8003462: 428d cmp r5, r1
+ 8003464: f04f 0101 mov.w r1, #1
+ 8003468: bf28 it cs
+ 800346a: 2100 movcs r1, #0
+ if self.index < self.len {
+ 800346c: 4283 cmp r3, r0
+ (carry1 || carry2, v)
+ 800346e: ea46 0601 orr.w r6, r6, r1
+ 8003472: d3e4 bcc.n 800343e <core::fmt::float::float_to_decimal_common_exact+0xc0a>
+ assert!(noborrow);
+ 8003474: 2e00 cmp r6, #0
+ 8003476: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 800347a: f000 829a beq.w 80039b2 <core::fmt::float::float_to_decimal_common_exact+0x117e>
+ 800347e: f04f 0c08 mov.w ip, #8
+ self.size = sz;
+ 8003482: f8cd 245c str.w r2, [sp, #1116] ; 0x45c
+ let sz = max(self.size, other.size);
+ 8003486: f8dd 0648 ldr.w r0, [sp, #1608] ; 0x648
+ 800348a: 4290 cmp r0, r2
+ 800348c: bf38 it cc
+ 800348e: 4610 movcc r0, r2
+ } else if self.end > slice.len() {
+ 8003490: 2829 cmp r0, #41 ; 0x29
+ 8003492: f080 829c bcs.w 80039ce <core::fmt::float::float_to_decimal_common_exact+0x119a>
+ loop {
+ 8003496: 0081 lsls r1, r0, #2
+ if self.end == self.ptr {
+ 8003498: 2900 cmp r1, #0
+ 800349a: d00a beq.n 80034b2 <core::fmt::float::float_to_decimal_common_exact+0xc7e>
+ 800349c: d00c beq.n 80034b8 <core::fmt::float::float_to_decimal_common_exact+0xc84>
+ 800349e: f50d 66c9 add.w r6, sp, #1608 ; 0x648
+ 80034a2: 586b ldr r3, [r5, r1]
+ 80034a4: 5876 ldr r6, [r6, r1]
+ Ordering::Equal => (),
+ 80034a6: 3904 subs r1, #4
+ 80034a8: 42b3 cmp r3, r6
+ 80034aa: d0f5 beq.n 8003498 <core::fmt::float::float_to_decimal_common_exact+0xc64>
+ 80034ac: d204 bcs.n 80034b8 <core::fmt::float::float_to_decimal_common_exact+0xc84>
+ let sz = cmp::max(self.size, other.size);
+ 80034ae: 4610 mov r0, r2
+ 80034b0: e035 b.n 800351e <core::fmt::float::float_to_decimal_common_exact+0xcea>
+ 80034b2: d001 beq.n 80034b8 <core::fmt::float::float_to_decimal_common_exact+0xc84>
+ 80034b4: 4610 mov r0, r2
+ 80034b6: e032 b.n 800351e <core::fmt::float::float_to_decimal_common_exact+0xcea>
+ 80034b8: 2103 movs r1, #3
+ 80034ba: f340 021d sbfx r2, r0, #0, #30
+ 80034be: ea41 0180 orr.w r1, r1, r0, lsl #2
+ 80034c2: 2907 cmp r1, #7
+ 80034c4: d327 bcc.n 8003516 <core::fmt::float::float_to_decimal_common_exact+0xce2>
+ 80034c6: f8cd c03c str.w ip, [sp, #60] ; 0x3c
+ 80034ca: f8dd c038 ldr.w ip, [sp, #56] ; 0x38
+ 80034ce: 2300 movs r3, #0
+ 80034d0: 2501 movs r5, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 80034d2: f85c 6023 ldr.w r6, [ip, r3, lsl #2]
+ 80034d6: f859 1023 ldr.w r1, [r9, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80034da: f005 0501 and.w r5, r5, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 80034de: 43f6 mvns r6, r6
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80034e0: 440e add r6, r1
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80034e2: 4435 add r5, r6
+ *a = v;
+ 80034e4: f849 5023 str.w r5, [r9, r3, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80034e8: 42b5 cmp r5, r6
+ 80034ea: f04f 0501 mov.w r5, #1
+ self.index += 1;
+ 80034ee: f103 0301 add.w r3, r3, #1
+ 80034f2: bf28 it cs
+ 80034f4: 2500 movcs r5, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80034f6: 428e cmp r6, r1
+ 80034f8: f04f 0101 mov.w r1, #1
+ 80034fc: bf28 it cs
+ 80034fe: 2100 movcs r1, #0
+ if self.index < self.len {
+ 8003500: 4293 cmp r3, r2
+ (carry1 || carry2, v)
+ 8003502: ea45 0501 orr.w r5, r5, r1
+ 8003506: d3e4 bcc.n 80034d2 <core::fmt::float::float_to_decimal_common_exact+0xc9e>
+ 8003508: f8dd c03c ldr.w ip, [sp, #60] ; 0x3c
+ assert!(noborrow);
+ 800350c: 2d00 cmp r5, #0
+ 800350e: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 8003512: f000 824e beq.w 80039b2 <core::fmt::float::float_to_decimal_common_exact+0x117e>
+ return (len, k);
+ }
+
+ let mut d = 0;
+ if mant >= scale8 { mant.sub(&scale8); d += 8; }
+ if mant >= scale4 { mant.sub(&scale4); d += 4; }
+ 8003516: f04c 0c04 orr.w ip, ip, #4
+ self.size = sz;
+ 800351a: f8cd 045c str.w r0, [sp, #1116] ; 0x45c
+ let sz = max(self.size, other.size);
+ 800351e: f8dd 35a4 ldr.w r3, [sp, #1444] ; 0x5a4
+ 8003522: 4283 cmp r3, r0
+ 8003524: bf38 it cc
+ 8003526: 4603 movcc r3, r0
+ } else if self.end > slice.len() {
+ 8003528: 2b29 cmp r3, #41 ; 0x29
+ 800352a: f080 8253 bcs.w 80039d4 <core::fmt::float::float_to_decimal_common_exact+0x11a0>
+ loop {
+ 800352e: 0099 lsls r1, r3, #2
+ if self.end == self.ptr {
+ 8003530: 2900 cmp r1, #0
+ 8003532: d009 beq.n 8003548 <core::fmt::float::float_to_decimal_common_exact+0xd14>
+ 8003534: d00b beq.n 800354e <core::fmt::float::float_to_decimal_common_exact+0xd1a>
+ 8003536: 586a ldr r2, [r5, r1]
+ 8003538: f85e 6001 ldr.w r6, [lr, r1]
+ Ordering::Equal => (),
+ 800353c: 3904 subs r1, #4
+ 800353e: 42b2 cmp r2, r6
+ 8003540: d0f6 beq.n 8003530 <core::fmt::float::float_to_decimal_common_exact+0xcfc>
+ 8003542: d204 bcs.n 800354e <core::fmt::float::float_to_decimal_common_exact+0xd1a>
+ let sz = cmp::max(self.size, other.size);
+ 8003544: 4603 mov r3, r0
+ 8003546: e02f b.n 80035a8 <core::fmt::float::float_to_decimal_common_exact+0xd74>
+ 8003548: d001 beq.n 800354e <core::fmt::float::float_to_decimal_common_exact+0xd1a>
+ 800354a: 4603 mov r3, r0
+ 800354c: e02c b.n 80035a8 <core::fmt::float::float_to_decimal_common_exact+0xd74>
+ 800354e: 2003 movs r0, #3
+ 8003550: ea40 0183 orr.w r1, r0, r3, lsl #2
+ 8003554: f343 001d sbfx r0, r3, #0, #30
+ 8003558: 2907 cmp r1, #7
+ 800355a: d321 bcc.n 80035a0 <core::fmt::float::float_to_decimal_common_exact+0xd6c>
+ 800355c: 2200 movs r2, #0
+ 800355e: 2501 movs r5, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 8003560: f854 6022 ldr.w r6, [r4, r2, lsl #2]
+ 8003564: f859 1022 ldr.w r1, [r9, r2, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8003568: f005 0501 and.w r5, r5, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 800356c: 43f6 mvns r6, r6
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 800356e: 440e add r6, r1
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8003570: 4435 add r5, r6
+ *a = v;
+ 8003572: f849 5022 str.w r5, [r9, r2, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8003576: 42b5 cmp r5, r6
+ 8003578: f04f 0501 mov.w r5, #1
+ self.index += 1;
+ 800357c: f102 0201 add.w r2, r2, #1
+ 8003580: bf28 it cs
+ 8003582: 2500 movcs r5, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8003584: 428e cmp r6, r1
+ 8003586: f04f 0101 mov.w r1, #1
+ 800358a: bf28 it cs
+ 800358c: 2100 movcs r1, #0
+ if self.index < self.len {
+ 800358e: 4282 cmp r2, r0
+ (carry1 || carry2, v)
+ 8003590: ea45 0501 orr.w r5, r5, r1
+ 8003594: d3e4 bcc.n 8003560 <core::fmt::float::float_to_decimal_common_exact+0xd2c>
+ assert!(noborrow);
+ 8003596: 2d00 cmp r5, #0
+ 8003598: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 800359c: f000 8209 beq.w 80039b2 <core::fmt::float::float_to_decimal_common_exact+0x117e>
+ if mant >= scale2 { mant.sub(&scale2); d += 2; }
+ 80035a0: f10c 0c02 add.w ip, ip, #2
+ self.size = sz;
+ 80035a4: f8cd 345c str.w r3, [sp, #1116] ; 0x45c
+ let sz = max(self.size, other.size);
+ 80035a8: f8dd e500 ldr.w lr, [sp, #1280] ; 0x500
+ 80035ac: 4618 mov r0, r3
+ 80035ae: 459e cmp lr, r3
+ 80035b0: bf28 it cs
+ 80035b2: 4670 movcs r0, lr
+ } else if self.end > slice.len() {
+ 80035b4: 2829 cmp r0, #41 ; 0x29
+ 80035b6: f080 820e bcs.w 80039d6 <core::fmt::float::float_to_decimal_common_exact+0x11a2>
+ loop {
+ 80035ba: 0081 lsls r1, r0, #2
+ if self.end == self.ptr {
+ 80035bc: 2900 cmp r1, #0
+ 80035be: d00a beq.n 80035d6 <core::fmt::float::float_to_decimal_common_exact+0xda2>
+ 80035c0: d00c beq.n 80035dc <core::fmt::float::float_to_decimal_common_exact+0xda8>
+ 80035c2: f50d 64a0 add.w r4, sp, #1280 ; 0x500
+ 80035c6: 586a ldr r2, [r5, r1]
+ 80035c8: 5864 ldr r4, [r4, r1]
+ Ordering::Equal => (),
+ 80035ca: 3904 subs r1, #4
+ 80035cc: 42a2 cmp r2, r4
+ 80035ce: d0f5 beq.n 80035bc <core::fmt::float::float_to_decimal_common_exact+0xd88>
+ 80035d0: d204 bcs.n 80035dc <core::fmt::float::float_to_decimal_common_exact+0xda8>
+ let mut sz = self.size;
+ 80035d2: 4618 mov r0, r3
+ 80035d4: e02f b.n 8003636 <core::fmt::float::float_to_decimal_common_exact+0xe02>
+ 80035d6: d001 beq.n 80035dc <core::fmt::float::float_to_decimal_common_exact+0xda8>
+ 80035d8: 4618 mov r0, r3
+ 80035da: e02c b.n 8003636 <core::fmt::float::float_to_decimal_common_exact+0xe02>
+ 80035dc: 2103 movs r1, #3
+ 80035de: f340 031d sbfx r3, r0, #0, #30
+ 80035e2: ea41 0180 orr.w r1, r1, r0, lsl #2
+ 80035e6: 2907 cmp r1, #7
+ 80035e8: d321 bcc.n 800362e <core::fmt::float::float_to_decimal_common_exact+0xdfa>
+ 80035ea: 2500 movs r5, #0
+ 80035ec: 2601 movs r6, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 80035ee: f85b 2025 ldr.w r2, [fp, r5, lsl #2]
+ 80035f2: f859 1025 ldr.w r1, [r9, r5, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80035f6: f006 0401 and.w r4, r6, #1
+ let (c, v) = (*a).full_add(!*b, noborrow);
+ 80035fa: 43d2 mvns r2, r2
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 80035fc: 440a add r2, r1
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 80035fe: 4414 add r4, r2
+ *a = v;
+ 8003600: f849 4025 str.w r4, [r9, r5, lsl #2]
+ intrinsics::add_with_overflow(v, if carry {1} else {0})
+ 8003604: 4294 cmp r4, r2
+ 8003606: f04f 0401 mov.w r4, #1
+ self.index += 1;
+ 800360a: f105 0501 add.w r5, r5, #1
+ 800360e: bf28 it cs
+ 8003610: 2400 movcs r4, #0
+ let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
+ 8003612: 428a cmp r2, r1
+ 8003614: f04f 0101 mov.w r1, #1
+ 8003618: bf28 it cs
+ 800361a: 2100 movcs r1, #0
+ if self.index < self.len {
+ 800361c: 429d cmp r5, r3
+ (carry1 || carry2, v)
+ 800361e: ea41 0604 orr.w r6, r1, r4
+ 8003622: d3e4 bcc.n 80035ee <core::fmt::float::float_to_decimal_common_exact+0xdba>
+ assert!(noborrow);
+ 8003624: 2e00 cmp r6, #0
+ 8003626: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 800362a: f000 81c2 beq.w 80039b2 <core::fmt::float::float_to_decimal_common_exact+0x117e>
+ if mant >= scale { mant.sub(&scale); d += 1; }
+ 800362e: f10c 0c01 add.w ip, ip, #1
+ self.size = sz;
+ 8003632: f8cd 045c str.w r0, [sp, #1116] ; 0x45c
+ debug_assert!(mant < scale);
+ debug_assert!(d < 10);
+ buf[i] = b'0' + d;
+ 8003636: 9915 ldr r1, [sp, #84] ; 0x54
+ 8003638: 9b13 ldr r3, [sp, #76] ; 0x4c
+ 800363a: 4654 mov r4, sl
+ 800363c: 428b cmp r3, r1
+ 800363e: f080 81cd bcs.w 80039dc <core::fmt::float::float_to_decimal_common_exact+0x11a8>
+ 8003642: f10c 0130 add.w r1, ip, #48 ; 0x30
+ 8003646: aa17 add r2, sp, #92 ; 0x5c
+ } else if self.end > slice.len() {
+ 8003648: 2829 cmp r0, #41 ; 0x29
+ 800364a: f04f 0a0a mov.w sl, #10
+ 800364e: 54d1 strb r1, [r2, r3]
+ 8003650: f080 81c8 bcs.w 80039e4 <core::fmt::float::float_to_decimal_common_exact+0x11b0>
+ if self.ptr == self.end {
+ 8003654: 2800 cmp r0, #0
+ 8003656: d019 beq.n 800368c <core::fmt::float::float_to_decimal_common_exact+0xe58>
+ intrinsics::offset(self, count) as *mut T
+ 8003658: eb05 0180 add.w r1, r5, r0, lsl #2
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 800365c: 0086 lsls r6, r0, #2
+ 800365e: 2500 movs r5, #0
+ 8003660: f101 0c04 add.w ip, r1, #4
+ 8003664: 4649 mov r1, r9
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8003666: 680a ldr r2, [r1, #0]
+ 8003668: 2300 movs r3, #0
+ if self.ptr == self.end {
+ 800366a: 3e04 subs r6, #4
+ 800366c: fbe2 530a umlal r5, r3, r2, sl
+ *a = v;
+ 8003670: f841 5b04 str.w r5, [r1], #4
+ 8003674: 461d mov r5, r3
+ 8003676: d1f6 bne.n 8003666 <core::fmt::float::float_to_decimal_common_exact+0xe32>
+ 8003678: b313 cbz r3, 80036c0 <core::fmt::float::float_to_decimal_common_exact+0xe8c>
+ self.base[sz] = carry;
+ 800367a: 2827 cmp r0, #39 ; 0x27
+ 800367c: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 8003680: f200 81db bhi.w 8003a3a <core::fmt::float::float_to_decimal_common_exact+0x1206>
+ sz += 1;
+ 8003684: 3001 adds r0, #1
+ self.base[sz] = carry;
+ 8003686: f8cc 3000 str.w r3, [ip]
+ 800368a: e01b b.n 80036c4 <core::fmt::float::float_to_decimal_common_exact+0xe90>
+ 800368c: 2000 movs r0, #0
+ 800368e: e019 b.n 80036c4 <core::fmt::float::float_to_decimal_common_exact+0xe90>
+ 8003690: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 8003694: 4653 mov r3, sl
+ while self.ptr != self.end {
+ 8003696: 2a00 cmp r2, #0
+ 8003698: d049 beq.n 800372e <core::fmt::float::float_to_decimal_common_exact+0xefa>
+ 800369a: f856 1b04 ldr.w r1, [r6], #4
+ 800369e: b119 cbz r1, 80036a8 <core::fmt::float::float_to_decimal_common_exact+0xe74>
+ 80036a0: 4619 mov r1, r3
+ SearchWhile::Done(false)
+ 80036a2: f807 ec1d strb.w lr, [r7, #-29]
+ 80036a6: e001 b.n 80036ac <core::fmt::float::float_to_decimal_common_exact+0xe78>
+ 80036a8: f1a7 011d sub.w r1, r7, #29
+ 80036ac: 2400 movs r4, #0
+ search_while!(g($mkref!(self.ptr.post_inc())));
+ 80036ae: 3a04 subs r2, #4
+ 80036b0: 700c strb r4, [r1, #0]
+ })
+ 80036b2: f817 1c1d ldrb.w r1, [r7, #-29]
+ search_while!(g($mkref!(self.ptr.post_inc())));
+ 80036b6: 2900 cmp r1, #0
+ 80036b8: d0ed beq.n 8003696 <core::fmt::float::float_to_decimal_common_exact+0xe62>
+ })
+ 80036ba: f817 2c1e ldrb.w r2, [r7, #-30]
+ 80036be: e693 b.n 80033e8 <core::fmt::float::float_to_decimal_common_exact+0xbb4>
+ 80036c0: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 80036c4: 9914 ldr r1, [sp, #80] ; 0x50
+ 80036c6: 9a12 ldr r2, [sp, #72] ; 0x48
+ self.size = sz;
+ 80036c8: f8cd 045c str.w r0, [sp, #1116] ; 0x45c
+ 80036cc: 4291 cmp r1, r2
+ 80036ce: 4611 mov r1, r2
+ 80036d0: f63f ae37 bhi.w 8003342 <core::fmt::float::float_to_decimal_common_exact+0xb0e>
+ 80036d4: 9c14 ldr r4, [sp, #80] ; 0x50
+ 80036d6: 2100 movs r1, #0
+ 80036d8: e5ef b.n 80032ba <core::fmt::float::float_to_decimal_common_exact+0xa86>
+ 80036da: e9dd 8902 ldrd r8, r9, [sp, #8]
+ } else if self.end > slice.len() {
+ 80036de: f1be 0f29 cmp.w lr, #41 ; 0x29
+ 80036e2: f080 81a3 bcs.w 8003a2c <core::fmt::float::float_to_decimal_common_exact+0x11f8>
+ 80036e6: 2300 movs r3, #0
+ if self.ptr == self.end {
+ 80036e8: f1be 0f00 cmp.w lr, #0
+ 80036ec: d033 beq.n 8003756 <core::fmt::float::float_to_decimal_common_exact+0xf22>
+ 80036ee: f50d 61a0 add.w r1, sp, #1280 ; 0x500
+// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
+ 80036f2: ea4f 068e mov.w r6, lr, lsl #2
+ 80036f6: 2505 movs r5, #5
+ 80036f8: eb01 018e add.w r1, r1, lr, lsl #2
+ 80036fc: f101 0c04 add.w ip, r1, #4
+ let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);
+ 8003700: f8db 2000 ldr.w r2, [fp]
+ 8003704: 2100 movs r1, #0
+ if self.ptr == self.end {
+ 8003706: 3e04 subs r6, #4
+ 8003708: fbe2 3105 umlal r3, r1, r2, r5
+ *a = v;
+ 800370c: f84b 3b04 str.w r3, [fp], #4
+ 8003710: 460b mov r3, r1
+ 8003712: d1f5 bne.n 8003700 <core::fmt::float::float_to_decimal_common_exact+0xecc>
+ if carry > 0 {
+ 8003714: 2900 cmp r1, #0
+ 8003716: f20d 455c addw r5, sp, #1116 ; 0x45c
+ 800371a: d01b beq.n 8003754 <core::fmt::float::float_to_decimal_common_exact+0xf20>
+ self.base[sz] = carry;
+ 800371c: f1be 0f27 cmp.w lr, #39 ; 0x27
+ 8003720: f200 81a8 bhi.w 8003a74 <core::fmt::float::float_to_decimal_common_exact+0x1240>
+ sz += 1;
+ 8003724: f10e 0301 add.w r3, lr, #1
+ self.base[sz] = carry;
+ 8003728: f8cc 1000 str.w r1, [ip]
+ 800372c: e013 b.n 8003756 <core::fmt::float::float_to_decimal_common_exact+0xf22>
+ 800372e: e9dd 4114 ldrd r4, r1, [sp, #80] ; 0x50
+ } else if self.end > slice.len() {
+ 8003732: 428c cmp r4, r1
+ 8003734: f200 81a2 bhi.w 8003a7c <core::fmt::float::float_to_decimal_common_exact+0x1248>
+ 8003738: 9a13 ldr r2, [sp, #76] ; 0x4c
+ 800373a: e9dd 8902 ldrd r8, r9, [sp, #8]
+ 800373e: 9e0b ldr r6, [sp, #44] ; 0x2c
+ from_raw_parts_mut(slice.as_mut_ptr().offset(self.start as isize), self.end - self.start)
+ 8003740: 1aa1 subs r1, r4, r2
+ 8003742: d004 beq.n 800374e <core::fmt::float::float_to_decimal_common_exact+0xf1a>
+ 8003744: a817 add r0, sp, #92 ; 0x5c
+ 8003746: 4410 add r0, r2
+ for c in &mut buf[i..len] { *c = b'0'; }
+ 8003748: 2230 movs r2, #48 ; 0x30
+ 800374a: f000 f9ea bl 8003b22 <__aeabi_memset>
+ 800374e: f8dd e01c ldr.w lr, [sp, #28]
+ 8003752: e055 b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 8003754: 4673 mov r3, lr
+ 8003756: 4283 cmp r3, r0
+ self.size = sz;
+ 8003758: f8cd 3500 str.w r3, [sp, #1280] ; 0x500
+ 800375c: bf28 it cs
+ 800375e: 4618 movcs r0, r3
+ 8003760: f8dd e01c ldr.w lr, [sp, #28]
+ } else if self.end > slice.len() {
+ 8003764: 2829 cmp r0, #41 ; 0x29
+ 8003766: f080 8165 bcs.w 8003a34 <core::fmt::float::float_to_decimal_common_exact+0x1200>
+ loop {
+ 800376a: 0080 lsls r0, r0, #2
+ if self.end == self.ptr {
+ 800376c: 2800 cmp r0, #0
+ 800376e: d009 beq.n 8003784 <core::fmt::float::float_to_decimal_common_exact+0xf50>
+ 8003770: d014 beq.n 800379c <core::fmt::float::float_to_decimal_common_exact+0xf68>
+ 8003772: f50d 62a0 add.w r2, sp, #1280 ; 0x500
+ 8003776: 5829 ldr r1, [r5, r0]
+ 8003778: 5812 ldr r2, [r2, r0]
+ Ordering::Equal => (),
+ 800377a: 3804 subs r0, #4
+ 800377c: 4291 cmp r1, r2
+ 800377e: d0f5 beq.n 800376c <core::fmt::float::float_to_decimal_common_exact+0xf38>
+ 8003780: d20c bcs.n 800379c <core::fmt::float::float_to_decimal_common_exact+0xf68>
+ 8003782: e03c b.n 80037fe <core::fmt::float::float_to_decimal_common_exact+0xfca>
+ 8003784: d13b bne.n 80037fe <core::fmt::float::float_to_decimal_common_exact+0xfca>
+ // rounding up if we stop in the middle of digits
+ // if the following digits are exactly 5000..., check the prior digit and try to
+ // round to even (i.e. avoid rounding up when the prior digit is even).
+ let order = mant.cmp(scale.mul_small(5));
+ if order == Ordering::Greater || (order == Ordering::Equal &&
+ (len == 0 || buf[len-1] & 1 == 1)) {
+ 8003786: 9813 ldr r0, [sp, #76] ; 0x4c
+ 8003788: b940 cbnz r0, 800379c <core::fmt::float::float_to_decimal_common_exact+0xf68>
+ &(*slice)[self]
+ 800378a: 9915 ldr r1, [sp, #84] ; 0x54
+ 800378c: 1e60 subs r0, r4, #1
+ 800378e: 4288 cmp r0, r1
+ 8003790: f080 817e bcs.w 8003a90 <core::fmt::float::float_to_decimal_common_exact+0x125c>
+ 8003794: a917 add r1, sp, #92 ; 0x5c
+ 8003796: 5c08 ldrb r0, [r1, r0]
+ if order == Ordering::Greater || (order == Ordering::Equal &&
+ 8003798: 07c0 lsls r0, r0, #31
+ 800379a: d030 beq.n 80037fe <core::fmt::float::float_to_decimal_common_exact+0xfca>
+ // if rounding up changes the length, the exponent should also change.
+ // but we've been requested a fixed number of digits, so do not alter the buffer...
+ if let Some(c) = round_up(buf, len) {
+ 800379c: 9915 ldr r1, [sp, #84] ; 0x54
+ 800379e: ad17 add r5, sp, #92 ; 0x5c
+ 80037a0: 4622 mov r2, r4
+ 80037a2: 4628 mov r0, r5
+ 80037a4: f7fd fa2f bl 8000c06 <core::num::flt2dec::round_up>
+ 80037a8: f3c0 2107 ubfx r1, r0, #8, #8
+ 80037ac: b2c0 uxtb r0, r0
+ 80037ae: 2801 cmp r0, #1
+ 80037b0: d123 bne.n 80037fa <core::fmt::float::float_to_decimal_common_exact+0xfc6>
+ // ...unless we've been requested the fixed precision instead.
+ // we also need to check that, if the original buffer was empty,
+ // the additional digit can only be added when `k == limit` (edge case).
+ k += 1;
+ 80037b2: 9809 ldr r0, [sp, #36] ; 0x24
+ 80037b4: f8dd e01c ldr.w lr, [sp, #28]
+ 80037b8: 3001 adds r0, #1
+ 80037ba: b202 sxth r2, r0
+ if k > limit && len < buf.len() {
+ 80037bc: 980b ldr r0, [sp, #44] ; 0x2c
+ 80037be: 9209 str r2, [sp, #36] ; 0x24
+ 80037c0: 4282 cmp r2, r0
+ 80037c2: dd1c ble.n 80037fe <core::fmt::float::float_to_decimal_common_exact+0xfca>
+ 80037c4: 9815 ldr r0, [sp, #84] ; 0x54
+ 80037c6: 4284 cmp r4, r0
+ buf[len] = c;
+ 80037c8: bf3c itt cc
+ 80037ca: 5529 strbcc r1, [r5, r4]
+ len += 1;
+ 80037cc: 3401 addcc r4, #1
+ 80037ce: e016 b.n 80037fe <core::fmt::float::float_to_decimal_common_exact+0xfca>
+ 80037d0: f8dd e01c ldr.w lr, [sp, #28]
+ 80037d4: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 80037d6: e9dd 8902 ldrd r8, r9, [sp, #8]
+ 80037da: 2400 movs r4, #0
+ 80037dc: e010 b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 80037de: e9dd 8902 ldrd r8, r9, [sp, #8]
+ 80037e2: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 80037e4: 465c mov r4, fp
+ 80037e6: e00b b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 80037e8: e9dd 8902 ldrd r8, r9, [sp, #8]
+ 80037ec: f8dd e01c ldr.w lr, [sp, #28]
+ 80037f0: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 80037f2: 9c14 ldr r4, [sp, #80] ; 0x50
+ 80037f4: e004 b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 80037f6: e9dd 8902 ldrd r8, r9, [sp, #8]
+ 80037fa: f8dd e01c ldr.w lr, [sp, #28]
+ 80037fe: 9e0b ldr r6, [sp, #44] ; 0x2c
+ let (len, exp) = format_exact(decoded, &mut buf[..maxlen], limit);
+ if exp <= limit {
+ 8003800: 9809 ldr r0, [sp, #36] ; 0x24
+ 8003802: b200 sxth r0, r0
+ 8003804: 42b0 cmp r0, r6
+ 8003806: dd30 ble.n 800386a <core::fmt::float::float_to_decimal_common_exact+0x1036>
+ } else if self.end > slice.len() {
+ 8003808: f5b4 6f80 cmp.w r4, #1024 ; 0x400
+ 800380c: f200 8118 bhi.w 8003a40 <core::fmt::float::float_to_decimal_common_exact+0x120c>
+ assert!(!buf.is_empty());
+ 8003810: 2c00 cmp r4, #0
+ 8003812: f000 811a beq.w 8003a4a <core::fmt::float::float_to_decimal_common_exact+0x1216>
+ assert!(buf[0] > b'0');
+ 8003816: f89d 105c ldrb.w r1, [sp, #92] ; 0x5c
+ 800381a: 2930 cmp r1, #48 ; 0x30
+ 800381c: f240 811b bls.w 8003a56 <core::fmt::float::float_to_decimal_common_exact+0x1222>
+ if exp <= 0 {
+ 8003820: 2801 cmp r0, #1
+ 8003822: db3e blt.n 80038a2 <core::fmt::float::float_to_decimal_common_exact+0x106e>
+ 8003824: 2102 movs r1, #2
+ 8003826: aa17 add r2, sp, #92 ; 0x5c
+ if exp < buf.len() {
+ 8003828: 42a0 cmp r0, r4
+ 800382a: f827 1cc4 strh.w r1, [r7, #-196]
+ 800382e: f847 2cc0 str.w r2, [r7, #-192]
+ 8003832: d25b bcs.n 80038ec <core::fmt::float::float_to_decimal_common_exact+0x10b8>
+ parts[1] = Part::Copy(b".");
+ 8003834: f644 2386 movw r3, #19078 ; 0x4a86
+ parts[0] = Part::Copy(&buf[..exp]);
+ 8003838: f847 0cbc str.w r0, [r7, #-188]
+ parts[1] = Part::Copy(b".");
+ 800383c: f827 1cb8 strh.w r1, [r7, #-184]
+ 8003840: f6c0 0300 movt r3, #2048 ; 0x800
+ 8003844: f847 3cb4 str.w r3, [r7, #-180]
+ 8003848: 2301 movs r3, #1
+ 800384a: f847 3cb0 str.w r3, [r7, #-176]
+ parts[2] = Part::Copy(&buf[exp..]);
+ 800384e: f827 1cac strh.w r1, [r7, #-172]
+ intrinsics::offset(self, count)
+ 8003852: 1811 adds r1, r2, r0
+ 8003854: f847 1ca8 str.w r1, [r7, #-168]
+ from_raw_parts(slice.as_ptr().offset(self.start as isize), self.end - self.start)
+ 8003858: 1a21 subs r1, r4, r0
+ if frac_digits > buf.len() - exp {
+ 800385a: 4541 cmp r1, r8
+ parts[2] = Part::Copy(&buf[exp..]);
+ 800385c: f847 1ca4 str.w r1, [r7, #-164]
+ 8003860: d242 bcs.n 80038e8 <core::fmt::float::float_to_decimal_common_exact+0x10b4>
+ parts[3] = Part::Zero(frac_digits - (buf.len() - exp));
+ 8003862: 4440 add r0, r8
+ 8003864: 2100 movs r1, #0
+ 8003866: 1b00 subs r0, r0, r4
+ 8003868: e039 b.n 80038de <core::fmt::float::float_to_decimal_common_exact+0x10aa>
+ 800386a: 2002 movs r0, #2
+ // the restriction couldn't been met, so this should render like zero no matter
+ // `exp` was. this does not include the case that the restriction has been met
+ // only after the final rounding-up; it's a regular case with `exp = limit + 1`.
+ debug_assert_eq!(len, 0);
+ if frac_digits > 0 { // [0.][0000]
+ 800386c: f1b8 0f00 cmp.w r8, #0
+ 8003870: f827 0cc4 strh.w r0, [r7, #-196]
+ 8003874: d00b beq.n 800388e <core::fmt::float::float_to_decimal_common_exact+0x105a>
+ parts[0] = Part::Copy(b"0.");
+ 8003876: f644 2184 movw r1, #19076 ; 0x4a84
+ 800387a: f6c0 0100 movt r1, #2048 ; 0x800
+ 800387e: e947 1030 strd r1, r0, [r7, #-192] ; 0xc0
+ parts[1] = Part::Zero(frac_digits);
+ 8003882: 2100 movs r1, #0
+ 8003884: f827 1cb8 strh.w r1, [r7, #-184]
+ 8003888: f847 8cb4 str.w r8, [r7, #-180]
+ 800388c: e04b b.n 8003926 <core::fmt::float::float_to_decimal_common_exact+0x10f2>
+ Formatted { sign: sign, parts: &parts[..2] }
+ } else {
+ parts[0] = Part::Copy(b"0");
+ 800388e: f644 306e movw r0, #19310 ; 0x4b6e
+ 8003892: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003896: f847 0cc0 str.w r0, [r7, #-192]
+ 800389a: 2001 movs r0, #1
+ 800389c: f847 0cbc str.w r0, [r7, #-188]
+ 80038a0: e041 b.n 8003926 <core::fmt::float::float_to_decimal_common_exact+0x10f2>
+ parts[0] = Part::Copy(b"0.");
+ 80038a2: f644 2184 movw r1, #19076 ; 0x4a84
+ 80038a6: 2202 movs r2, #2
+ if frac_digits > buf.len() && frac_digits - buf.len() > minus_exp {
+ 80038a8: 4544 cmp r4, r8
+ parts[0] = Part::Copy(b"0.");
+ 80038aa: f6c0 0100 movt r1, #2048 ; 0x800
+ 80038ae: f827 2cc4 strh.w r2, [r7, #-196]
+ 80038b2: e947 1230 strd r1, r2, [r7, #-192] ; 0xc0
+ 80038b6: f04f 0100 mov.w r1, #0
+ parts[1] = Part::Zero(minus_exp);
+ 80038ba: f827 1cb8 strh.w r1, [r7, #-184]
+ let minus_exp = -(exp as i32) as usize;
+ 80038be: f1c0 0100 rsb r1, r0, #0
+ parts[1] = Part::Zero(minus_exp);
+ 80038c2: f847 1cb4 str.w r1, [r7, #-180]
+ parts[2] = Part::Copy(buf);
+ 80038c6: f827 2cac strh.w r2, [r7, #-172]
+ 80038ca: aa17 add r2, sp, #92 ; 0x5c
+ 80038cc: e947 242a strd r2, r4, [r7, #-168] ; 0xa8
+ 80038d0: d20a bcs.n 80038e8 <core::fmt::float::float_to_decimal_common_exact+0x10b4>
+ if frac_digits > buf.len() && frac_digits - buf.len() > minus_exp {
+ 80038d2: eba8 0204 sub.w r2, r8, r4
+ 80038d6: 428a cmp r2, r1
+ 80038d8: d906 bls.n 80038e8 <core::fmt::float::float_to_decimal_common_exact+0x10b4>
+ parts[3] = Part::Zero((frac_digits - buf.len()) - minus_exp);
+ 80038da: 2100 movs r1, #0
+ 80038dc: 4410 add r0, r2
+ 80038de: f827 1ca0 strh.w r1, [r7, #-160]
+ 80038e2: f847 0c9c str.w r0, [r7, #-156]
+ 80038e6: e01d b.n 8003924 <core::fmt::float::float_to_decimal_common_exact+0x10f0>
+ 80038e8: 2003 movs r0, #3
+ 80038ea: e01c b.n 8003926 <core::fmt::float::float_to_decimal_common_exact+0x10f2>
+ 80038ec: 2100 movs r1, #0
+ parts[1] = Part::Zero(exp - buf.len());
+ 80038ee: 1b00 subs r0, r0, r4
+ parts[0] = Part::Copy(buf);
+ 80038f0: f847 4cbc str.w r4, [r7, #-188]
+ if frac_digits > 0 {
+ 80038f4: f1b8 0f00 cmp.w r8, #0
+ parts[1] = Part::Zero(exp - buf.len());
+ 80038f8: f827 1cb8 strh.w r1, [r7, #-184]
+ 80038fc: f847 0cb4 str.w r0, [r7, #-180]
+ 8003900: f04f 0002 mov.w r0, #2
+ 8003904: d00f beq.n 8003926 <core::fmt::float::float_to_decimal_common_exact+0x10f2>
+ parts[2] = Part::Copy(b".");
+ 8003906: f827 0cac strh.w r0, [r7, #-172]
+ 800390a: f644 2086 movw r0, #19078 ; 0x4a86
+ 800390e: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003912: f847 0ca8 str.w r0, [r7, #-168]
+ 8003916: 2001 movs r0, #1
+ 8003918: f847 0ca4 str.w r0, [r7, #-164]
+ parts[3] = Part::Zero(frac_digits);
+ 800391c: f827 1ca0 strh.w r1, [r7, #-160]
+ 8003920: f847 8c9c str.w r8, [r7, #-156]
+ 8003924: 2004 movs r0, #4
+ 8003926: 9b0c ldr r3, [sp, #48] ; 0x30
+ 8003928: f1a7 01c4 sub.w r1, r7, #196 ; 0xc4
+ 800392c: f8cd e648 str.w lr, [sp, #1608] ; 0x648
+ 8003930: f8cd 364c str.w r3, [sp, #1612] ; 0x64c
+ 8003934: f8cd 1650 str.w r1, [sp, #1616] ; 0x650
+ 8003938: f8cd 0654 str.w r0, [sp, #1620] ; 0x654
+ 800393c: f50d 61c9 add.w r1, sp, #1608 ; 0x648
+ fmt.pad_formatted_parts(&formatted)
+ 8003940: 4648 mov r0, r9
+ 8003942: f7fd fb6d bl 8001020 <core::fmt::Formatter::pad_formatted_parts>
+}
+ 8003946: f50d 6df2 add.w sp, sp, #1936 ; 0x790
+ 800394a: b001 add sp, #4
+ 800394c: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8003950: bdf0 pop {r4, r5, r6, r7, pc}
+ 8003952: f8dd a054 ldr.w sl, [sp, #84] ; 0x54
+ 8003956: 9c14 ldr r4, [sp, #80] ; 0x50
+ 8003958: f10d 085c add.w r8, sp, #92 ; 0x5c
+ if let Some(c) = round_up(buf, len) {
+ 800395c: 4640 mov r0, r8
+ 800395e: 4651 mov r1, sl
+ 8003960: 4622 mov r2, r4
+ 8003962: f7fd f950 bl 8000c06 <core::num::flt2dec::round_up>
+ 8003966: f3c0 2107 ubfx r1, r0, #8, #8
+ 800396a: e9dd 2902 ldrd r2, r9, [sp, #8]
+ 800396e: b2c0 uxtb r0, r0
+ 8003970: 2801 cmp r0, #1
+ 8003972: d10f bne.n 8003994 <core::fmt::float::float_to_decimal_common_exact+0x1160>
+ exp += 1;
+ 8003974: 9800 ldr r0, [sp, #0]
+ 8003976: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 8003978: f8dd e01c ldr.w lr, [sp, #28]
+ 800397c: 3002 adds r0, #2
+ 800397e: b200 sxth r0, r0
+ if exp > limit && len < buf.len() {
+ 8003980: 42b0 cmp r0, r6
+ 8003982: 9009 str r0, [sp, #36] ; 0x24
+ 8003984: dd0d ble.n 80039a2 <core::fmt::float::float_to_decimal_common_exact+0x116e>
+ 8003986: 4554 cmp r4, sl
+ buf[len] = c;
+ 8003988: bf3c itt cc
+ 800398a: f808 1004 strbcc.w r1, [r8, r4]
+ len += 1;
+ 800398e: 3401 addcc r4, #1
+ 8003990: 4690 mov r8, r2
+ 8003992: e735 b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 8003994: f8dd e01c ldr.w lr, [sp, #28]
+ 8003998: 9e0b ldr r6, [sp, #44] ; 0x2c
+ 800399a: 4690 mov r8, r2
+ 800399c: e730 b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 800399e: 4680 mov r8, r0
+ 80039a0: e72e b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ 80039a2: 4690 mov r8, r2
+ 80039a4: e72c b.n 8003800 <core::fmt::float::float_to_decimal_common_exact+0xfcc>
+ base[sz] = v as $ty;
+ 80039a6: 2128 movs r1, #40 ; 0x28
+ 80039a8: f7fc fdcd bl 8000546 <core::panicking::panic_bounds_check>
+ buf[i] = b'0' + q as u8;
+ 80039ac: 9915 ldr r1, [sp, #84] ; 0x54
+ 80039ae: f7fc fdca bl 8000546 <core::panicking::panic_bounds_check>
+ 80039b2: f244 500c movw r0, #17676 ; 0x450c
+ 80039b6: f6c0 0000 movt r0, #2048 ; 0x800
+ 80039ba: f7fd f89a bl 8000af2 <core::panicking::panic>
+ 80039be: 4608 mov r0, r1
+ 80039c0: 2128 movs r1, #40 ; 0x28
+ 80039c2: f7fc fdbc bl 800053e <core::slice::slice_index_len_fail>
+ slice_index_len_fail(self.end, slice.len());
+ 80039c6: 2128 movs r1, #40 ; 0x28
+ 80039c8: f7fc fdb9 bl 800053e <core::slice::slice_index_len_fail>
+ 80039cc: 4610 mov r0, r2
+ 80039ce: 2128 movs r1, #40 ; 0x28
+ 80039d0: f7fc fdb5 bl 800053e <core::slice::slice_index_len_fail>
+ 80039d4: 4618 mov r0, r3
+ 80039d6: 2128 movs r1, #40 ; 0x28
+ 80039d8: f7fc fdb1 bl 800053e <core::slice::slice_index_len_fail>
+ buf[i] = b'0' + d;
+ 80039dc: 9915 ldr r1, [sp, #84] ; 0x54
+ 80039de: 4618 mov r0, r3
+ 80039e0: f7fc fdb1 bl 8000546 <core::panicking::panic_bounds_check>
+ slice_index_len_fail(self.end, slice.len());
+ 80039e4: 2128 movs r1, #40 ; 0x28
+ 80039e6: f7fc fdaa bl 800053e <core::slice::slice_index_len_fail>
+ assert!(buf.len() >= maxlen);
+ 80039ea: f644 3070 movw r0, #19312 ; 0x4b70
+ 80039ee: f6c0 0000 movt r0, #2048 ; 0x800
+ 80039f2: f7fd f87e bl 8000af2 <core::panicking::panic>
+ assert!(d.mant > 0);
+ 80039f6: f644 10b0 movw r0, #18864 ; 0x49b0
+ 80039fa: f6c0 0000 movt r0, #2048 ; 0x800
+ 80039fe: f7fd f878 bl 8000af2 <core::panicking::panic>
+ assert!(d.mant < (1 << 61)); // we need at least three bits of additional precision
+ 8003a02: f644 10c8 movw r0, #18888 ; 0x49c8
+ 8003a06: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003a0a: f7fd f872 bl 8000af2 <core::panicking::panic>
+ let (f, e, k) = CACHED_POW10[idx as usize];
+ 8003a0e: 2151 movs r1, #81 ; 0x51
+ 8003a10: f7fc fd99 bl 8000546 <core::panicking::panic_bounds_check>
+ assert!(d.mant.checked_add(d.plus).is_some());
+ 8003a14: f244 7064 movw r0, #18276 ; 0x4764
+ 8003a18: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003a1c: f7fd f869 bl 8000af2 <core::panicking::panic>
+ assert!(d.mant.checked_sub(d.minus).is_some());
+ 8003a20: f244 707c movw r0, #18300 ; 0x477c
+ 8003a24: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003a28: f7fd f863 bl 8000af2 <core::panicking::panic>
+ 8003a2c: 4670 mov r0, lr
+ 8003a2e: 2128 movs r1, #40 ; 0x28
+ 8003a30: f7fc fd85 bl 800053e <core::slice::slice_index_len_fail>
+ slice_index_len_fail(self.end, slice.len());
+ 8003a34: 2128 movs r1, #40 ; 0x28
+ 8003a36: f7fc fd82 bl 800053e <core::slice::slice_index_len_fail>
+ self.base[sz] = carry;
+ 8003a3a: 2128 movs r1, #40 ; 0x28
+ 8003a3c: f7fc fd83 bl 8000546 <core::panicking::panic_bounds_check>
+ 8003a40: 4620 mov r0, r4
+ 8003a42: f44f 6180 mov.w r1, #1024 ; 0x400
+ 8003a46: f7fc fd7a bl 800053e <core::slice::slice_index_len_fail>
+ assert!(!buf.is_empty());
+ 8003a4a: f644 2054 movw r0, #19028 ; 0x4a54
+ 8003a4e: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003a52: f7fd f84e bl 8000af2 <core::panicking::panic>
+ assert!(buf[0] > b'0');
+ 8003a56: f644 206c movw r0, #19052 ; 0x4a6c
+ 8003a5a: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003a5e: f7fd f848 bl 8000af2 <core::panicking::panic>
+ assert!(d.plus > 0);
+ 8003a62: f244 704c movw r0, #18252 ; 0x474c
+ 8003a66: f6c0 0000 movt r0, #2048 ; 0x800
+ 8003a6a: f7fd f842 bl 8000af2 <core::panicking::panic>
+ slice_index_len_fail(self.end, slice.len());
+ 8003a6e: 2128 movs r1, #40 ; 0x28
+ 8003a70: f7fc fd65 bl 800053e <core::slice::slice_index_len_fail>
+ 8003a74: 4670 mov r0, lr
+ 8003a76: 2128 movs r1, #40 ; 0x28
+ 8003a78: f7fc fd65 bl 8000546 <core::panicking::panic_bounds_check>
+ 8003a7c: 4620 mov r0, r4
+ 8003a7e: f7fc fd5e bl 800053e <core::slice::slice_index_len_fail>
+ self.base[sz] = 1;
+ 8003a82: 4608 mov r0, r1
+ 8003a84: 2128 movs r1, #40 ; 0x28
+ 8003a86: f7fc fd5e bl 8000546 <core::panicking::panic_bounds_check>
+ self.base[sz] = carry;
+ 8003a8a: 2128 movs r1, #40 ; 0x28
+ 8003a8c: f7fc fd5b bl 8000546 <core::panicking::panic_bounds_check>
+ &(*slice)[self]
+ 8003a90: 9915 ldr r1, [sp, #84] ; 0x54
+ 8003a92: f7fc fd58 bl 8000546 <core::panicking::panic_bounds_check>
+
+08003a96 <core::fmt::float::<impl core::fmt::Display for f64>::fmt>:
+ pub fn sign_plus(&self) -> bool { self.flags & (1 << FlagV1::SignPlus as u32) != 0 }
+ 8003a96: 680a ldr r2, [r1, #0]
+ (false, true) => flt2dec::Sign::MinusRaw,
+ (true, false) => flt2dec::Sign::MinusPlus,
+ (true, true) => flt2dec::Sign::MinusPlusRaw,
+ };
+
+ if let Some(precision) = fmt.precision {
+ 8003a98: 690b ldr r3, [r1, #16]
+ 8003a9a: ed90 0b00 vldr d0, [r0]
+ 8003a9e: f002 0001 and.w r0, r2, #1
+ 8003aa2: 2b01 cmp r3, #1
+ (false, false) => flt2dec::Sign::Minus,
+ 8003aa4: ea4f 0c40 mov.w ip, r0, lsl #1
+ 8003aa8: d104 bne.n 8003ab4 <core::fmt::float::<impl core::fmt::Display for f64>::fmt+0x1e>
+ if let Some(precision) = fmt.precision {
+ 8003aaa: 694a ldr r2, [r1, #20]
+ float_to_decimal_common_exact(fmt, num, sign, precision)
+ 8003aac: 4608 mov r0, r1
+ 8003aae: 4661 mov r1, ip
+ 8003ab0: f7fe bec0 b.w 8002834 <core::fmt::float::float_to_decimal_common_exact>
+ } else {
+ float_to_decimal_common_shortest(fmt, num, sign)
+ 8003ab4: 4608 mov r0, r1
+ 8003ab6: 4661 mov r1, ip
+ 8003ab8: f7fd bc93 b.w 80013e2 <core::fmt::float::float_to_decimal_common_shortest>
+
+08003abc <__aeabi_uldivmod>:
+}
+
+#[naked]
+#[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+pub unsafe fn __aeabi_uldivmod() {
+ asm!("push {r4, lr}
+ 8003abc: b510 push {r4, lr}
+ 8003abe: b084 sub sp, #16
+ 8003ac0: ac02 add r4, sp, #8
+ 8003ac2: 9400 str r4, [sp, #0]
+ 8003ac4: f000 f859 bl 8003b7a <__udivmoddi4>
+ 8003ac8: 9a02 ldr r2, [sp, #8]
+ 8003aca: 9b03 ldr r3, [sp, #12]
+ 8003acc: b004 add sp, #16
+ 8003ace: bd10 pop {r4, pc}
+
+08003ad0 <__aeabi_memcpy>:
+pub unsafe extern "C" fn memcpy(dest: *mut u8,
+ src: *const u8,
+ n: usize)
+ -> *mut u8 {
+ let mut i = 0;
+ while i < n {
+ 8003ad0: 2a00 cmp r2, #0
+#[cfg(not(target_os = "ios"))]
+#[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+#[cfg_attr(thumb, linkage = "weak")]
+pub unsafe extern "aapcs" fn __aeabi_memcpy(dest: *mut u8, src: *const u8, n: usize) {
+ ::mem::memcpy(dest, src, n);
+}
+ 8003ad2: bf08 it eq
+ 8003ad4: 4770 bxeq lr
+ *dest.offset(i as isize) = *src.offset(i as isize);
+ 8003ad6: f811 3b01 ldrb.w r3, [r1], #1
+ while i < n {
+ 8003ada: 3a01 subs r2, #1
+ *dest.offset(i as isize) = *src.offset(i as isize);
+ 8003adc: f800 3b01 strb.w r3, [r0], #1
+ 8003ae0: d1f9 bne.n 8003ad6 <__aeabi_memcpy+0x6>
+ 8003ae2: 4770 bx lr
+
+08003ae4 <__aeabi_memcpy4>:
+
+#[cfg(not(target_os = "ios"))]
+#[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+#[cfg_attr(thumb, linkage = "weak")]
+pub unsafe extern "aapcs" fn __aeabi_memcpy4(dest: *mut u8, src: *const u8, mut n: usize) {
+ 8003ae4: 468c mov ip, r1
+ 8003ae6: 4603 mov r3, r0
+ use core::ptr;
+
+ let mut dest = dest as *mut u32;
+ let mut src = src as *mut u32;
+
+ while n >= 4 {
+ 8003ae8: 2a04 cmp r2, #4
+ 8003aea: d316 bcc.n 8003b1a <__aeabi_memcpy4+0x36>
+ 8003aec: b5b0 push {r4, r5, r7, lr}
+ 8003aee: af02 add r7, sp, #8
+ 8003af0: f1a2 0e04 sub.w lr, r2, #4
+ 8003af4: f02e 0403 bic.w r4, lr, #3
+ 8003af8: 1d20 adds r0, r4, #4
+ 8003afa: eb0c 0100 add.w r1, ip, r0
+ 8003afe: 4418 add r0, r3
+ 8003b00: f85c 5b04 ldr.w r5, [ip], #4
+ ptr::write(dest, ptr::read(src));
+ dest = dest.offset(1);
+ src = src.offset(1);
+ n -= 4;
+ 8003b04: 3a04 subs r2, #4
+ while n >= 4 {
+ 8003b06: 2a03 cmp r2, #3
+ intrinsics::move_val_init(&mut *dst, src)
+ 8003b08: f843 5b04 str.w r5, [r3], #4
+ 8003b0c: d8f8 bhi.n 8003b00 <__aeabi_memcpy4+0x1c>
+ 8003b0e: ebae 0204 sub.w r2, lr, r4
+ 8003b12: e8bd 40b0 ldmia.w sp!, {r4, r5, r7, lr}
+ }
+
+ __aeabi_memcpy(dest as *mut u8, src as *const u8, n);
+ 8003b16: f7ff bfdb b.w 8003ad0 <__aeabi_memcpy>
+ 8003b1a: 4618 mov r0, r3
+ 8003b1c: 4661 mov r1, ip
+ 8003b1e: f7ff bfd7 b.w 8003ad0 <__aeabi_memcpy>
+
+08003b22 <__aeabi_memset>:
+}
+
+#[cfg_attr(all(feature = "mem", not(feature = "mangled-names")), no_mangle)]
+pub unsafe extern "C" fn memset(s: *mut u8, c: c_int, n: usize) -> *mut u8 {
+ let mut i = 0;
+ while i < n {
+ 8003b22: 2900 cmp r1, #0
+#[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+#[cfg_attr(thumb, linkage = "weak")]
+pub unsafe extern "aapcs" fn __aeabi_memset(dest: *mut u8, n: usize, c: i32) {
+ // Note the different argument order
+ ::mem::memset(dest, c, n);
+}
+ 8003b24: bf08 it eq
+ 8003b26: 4770 bxeq lr
+ *s.offset(i as isize) = c as u8;
+ 8003b28: f800 2b01 strb.w r2, [r0], #1
+ while i < n {
+ 8003b2c: 3901 subs r1, #1
+ 8003b2e: d1fb bne.n 8003b28 <__aeabi_memset+0x6>
+ 8003b30: 4770 bx lr
+
+08003b32 <__aeabi_memset4>:
+
+#[cfg(not(target_os = "ios"))]
+#[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+#[cfg_attr(thumb, linkage = "weak")]
+pub unsafe extern "aapcs" fn __aeabi_memset4(dest: *mut u8, mut n: usize, c: i32) {
+ 8003b32: 4613 mov r3, r2
+ let mut dest = dest as *mut u32;
+
+ let byte = (c as u32) & 0xff;
+ let c = (byte << 24) | (byte << 16) | (byte << 8) | byte;
+
+ while n >= 4 {
+ 8003b34: 2904 cmp r1, #4
+ let byte = (c as u32) & 0xff;
+ 8003b36: b2da uxtb r2, r3
+ 8003b38: bf38 it cc
+ 8003b3a: f7ff bff2 bcc.w 8003b22 <__aeabi_memset>
+ 8003b3e: b5b0 push {r4, r5, r7, lr}
+ 8003b40: af02 add r7, sp, #8
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+ 8003b42: f1a1 0e04 sub.w lr, r1, #4
+ let c = (byte << 24) | (byte << 16) | (byte << 8) | byte;
+ 8003b46: ea42 6303 orr.w r3, r2, r3, lsl #24
+ 8003b4a: f02e 0503 bic.w r5, lr, #3
+ 8003b4e: ea43 4302 orr.w r3, r3, r2, lsl #16
+ let mut dest = dest as *mut u32;
+ 8003b52: 1944 adds r4, r0, r5
+ let c = (byte << 24) | (byte << 16) | (byte << 8) | byte;
+ 8003b54: ea43 2302 orr.w r3, r3, r2, lsl #8
+ 8003b58: f104 0c04 add.w ip, r4, #4
+ ptr::write(dest, c);
+ dest = dest.offset(1);
+ n -= 4;
+ 8003b5c: 3904 subs r1, #4
+ intrinsics::move_val_init(&mut *dst, src)
+ 8003b5e: f840 3b04 str.w r3, [r0], #4
+ while n >= 4 {
+ 8003b62: 2903 cmp r1, #3
+ 8003b64: d8fa bhi.n 8003b5c <__aeabi_memset4+0x2a>
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+ 8003b66: ebae 0105 sub.w r1, lr, r5
+ 8003b6a: e8bd 40b0 ldmia.w sp!, {r4, r5, r7, lr}
+ }
+
+ __aeabi_memset(dest as *mut u8, n, byte as i32);
+ 8003b6e: 4660 mov r0, ip
+ 8003b70: f7ff bfd7 b.w 8003b22 <__aeabi_memset>
+
+08003b74 <__aeabi_memclr4>:
+
+#[cfg(not(target_os = "ios"))]
+#[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+#[cfg_attr(thumb, linkage = "weak")]
+pub unsafe extern "aapcs" fn __aeabi_memclr4(dest: *mut u8, n: usize) {
+ __aeabi_memset4(dest, n, 0);
+ 8003b74: 2200 movs r2, #0
+ 8003b76: f7ff bfdc b.w 8003b32 <__aeabi_memset4>
+
+08003b7a <__udivmoddi4>:
+
+ $($rest:tt)*
+ ) => (
+ $(#[$($attr)*])*
+ #[cfg_attr(not(feature = "mangled-names"), no_mangle)]
+ pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {
+ 8003b7a: b5f0 push {r4, r5, r6, r7, lr}
+ 8003b7c: af03 add r7, sp, #12
+ 8003b7e: e92d 0f00 stmdb sp!, {r8, r9, sl, fp}
+ 8003b82: b082 sub sp, #8
+ 8003b84: 68bc ldr r4, [r7, #8]
+ 8003b86: b151 cbz r1, 8003b9e <__udivmoddi4+0x24>
+ rem
+ }
+
+ /// Returns `n / d` and sets `*rem = n % d`
+ pub extern "C" fn __udivmoddi4(n: u64, d: u64, rem: Option<&mut u64>) -> u64 {
+ udivmod_inner!(n, d, rem, u64)
+ 8003b88: 2a00 cmp r2, #0
+ 8003b8a: d017 beq.n 8003bbc <__udivmoddi4+0x42>
+ 8003b8c: b393 cbz r3, 8003bf4 <__udivmoddi4+0x7a>
+ unsafe { $ctlz(self as $ActualT) as u32 }
+ 8003b8e: fab1 f681 clz r6, r1
+ 8003b92: fab3 f583 clz r5, r3
+ intrinsics::overflowing_sub(self, rhs)
+ 8003b96: 1bad subs r5, r5, r6
+ 8003b98: 2d1f cmp r5, #31
+ 8003b9a: d820 bhi.n 8003bde <__udivmoddi4+0x64>
+ 8003b9c: e025 b.n 8003bea <__udivmoddi4+0x70>
+ 8003b9e: b9f3 cbnz r3, 8003bde <__udivmoddi4+0x64>
+ 8003ba0: 2c00 cmp r4, #0
+ 8003ba2: f000 80b1 beq.w 8003d08 <__udivmoddi4+0x18e>
+ if other == 0 {
+ 8003ba6: 2a00 cmp r2, #0
+ 8003ba8: f000 80e2 beq.w 8003d70 <__udivmoddi4+0x1f6>
+ Some(unsafe { intrinsics::unchecked_rem(self, other) })
+ 8003bac: fbb0 f3f2 udiv r3, r0, r2
+ ($Small: ty, $Large: ty, #[$attr:meta]) => {
+ #[$attr]
+ impl From<$Small> for $Large {
+ #[inline]
+ fn from(small: $Small) -> $Large {
+ small as $Large
+ 8003bb0: 2100 movs r1, #0
+ Some(unsafe { intrinsics::unchecked_rem(self, other) })
+ 8003bb2: fb03 0312 mls r3, r3, r2, r0
+ 8003bb6: e9c4 3100 strd r3, r1, [r4]
+ 8003bba: e0a6 b.n 8003d0a <__udivmoddi4+0x190>
+ 8003bbc: 2b00 cmp r3, #0
+ 8003bbe: f000 80d7 beq.w 8003d70 <__udivmoddi4+0x1f6>
+ 8003bc2: 2800 cmp r0, #0
+ 8003bc4: f000 8094 beq.w 8003cf0 <__udivmoddi4+0x176>
+ intrinsics::overflowing_sub(self, rhs)
+ 8003bc8: 1e5e subs r6, r3, #1
+ 8003bca: 421e tst r6, r3
+ 8003bcc: f000 80bd beq.w 8003d4a <__udivmoddi4+0x1d0>
+ unsafe { $ctlz(self as $ActualT) as u32 }
+ 8003bd0: fab1 f681 clz r6, r1
+ 8003bd4: fab3 f583 clz r5, r3
+ intrinsics::overflowing_sub(self, rhs)
+ 8003bd8: 1bad subs r5, r5, r6
+ 8003bda: 2d1e cmp r5, #30
+ 8003bdc: d905 bls.n 8003bea <__udivmoddi4+0x70>
+ 8003bde: 2c00 cmp r4, #0
+ 8003be0: bf18 it ne
+ 8003be2: e9c4 0100 strdne r0, r1, [r4]
+ 8003be6: 2000 movs r0, #0
+ 8003be8: e0bd b.n 8003d66 <__udivmoddi4+0x1ec>
+ 8003bea: f1c5 063f rsb r6, r5, #63 ; 0x3f
+ 8003bee: f105 0e01 add.w lr, r5, #1
+ 8003bf2: e00c b.n 8003c0e <__udivmoddi4+0x94>
+ 8003bf4: 1e56 subs r6, r2, #1
+ 8003bf6: 4216 tst r6, r2
+ 8003bf8: f000 808a beq.w 8003d10 <__udivmoddi4+0x196>
+ unsafe { $ctlz(self as $ActualT) as u32 }
+ 8003bfc: fab2 f582 clz r5, r2
+ 8003c00: fab1 f681 clz r6, r1
+ 8003c04: 3521 adds r5, #33 ; 0x21
+ 8003c06: eba5 0e06 sub.w lr, r5, r6
+ 8003c0a: f1ce 0600 rsb r6, lr, #0
+ 8003c0e: f006 093f and.w r9, r6, #63 ; 0x3f
+ 8003c12: f1c9 0420 rsb r4, r9, #32
+ 8003c16: fa01 f509 lsl.w r5, r1, r9
+ 8003c1a: f1a9 0c20 sub.w ip, r9, #32
+ 8003c1e: fa00 fa09 lsl.w sl, r0, r9
+ 8003c22: fa20 f404 lsr.w r4, r0, r4
+ 8003c26: f1bc 0f00 cmp.w ip, #0
+ 8003c2a: ea44 0b05 orr.w fp, r4, r5
+ 8003c2e: f00e 043f and.w r4, lr, #63 ; 0x3f
+ 8003c32: f1c4 0520 rsb r5, r4, #32
+ 8003c36: f1a4 0620 sub.w r6, r4, #32
+ 8003c3a: bfa8 it ge
+ 8003c3c: fa00 fb0c lslge.w fp, r0, ip
+ 8003c40: fa01 f805 lsl.w r8, r1, r5
+ 8003c44: fa20 f504 lsr.w r5, r0, r4
+ 8003c48: 2e00 cmp r6, #0
+ 8003c4a: fa21 f004 lsr.w r0, r1, r4
+ 8003c4e: ea45 0508 orr.w r5, r5, r8
+ 8003c52: bfa8 it ge
+ 8003c54: fa21 f506 lsrge.w r5, r1, r6
+ 8003c58: f1bc 0f00 cmp.w ip, #0
+ 8003c5c: bfa8 it ge
+ 8003c5e: f04f 0a00 movge.w sl, #0
+ 8003c62: 2e00 cmp r6, #0
+ 8003c64: bfa8 it ge
+ 8003c66: 2000 movge r0, #0
+ 8003c68: f1be 0f00 cmp.w lr, #0
+ 8003c6c: d02f beq.n 8003cce <__udivmoddi4+0x154>
+ 8003c6e: 1e51 subs r1, r2, #1
+ 8003c70: f04f 0c00 mov.w ip, #0
+ 8003c74: f04f 0800 mov.w r8, #0
+ 8003c78: 4656 mov r6, sl
+ 8003c7a: 4691 mov r9, r2
+ 8003c7c: 9101 str r1, [sp, #4]
+ 8003c7e: f163 0100 sbc.w r1, r3, #0
+ 8003c82: 9100 str r1, [sp, #0]
+ intrinsics::overflowing_sub(self, rhs)
+ 8003c84: 9901 ldr r1, [sp, #4]
+ 8003c86: 0040 lsls r0, r0, #1
+ 8003c88: 461c mov r4, r3
+ 8003c8a: ea4c 0a46 orr.w sl, ip, r6, lsl #1
+ 8003c8e: ea40 70d5 orr.w r0, r0, r5, lsr #31
+ 8003c92: 006d lsls r5, r5, #1
+ 8003c94: ea45 75db orr.w r5, r5, fp, lsr #31
+ 8003c98: 1b49 subs r1, r1, r5
+ 8003c9a: 9900 ldr r1, [sp, #0]
+ 8003c9c: 4181 sbcs r1, r0
+ 8003c9e: ea03 72e1 and.w r2, r3, r1, asr #31
+ 8003ca2: ea09 73e1 and.w r3, r9, r1, asr #31
+ 8003ca6: 1aed subs r5, r5, r3
+ 8003ca8: 4623 mov r3, r4
+ 8003caa: 4190 sbcs r0, r2
+ 8003cac: 2201 movs r2, #1
+ 8003cae: f1be 0e01 subs.w lr, lr, #1
+ 8003cb2: ea02 72e1 and.w r2, r2, r1, asr #31
+ 8003cb6: ea4f 014b mov.w r1, fp, lsl #1
+ 8003cba: ea41 71d6 orr.w r1, r1, r6, lsr #31
+ 8003cbe: 4694 mov ip, r2
+ 8003cc0: 4656 mov r6, sl
+ 8003cc2: ea48 0b01 orr.w fp, r8, r1
+ 8003cc6: f04f 0800 mov.w r8, #0
+ 8003cca: d1db bne.n 8003c84 <__udivmoddi4+0x10a>
+ 8003ccc: e002 b.n 8003cd4 <__udivmoddi4+0x15a>
+ 8003cce: 2200 movs r2, #0
+ 8003cd0: f04f 0800 mov.w r8, #0
+ 8003cd4: 68b9 ldr r1, [r7, #8]
+ 8003cd6: 2900 cmp r1, #0
+ 8003cd8: bf18 it ne
+ 8003cda: e9c1 5000 strdne r5, r0, [r1]
+ 8003cde: ea4f 014b mov.w r1, fp, lsl #1
+ 8003ce2: ea42 004a orr.w r0, r2, sl, lsl #1
+ 8003ce6: ea41 71da orr.w r1, r1, sl, lsr #31
+ 8003cea: ea41 0108 orr.w r1, r1, r8
+ 8003cee: e03b b.n 8003d68 <__udivmoddi4+0x1ee>
+ 8003cf0: 2c00 cmp r4, #0
+ }
+ fn high_as_low(high: $tyhigh) -> $tylow {
+ high as $tylow
+ }
+ fn from_parts(low: $tylow, high: $tyhigh) -> $ty {
+ low as $ty | ((high as $ty) << $halfbits)
+ 8003cf2: bf1f itttt ne
+ 8003cf4: 2000 movne r0, #0
+ Some(unsafe { intrinsics::unchecked_rem(self, other) })
+ 8003cf6: fbb1 f2f3 udivne r2, r1, r3
+ 8003cfa: fb02 1213 mlsne r2, r2, r3, r1
+ 8003cfe: e9c4 0200 strdne r0, r2, [r4]
+ other => Some(unsafe { intrinsics::unchecked_div(self, other) }),
+ 8003d02: fbb1 f0f3 udiv r0, r1, r3
+ 8003d06: e02e b.n 8003d66 <__udivmoddi4+0x1ec>
+ 8003d08: b39a cbz r2, 8003d72 <__udivmoddi4+0x1f8>
+ 8003d0a: fbb0 f0f2 udiv r0, r0, r2
+ 8003d0e: e02a b.n 8003d66 <__udivmoddi4+0x1ec>
+ 8003d10: 2c00 cmp r4, #0
+ small as $Large
+ 8003d12: bf1e ittt ne
+ 8003d14: 2300 movne r3, #0
+ 8003d16: 4006 andne r6, r0
+ 8003d18: e9c4 6300 strdne r6, r3, [r4]
+ 8003d1c: 2a01 cmp r2, #1
+ 8003d1e: d023 beq.n 8003d68 <__udivmoddi4+0x1ee>
+ intrinsics::cttz(self) as u32
+ 8003d20: fa92 f2a2 rbit r2, r2
+ 8003d24: fab2 f282 clz r2, r2
+ 8003d28: f1c2 0320 rsb r3, r2, #32
+ 8003d2c: 40d0 lsrs r0, r2
+ 8003d2e: fa01 f303 lsl.w r3, r1, r3
+ 8003d32: 4318 orrs r0, r3
+ 8003d34: f1a2 0320 sub.w r3, r2, #32
+ 8003d38: 2b00 cmp r3, #0
+ 8003d3a: bfa8 it ge
+ 8003d3c: fa21 f003 lsrge.w r0, r1, r3
+ 8003d40: fa21 f102 lsr.w r1, r1, r2
+ 8003d44: bfa8 it ge
+ 8003d46: 2100 movge r1, #0
+ 8003d48: e00e b.n 8003d68 <__udivmoddi4+0x1ee>
+ 8003d4a: 2c00 cmp r4, #0
+ 8003d4c: bf1c itt ne
+ 8003d4e: ea06 0201 andne.w r2, r6, r1
+ 8003d52: e9c4 0200 strdne r0, r2, [r4]
+ 8003d56: fa93 f0a3 rbit r0, r3
+ 8003d5a: fab0 f080 clz r0, r0
+ 8003d5e: f000 001f and.w r0, r0, #31
+ 8003d62: fa21 f000 lsr.w r0, r1, r0
+ 8003d66: 2100 movs r1, #0
+ $($body)*
+ }
+ 8003d68: b002 add sp, #8
+ 8003d6a: e8bd 0f00 ldmia.w sp!, {r8, r9, sl, fp}
+ 8003d6e: bdf0 pop {r4, r5, r6, r7, pc}
+ 8003d70: defe udf #254 ; 0xfe
+
+#[cfg(test)]
+extern crate core;
+
+fn abort() -> ! {
+ unsafe { core::intrinsics::abort() }
+ 8003d72: defe udf #254 ; 0xfe
diff --git a/src/lib.rs b/src/lib.rs
index 1d7c4405199821bf38eaa0e86c7c4fe987c0c59e..70c44ca02002f5bec956b7c699f93613b33a5fc3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -34,7 +34,7 @@ pub mod gpio;
// pub mod pwm;
// pub mod qei;
// pub mod rtc;
-// pub mod serial;
+pub mod serial;
// pub mod spi;
pub mod time;
// pub mod timer;
@@ -53,7 +53,12 @@ macro_rules! frequency {
use time::*;
/// Frequency
- pub const FREQUENCY: u32 = $FREQUENCY;
+ static mut FREQUENCY: u32 = $FREQUENCY;
+
+ /// Set Frequency
+ pub fn set_frequency(f: u32) {
+ unsafe {FREQUENCY = f };
+ }
/// Unit of time
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
@@ -70,43 +75,43 @@ macro_rules! frequency {
impl From<Ticks> for Microseconds {
fn from(ticks: Ticks) -> Self {
- Microseconds(ticks.0 / (FREQUENCY / 1_000_000))
+ Microseconds(ticks.0 / (unsafe { FREQUENCY }/ 1_000_000))
}
}
impl From<Ticks> for Milliseconds {
fn from(ticks: Ticks) -> Self {
- Milliseconds(ticks.0 / (FREQUENCY / 1_000))
+ Milliseconds(ticks.0 / (unsafe { FREQUENCY }/ 1_000))
}
}
impl From<Ticks> for Seconds {
fn from(ticks: Ticks) -> Self {
- Seconds(ticks.0 / FREQUENCY)
+ Seconds(ticks.0 / unsafe { FREQUENCY })
}
}
impl From<IHertz> for Ticks {
fn from(ihz: IHertz) -> Ticks {
- Ticks(FREQUENCY / ihz.0)
+ Ticks(unsafe { FREQUENCY } / ihz.0)
}
}
impl From<Microseconds> for Ticks {
fn from(us: Microseconds) -> Ticks {
- Ticks(us.0 * (FREQUENCY / 1_000_000))
+ Ticks(us.0 * (unsafe { FREQUENCY } / 1_000_000))
}
}
impl From<Milliseconds> for Ticks {
fn from(ms: Milliseconds) -> Ticks {
- Ticks(ms.0 * (FREQUENCY / 1_000))
+ Ticks(ms.0 * (unsafe { FREQUENCY } / 1_000))
}
}
impl From<Seconds> for Ticks {
fn from(s: Seconds) -> Ticks {
- Ticks(s.0 * FREQUENCY)
+ Ticks(s.0 * unsafe { FREQUENCY })
}
}
@@ -120,8 +125,7 @@ macro_rules! frequency {
/// Advance High-performance Bus (AHB1)
pub mod ahb1 {
- //frequency!(16_000_000);
- frequency!(42_000_000);
+ frequency!(16_000_000);
}
/// Advance High-performance Bus (AHB2)
diff --git a/src/serial.rs b/src/serial.rs
index ef86e05dea2274530f9ff009821fb61cdb6dbf5b..189827771c44259f55f3695137f8c547b890efc7 100644
--- a/src/serial.rs
+++ b/src/serial.rs
@@ -29,8 +29,7 @@ use cast::u16;
use hal;
use nb;
use static_ref::Static;
-use stm32f40x::{gpioa, DMA1, USART1, USART2, USART3, usart6,
- /*AFIO, */ GPIOA, GPIOB, RCC};
+use stm32f40x::{gpioa, DMA1, USART1, USART2, USART3, usart6, /*AFIO, */ GPIOA, GPIOB, RCC};
//use dma::{self, Buffer, Dma1Channel4, Dma1Channel5};
@@ -55,10 +54,11 @@ unsafe impl Usart for USART2 {
type Ticks = ::apb1::Ticks;
}
-unsafe impl Usart for USART3 {
- type GPIO = GPIOB;
- type Ticks = ::apb1::Ticks;
-}
+
+// unsafe impl Usart for USART3 {
+// type GPIO = GPIOB;
+// type Ticks = ::apb1::Ticks;
+// }
/// An error
#[derive(Debug)]
@@ -106,6 +106,7 @@ where
{
}
+/*
impl<'a, U> Serial<'a, U>
where
U: Any + Usart,
@@ -115,19 +116,17 @@ where
///
/// The serial interface will be configured to use 8 bits of data, 1 stop
/// bit, no hardware control and to omit parity checking
- pub fn init<B>(
- &self,
- baud_rate: B,
- afio: &AFIO,
- dma1: Option<&DMA1>,
- gpio: &U::GPIO,
- rcc: &RCC,
- ) where
+ ///
+ ///
+
+ pub fn init<B>(&self, baud_rate: B, dma1: Option<&DMA1>, p::init::Peripherals)
+ where
B: Into<U::Ticks>,
{
- self._init(baud_rate.into(), afio, dma1, gpio, rcc)
+ //self._init(baud_rate.into(), afio, dma1, gpio, rcc)
}
+
fn _init(
&self,
baud_rate: U::Ticks,
@@ -335,6 +334,7 @@ where
}
}
}
+ */
impl<'a, U> hal::serial::Read<u8> for Serial<'a, U>
where
@@ -343,26 +343,26 @@ where
type Error = Error;
fn read(&self) -> Result<u8> {
- let usart1 = self.0;
- let sr = usart1.sr.read();
-
- if sr.ore().bit_is_set() {
- Err(nb::Error::Other(Error::Overrun))
- } else if sr.ne().bit_is_set() {
- Err(nb::Error::Other(Error::Noise))
- } else if sr.fe().bit_is_set() {
- Err(nb::Error::Other(Error::Framing))
- } else if sr.rxne().bit_is_set() {
- // NOTE(read_volatile) the register is 9 bits big but we'll only
- // work with the first 8 bits
- Ok(unsafe {
- ptr::read_volatile(&usart1.dr as *const _ as *const u8)
- })
- } else {
- Err(nb::Error::WouldBlock)
- }
+ let usart = self.0;
+ let sr = usart.sr.read();
+
+ if sr.ore().bit_is_set() {
+ Err(nb::Error::Other(Error::Overrun))
+ } else if sr.nf().bit_is_set() {
+ Err(nb::Error::Other(Error::Noise))
+ } else if sr.fe().bit_is_set() {
+ Err(nb::Error::Other(Error::Framing))
+ } else if sr.rxne().bit_is_set() {
+ // NOTE(read_volatile) the register is 9 bits big but we'll only
+ // work with the first 8 bits
+ Ok(unsafe {
+ ptr::read_volatile(&usart.dr as *const _ as *const u8)
+ })
+ } else {
+ Err(nb::Error::WouldBlock)
}
}
+}
impl<'a, U> hal::serial::Write<u8> for Serial<'a, U>
where
@@ -371,27 +371,26 @@ where
type Error = Error;
fn write(&self, byte: u8) -> Result<()> {
- let usart1 = self.0;
- let sr = usart1.sr.read();
-
- if sr.ore().bit_is_set() {
- Err(nb::Error::Other(Error::Overrun))
- } else if sr.ne().bit_is_set() {
- Err(nb::Error::Other(Error::Noise))
- } else if sr.fe().bit_is_set() {
- Err(nb::Error::Other(Error::Framing))
- } else if sr.txe().bit_is_set() {
- // NOTE(write_volatile) see NOTE in the `read` method
- unsafe {
- ptr::write_volatile(&usart1.dr as *const _ as *mut u8, byte)
- }
- Ok(())
- } else {
- Err(nb::Error::WouldBlock)
- }
+ let usart = self.0;
+ let sr = usart.sr.read();
+
+ if sr.ore().bit_is_set() {
+ Err(nb::Error::Other(Error::Overrun))
+ } else if sr.nf().bit_is_set() {
+ Err(nb::Error::Other(Error::Noise))
+ } else if sr.fe().bit_is_set() {
+ Err(nb::Error::Other(Error::Framing))
+ } else if sr.txe().bit_is_set() {
+ // NOTE(write_volatile) see NOTE in the `read` method
+ unsafe { ptr::write_volatile(&usart.dr as *const _ as *mut u8, byte) }
+ Ok(())
+ } else {
+ Err(nb::Error::WouldBlock)
+ }
}
}
+ /*
impl<'a> Serial<'a, USART1> {
/// Starts a DMA transfer to receive serial data into a `buffer`
///
@@ -399,6 +398,7 @@ impl<'a> Serial<'a, USART1> {
/// The `buffer` can be `release`d after the DMA transfer finishes
// TODO support circular mode + half transfer interrupt as a double
// buffering mode
+
pub fn read_exact<B>(
&self,
dma1: &DMA1,
@@ -425,7 +425,7 @@ impl<'a> Serial<'a, USART1> {
Ok(())
}
-
+
/// Starts a DMA transfer to send `buffer` through this serial port
///
/// This will immutably lock the `buffer` preventing mutably borrowing its
@@ -457,3 +457,4 @@ impl<'a> Serial<'a, USART1> {
Ok(())
}
}
+ */
diff --git a/stlink-v2-1.cfg b/stlink-v2-1.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..093e80177078667dbc03e166ac5d7e997086b4f2
--- /dev/null
+++ b/stlink-v2-1.cfg
@@ -0,0 +1,16 @@
+#
+# STMicroelectronics ST-LINK/V2-1 in-circuit debugger/programmer
+#
+
+interface hla
+hla_layout stlink
+hla_device_desc "ST-LINK/V2-1"
+hla_vid_pid 0x0483 0x374b
+
+# Optionally specify the serial number of ST-LINK/V2 usb device. ST-LINK/V2
+# devices seem to have serial numbers with unreadable characters. ST-LINK/V2
+# firmware version >= V2.J21.S4 recommended to avoid issues with adapter serial
+# number reset issues.
+# eg.
+#hla_serial "\xaa\xbc\x6e\x06\x50\x75\xff\x55\x17\x42\x19\x3f"
+
diff --git a/stm32f4x.cfg b/stm32f4x.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7a0af9fba0d24845b101207283327c766aacf22b
--- /dev/null
+++ b/stm32f4x.cfg
@@ -0,0 +1,106 @@
+# script for stm32f4x family
+
+#
+# stm32 devices support both JTAG and SWD transports.
+#
+source [find target/swj-dp.tcl]
+source [find mem_helper.tcl]
+
+if { [info exists CHIPNAME] } {
+ set _CHIPNAME $CHIPNAME
+} else {
+ set _CHIPNAME stm32f4x
+}
+
+set _ENDIAN little
+
+# Work-area is a space in RAM used for flash programming
+# By default use 32kB (Available RAM in smallest device STM32F410)
+if { [info exists WORKAREASIZE] } {
+ set _WORKAREASIZE $WORKAREASIZE
+} else {
+ set _WORKAREASIZE 0x8000
+}
+
+#jtag scan chain
+if { [info exists CPUTAPID] } {
+ set _CPUTAPID $CPUTAPID
+} else {
+ if { [using_jtag] } {
+ # See STM Document RM0090
+ # Section 38.6.3 - corresponds to Cortex-M4 r0p1
+ set _CPUTAPID 0x4ba00477
+ } {
+ set _CPUTAPID 0x2ba01477
+ }
+}
+
+swj_newdap $_CHIPNAME cpu -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id $_CPUTAPID
+
+if {[using_jtag]} {
+ jtag newtap $_CHIPNAME bs -irlen 5
+}
+
+set _TARGETNAME $_CHIPNAME.cpu
+target create $_TARGETNAME cortex_m -endian $_ENDIAN -chain-position $_TARGETNAME
+
+$_TARGETNAME configure -work-area-phys 0x20000000 -work-area-size $_WORKAREASIZE -work-area-backup 0
+
+set _FLASHNAME $_CHIPNAME.flash
+flash bank $_FLASHNAME stm32f2x 0 0 0 0 $_TARGETNAME
+
+# JTAG speed should be <= F_CPU/6. F_CPU after reset is 16MHz, so use F_JTAG = 2MHz
+#
+# Since we may be running of an RC oscilator, we crank down the speed a
+# bit more to be on the safe side. Perhaps superstition, but if are
+# running off a crystal, we can run closer to the limit. Note
+# that there can be a pretty wide band where things are more or less stable.
+adapter_khz 2000
+
+adapter_nsrst_delay 100
+if {[using_jtag]} {
+ jtag_ntrst_delay 100
+}
+
+reset_config srst_nogate
+
+if {![using_hla]} {
+ # if srst is not fitted use SYSRESETREQ to
+ # perform a soft reset
+ cortex_m reset_config sysresetreq
+}
+
+$_TARGETNAME configure -event examine-end {
+ # Enable debug during low power modes (uses more power)
+ # DBGMCU_CR |= DBG_STANDBY | DBG_STOP | DBG_SLEEP
+ mmw 0xE0042004 0x00000007 0
+
+ # Stop watchdog counters during halt
+ # DBGMCU_APB1_FZ |= DBG_IWDG_STOP | DBG_WWDG_STOP
+ mmw 0xE0042008 0x00001800 0
+}
+
+$_TARGETNAME configure -event trace-config {
+ # Set TRACE_IOEN; TRACE_MODE is set to async; when using sync
+ # change this value accordingly to configure trace pins
+ # assignment
+ mmw 0xE0042004 0x00000020 0
+}
+
+$_TARGETNAME configure -event reset-init {
+ # Configure PLL to boost clock to HSI x 4 (64 MHz)
+ mww 0x40023804 0x08012008 ;# RCC_PLLCFGR 16 Mhz /8 (M) * 128 (N) /4(P)
+ mww 0x40023C00 0x00000102 ;# FLASH_ACR = PRFTBE | 2(Latency)
+ mmw 0x40023800 0x01000000 0 ;# RCC_CR |= PLLON
+ sleep 10 ;# Wait for PLL to lock
+ mmw 0x40023808 0x00001000 0 ;# RCC_CFGR |= RCC_CFGR_PPRE1_DIV2
+ mmw 0x40023808 0x00000002 0 ;# RCC_CFGR |= RCC_CFGR_SW_PLL
+
+ # Boost JTAG frequency
+ adapter_khz 8000
+}
+
+$_TARGETNAME configure -event reset-start {
+ # Reduce speed since CPU speed will slow down to 16MHz with the reset
+ adapter_khz 2000
+}