There are actually several instances where we pass in read-only
parameters as pass-by-value, where in the case of String() that
is inefficient as it involves copy-constructor/temp string creations.
We can avoid that, similarly to single character string concatenations
done via string literals instead of char literals.
* Add time to filesystem API
Support the ESP32 File::getLastWrite() call and setting the time on
all filesystems automatically (assuming the system clock has
been set properly and time(NULL) returns the proper time!).
Adds Dir::fileTime() to get the time of a file being listed, similar to
Dir::fileName() and Dir::fileSize().
Adds ::setTimeCallback(time_t (*cb)()) to File, Dir, and FS, allowing
users to override the default timestamp on a per-file, directory, or
filesystem basis. By default, a simple callback returning time(nullptr)
is implemented.
LittleFS uses the 't' attribute and should be backwards compatible.
SD/SDFS work and include wrappers for obsolete SdFat timestamp callbacks
using the MSDOS time.
This PR does not update SPIFFS, due to compatability concerns and a
possible massive rewrite which would make it possible to determine if an
old-style ot metadata enabled FS is present at mount time.
Includes an updated SD/listfiles and LittleFS_time example.
Replaces #6315
* Add links to new mklittlefs w/timestamp support
Include the update mklittlefs which generated 't' metadata on imported
files.
../tools/sdk/lwip2/include/netif/lowpan6_opts.h
* Add explicit note about timestamp being local time
* Address review concerns
Clean up some awkward object instantiations.
Remove the _enableTime flag/setter from SPIFFS.
Clean up the FSConfig constructors using C++ style init lists.
* Status length arg in begin() added
* readable bits config
* strange line removed
* Empty constructor added
Moved custom status length init overloaded constructor
* Constructor without parameters added
* Code formatting fix
* default value in constructor removed
* default begin method forwarded to new
* Comments about bits added, else if except if
* WIP: Initial overlay of upstream version of umm_malloc over
our current version w/o any edits.
Using files from:
https://github.com/rhempel/umm_malloc/tree/master/srchttps://github.com/rhempel/c-helper-macros/tree/develop
The following file remanents from our old version were removed:
umm_malloc.cpp, umm_performance.h, umm_performance.cpp, and umm_stats.h
This is intended to be a "compare to" for changes made to
upstream version.
* WIP: upstream version of umm_malloc customized for Arduino ESP8266 Core
See comments at the top of umm_malloc.cpp for a summary of changes so far.
Added support for integrity check and poison check to refactored heap.cpp.
* Resoved Travis CI - issue
* Corrected #ifdef's for UMM_STATS/UMM_STATS_FULL
* Corrected UMM_REALLOC_DEFRAG option to be more like the original umm_realloc.
Updated some comments and changed method of defining _rom_putc1.
* Updated UMM_POISON_CHECK_LITE - Expanded the poison check on the current
allocation to include its nearest allocated neighbors in the heap.
That is to say, if the nearest neighbor is free, then the next one over
is checked. And this is done in both directions.
umm_malloc() will also checks the neighbors of the selected
allocation before use.
Merged umm_malloc.c into umm_malloc.cpp.
Added additional stats for debug build.
On going comment cleanup.
Removed #if 0 block from isr_safe_printf.
Corrected mistyped UMM_POISON_CHECK UMM_CHECK_POISON.
Corrected other conditional build issues.
* Updated printing in heap.cpp to behave the way os_printf did.
Updated printing in heap.cpp to behave the way os_printf would have with regards
to system_set_os_print. ie. setDebugOutput enable/disables printing
Expanded #ifdef fenceing of .c files to prevent Arduino IDE from building them
outside of the .cpp file they are included in.
Corrected more conditional building issues.
Remaining concern - umm_info(0, true) printing - does it need an ISR safe method,
all printing is done from within a critical sectionn with rsil(15)?
Or should be have the print option disabled for non-debug builds.
ie. Debug port: "Disabled"
* Merged latest, 2019-09-07, from upstream umm_malloc
* R.Hempel 2019-09-07 - Separate the malloc() and free() functionality into
* wrappers that use critical section protection macros
* and static core functions that assume they are
* running in a protected con text. Thanks @devyte
* Resolved issue where OOM selected w/ Debug port: "Disabled" caused hang.
With OOM selected w/ Debug port: "Disabled" you can now use
Serial.setDebugOutput(true); to enable OOM message displaying.
This is the behavior previously available with os_printf.
commit rev 1
* Fixed realloc OOM bug introduced due to confusing code, added comment for future.
umm_info(NULL, true) is now treated as a debug option that is enabled by
Arduino IDE->tools `Debug port: "Serial"`, etc. It now prints when
DEBUG_ESP_PORT or UMM_INFO_PRINT are defined.
Cleanup comments and some conditionals.
* Updated to track PRs for various print definitions. Cleaned up comments
* Added missing "#ifdef __cplusplus"
* Reorganize local enhancements
More comment cleanups
Added Status TODOs marks for upstream
* Print notice message for the need of -DUMM_INFO_PRINT
* This updates the heap management library, umm_malloc, to the current upstream
version at https://github.com/rhempel/umm_malloc. Some reorganizing and new code
was needed to use the new version.
This is a list of note worthy changes:
UMM_POISON - now has a lite option as well as the previous intensive check
option. The code for running the full poison test at the call of the various
alloc functions was removed in the upstream version. In this port the missing
code was added to heap.cpp and umm_local.cpp.
* UMM_POISON - appears to have been partially changed to UMM_POISON_CHECK,
I treat it as depricated and used UMM_POISON_CHECK, when needed.
However, the Arduino Core's references to UMM_POISON were replaced with
UMM_POISON_CHECK_LITE.
* UMM_POISON_CHECK_LITE - Less intense, it just checks poison on active
neighboring allocations.
* UMM_POISON_CHECK - Full heap intensive check of poison
UMM_INFO_PRINT - This new define makes building UMM_INFO with printing
capability, optional. When umm_info(NULL, true) is used to print a debug view of
heap information to the debug port, it has to walk the heap and print out
information, while in a critical section. This requires that the print function
be able to print w/o doing malloc calls and from an IRQ disabled context. It
also requires more IRAM to handle printing. Without this define
`umm_info(NULL, true)` will not print.
* UMM_INFO_PRINT is enabled as part of selecting `Debug port: "Serial" or
* "Serial1"`. To make available all the time use '-D UMM_INFO_PRINT`.
A cautionary note, on the use of UMM_INTEGRITY_CHECK, UMM_POISON_CHECK, and
UMM_INFO_PRINT. All of these run with IRQs disabled, for periods that can go
into 100's of us. With umm_info(NULL, true) that may go into seconds, depending
on the serial interface speed and the number of memory allocations present. Use
UMM_INTEGRITY_CHECK, UMM_POISON_CHECK, and UMM_INFO_PRINT sparingly.
If you want to see numbers for the disabled time, explore using
UMM_CRITICAL_METRICS in umm_malloc_cfg.h.
* This updates the heap management library, umm_malloc, to the current upstream
version at https://github.com/rhempel/umm_malloc. Some reorganizing and new code
was needed to use the new version.
This is a list of note worthy changes:
UMM_POISON - now has a lite option as well as the previous intensive check
option. The code for running the full poison test at the call of the various
alloc functions was removed in the upstream version. In this port the missing
code was added to heap.cpp and umm_local.cpp.
* UMM_POISON - appears to have been partially changed to UMM_POISON_CHECK,
I treat it as depricated and used UMM_POISON_CHECK, when needed.
However, the Arduino Core's references to UMM_POISON were replaced with
UMM_POISON_CHECK_LITE.
* UMM_POISON_CHECK_LITE - Less intense, it just checks poison on active
neighboring allocations.
* UMM_POISON_CHECK - Full heap intensive check of poison
UMM_INFO_PRINT - This new define makes building UMM_INFO with printing
capability, optional. When umm_info(NULL, true) is used to print a debug view of
heap information to the debug port, it has to walk the heap and print out
information, while in a critical section. This requires that the print function
be able to print w/o doing malloc calls and from an IRQ disabled context. It
also requires more IRAM to handle printing. Without this define
`umm_info(NULL, true)` will not print.
* UMM_INFO_PRINT is enabled as part of selecting `Debug port: "Serial" or
* "Serial1"`. To make available all the time use '-D UMM_INFO_PRINT`.
A cautionary note, on the use of UMM_INTEGRITY_CHECK, UMM_POISON_CHECK, and
UMM_INFO_PRINT. All of these run with IRQs disabled, for periods that can go
into 100's of us. With umm_info(NULL, true) that may go into seconds, depending
on the serial interface speed and the number of memory allocations present. Use
UMM_INTEGRITY_CHECK, UMM_POISON_CHECK, and UMM_INFO_PRINT sparingly.
If you want to see numbers for the disabled time, explore using
UMM_CRITICAL_METRICS in umm_malloc_cfg.h.
* Updated upstream TODO
* Changes on printing to comply with new understanding of SPI bus availability
from an ISR vs forground with INTLEVEL 15.
* Removed no longer needed files.
* OOM build option now saves file and line number for post mortem reporting.
* Missed change.
* Consolated upstream integration comments into Notes.h. This helps
keep these comments separated from the upstream code and to avoid
getting lost. I'll expand this as I think of and remember more.
* Comment updates.
* Notes update.
* Changes to heap.cpp -
Refactored macro PTR_CHECK__LOG_LAST_FAIL.
Replaced macros __umm_... with uppercase versions.
Corrected misplaced POISON_CHECK__PANIC_FL macro in realloc.
Added debug free options for OOM and Poison to umm_malloc_cfg.h
Updated Notes.h.
Lines that start with "//C" are meant to flag reviewer's attention.
* Corrected Full Poison Check's placement and documented the
thinking behind its placement and Integrity Checks placement
with relation to the *alloc function. Just so I don't forget
again :/
* Fixed typos
* Fix for scheduling recurrent functions while inside scheduled function
* Check that fn are valid. Invoking invalid functions throws otherwise.
* Added wakeup token to scheduler. Toggling the token value breaks a scheduled function
out from a delayed execution and makes it run on the next scheduler iteration.
* Timer reset reliability fix.
* Shrink interrupts-locked regions.
Add check for periodic yield to scheduled functions run-loop.
* Ordered, more predictable, scheduling. Before, it had different ordering compared to
FastScheduler as well as sequential calls from loop().
* Optional, for the paranoid: revert changes to (non-recurrent) schedule_function() / run_scheduled_functions().
* Comment
* Adapt one-line ifs to general style in same source file.
* Fix wakeupToken handling - don't respond to toggle, but to different value
vs. that at registering function with scheduler.
* Reword comment.
* Putting aside std::atomic concerns, use a callback for scheduler alarming.
In the future, async future's .then() might take advantage of this direction.
* Drop atomic include, align function type syntax.
* Reduce flash use.
* Prefer const ref over call by value plus std::move().
* sdk: testing branch update (v2.2.x), tidy up fw names in menus, add dates
Former default SDK (22y, renamed to 22x-190703) is still available
Changelog is included in sdk directory
* Keep current FW as default until next release
* update for PIO
* Double I2C read in one transaction skips a clock pulse (#5528)
See https://github.com/esp8266/Arduino/issues/5528 and the more elaborate [description](https://github.com/maarten-pennings/I2C-tool/blob/master/I2Ctest8266/README.md#how-to-fix)
where @maarten-pennings did all the hard work, but as far as I could see, no PR was made.
I also noticed some code duplication, which I moved to separate functions.
According to [this documentation on I2C clock stretching](https://www.i2c-bus.org/clock-stretching/) it is not allowed to have some slave keep the clock low during transmission of a byte, only after an ack.
So that's why it is not done in the while loop.
But I wondered if there should be an extra delay between the sequence of pulses and the extra added clock "valley". See my comment in the code.
Fixes#5528
* [I2C] Restore clock stretch functionality during transfer
As requested here: 8357a8c644 (r339310509)
* [I2C] Move duplicated clock stretch call to twi_scl_valley function
* Fix Python3 errors for device tests
The Python3 migration didn't include fixes for local scripts in the
device test tree.
Fatal build and run Python errors fixed.
The last update to xunitmerge is ~5 years ago, so it looks to be
unsupported now.
Use a local copy of the two components to allow patching to work with
Python3.
The serial test seems to send garbage chars (non-ASCII/etc.), so use a
codepage 437 which supports all 255 chars.
Fixes: #6660
* Run tests at 160MHz (req'd for some SSL connections)
* Fix debuglevel options for builder
* Fix Python3 interpreter path in xunitmerge
* Remove virtualenv on "make clean"
* Add appropriate attribution, license to xunitmerge
Add like to the original sources with the author's license to the
copied/fixed xunitmerge files.
Windows installers place each version of Python in their own, uniquely
named directory. Can't programatically override w/free Chocolatey, so
use the shell and figure it where it installed it dynamically.
* Reduce the IRAM (and heap) usage of I2C code
The I2C code takes a large chunk of IRAM space. Attempt to reduce the
size of the routines without impacting functionality.
First, remove the `static` classifier on the sda/scl variables in the
event handlers. The first instructions in the routines overwrite the
last value stored in them, anyway, and their addresses are never taken.
* Make most variables ints, not uint8_ts
Where it doesn't make a functional difference, make global variables
ints and not unit8_t. Bytewide updates and extracts require multiple
instructions and hence increase IRAM usage as well as runtime.
* Make local flag vars int
Sketch uses 270855 bytes (25%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27940 bytes (34%) of dynamic memory, leaving 53980 bytes for local variables. Maximum is 81920 bytes.
./xtensa-lx106-elf/bin/xtensa-lx106-elf-objdump -t -j .text1 /tmp/arduino_build_9615/*elf | sort -k1 | head -20
401000cc l F .text1 00000014 twi_delay
401000ec l F .text1 00000020 twi_reply$part$1
4010010c g F .text1 00000035 twi_reply
4010014c g F .text1 00000052 twi_stop
401001a0 g F .text1 0000003b twi_releaseBus
40100204 g F .text1 000001e6 twi_onTwipEvent
40100404 l F .text1 000001f7 onSdaChange
40100608 l F .text1 000002fd onSclChange
40100908 l F .text1 0000003b onTimer
* Factor out !scl in onSdaChange
If SCL is low then all branches of the case are no-ops, so factor that
portion outo to remove some redundant logic in each case.
Sketch uses 270843 bytes (25%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27944 bytes (34%) of dynamic memory, leaving 53976 bytes for local variables. Maximum is 81920 bytes.
401000cc l F .text1 00000014 twi_delay
401000ec l F .text1 00000020 twi_reply$part$1
4010010c g F .text1 00000035 twi_reply
4010014c g F .text1 00000052 twi_stop
401001a0 g F .text1 0000003b twi_releaseBus
40100204 g F .text1 000001e6 twi_onTwipEvent
40100404 l F .text1 000001e7 onSdaChange
401005f8 l F .text1 000002fd onSclChange
401008f8 l F .text1 0000003b onTimer
0x0000000040107468 _text_end = ABSOLUTE (.)
* Make tiny twi_reply inline
twi_reply is a chunk of code that can be inlined and actually save IRAM
space because certain conditions acan be statically evaluated by gcc.
Sketch uses 270823 bytes (25%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27944 bytes (34%) of dynamic memory, leaving 53976 bytes for local variables. Maximum is 81920 bytes.
401000cc l F .text1 00000014 twi_delay
401000f4 g F .text1 00000052 twi_stop
40100148 g F .text1 0000003b twi_releaseBus
401001b0 g F .text1 00000206 twi_onTwipEvent
401003d0 l F .text1 000001e7 onSdaChange
401005c4 l F .text1 000002fd onSclChange
401008c4 l F .text1 0000003b onTimer
40100918 g F .text1 00000085 millis
401009a0 g F .text1 0000000f micros
401009b0 g F .text1 00000022 micros64
401009d8 g F .text1 00000013 delayMicroseconds
401009f0 g F .text1 00000034 __digitalRead
401009f0 w F .text1 00000034 digitalRead
40100a3c g F .text1 000000e4 interrupt_handler
40100b20 g F .text1 0000000f vPortFree
0x0000000040107434 _text_end = ABSOLUTE (.)
* Inline additional twi_** helper functions
Sketch uses 270799 bytes (25%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27944 bytes (34%) of dynamic memory, leaving 53976 bytes for local variables. Maximum is 81920 bytes.
401000cc l F .text1 00000014 twi_delay
401000f4 w F .text1 0000003b twi_releaseBus
4010015c g F .text1 00000246 twi_onTwipEvent
401003bc l F .text1 000001e7 onSdaChange
401005b0 l F .text1 000002f9 onSclChange
401008ac l F .text1 0000003b onTimer
0x000000004010741c _text_end = ABSOLUTE (.)
* Convert state machine to 1-hot for faster lookup
GCC won't use a lookup table for the TWI state machine, so it ends up
using a series of straight line compare-jump, compare-jumps to figure
out which branch of code to execute for each state. For branches that
have multiple states that call them, this can expand to a lot of code.
Short-circuit the whole thing by converting the FSM to a 1-hot encoding
while executing it, and then just and-ing the 1-hot state with the
bitmask of states with the same code.
Sketch uses 270719 bytes (25%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27944 bytes (34%) of dynamic memory, leaving 53976 bytes for local variables. Maximum is 81920 bytes.
401000cc l F .text1 00000014 twi_delay
401000f4 w F .text1 0000003b twi_releaseBus
4010015c g F .text1 00000246 twi_onTwipEvent
401003c0 l F .text1 000001b1 onSdaChange
40100580 l F .text1 000002da onSclChange
4010085c l F .text1 0000003b onTimer
0x00000000401073cc _text_end = ABSOLUTE (.)
Saves 228 bytes of IRAM vs. master, uses 32 additional bytes of heap.
* Factor out twi_status setting
twi_status is set immediately before an event handler is called,
resulting in lots of duplicated code. Set the twi_status flag inside
the handler itself.
Saves an add'l ~100 bytes of IRAM from prior changes, for a total of
~340 bytes.
earle@server:~/Arduino/hardware/esp8266com/esp8266/tools$ ./xtensa-lx106-elf/bin/xtensa-lx106-elf-objdump -t -j .text1 /tmp/arduino_build_849115/*elf | sort -k1 | head -20
401000cc l F .text1 00000014 twi_delay
401000f4 w F .text1 0000003b twi_releaseBus
40100160 g F .text1 0000024e twi_onTwipEvent
401003c8 l F .text1 00000181 onSdaChange
40100558 l F .text1 00000297 onSclChange
* Use a struct to hold globals for TWI
Thanks to the suggestion from @mhightower83, move all global objects
into a struct. This lets a single base pointer register to be used in
place of constantly reloading the address of each individual variable.
This might be better expressed by moving this to a real C++
implementaion based on a class object (the twi.xxxx would go back to the
old xxx-only naming for vars), but there would then need to be API
wrappers since the functionality is exposed through a plain C API.
Saves 168 additional code bytes, for a grand total of 550 bytes IRAM.
earle@server:~/Arduino/hardware/esp8266com/esp8266/tools$ ./xtensa-lx106-elf/bin/xtensa-lx106-elf-objdump -t -j .text1 /tmp/arduino_build_849115/*elf | sort -k1 | head -20
401000cc l F .text1 00000014 twi_delay
401000e8 w F .text1 00000032 twi_releaseBus
40100128 g F .text1 00000217 twi_onTwipEvent
4010034c l F .text1 00000149 onSdaChange
4010049c l F .text1 00000267 onSclChange
40100704 l F .text1 00000028 onTimer
* Use enums for states, move one more var to twi struct
Make the TWI states enums and not #defines, in the hope that it will
allow GCC to more easily flag problems and general good code
organization.
401000cc l F .text1 00000014 twi_delay
401000e8 w F .text1 00000032 twi_releaseBus
40100128 g F .text1 00000217 twi_onTwipEvent
4010034c l F .text1 00000149 onSdaChange
4010049c l F .text1 00000257 onSclChange
401006f4 l F .text1 00000028 onTimer
Looks like another 16 bytes IRAM saved from the prior push.
Sketch uses 267079 bytes (25%) of program storage space. Maximum is 1044464 bytes.
Global variables use 27696 bytes (33%) of dynamic memory, leaving 54224 bytes for local variables. Maximum is 81920 bytes.
* Save 4 heap bytes by reprdering struct
* Convert to C++ class, clean up code
Convert the entire file into a C++ class (with C wrappers to preserve
the ABI). This allows for setting individual values of the global
struct(class) in-situ instead of a cryptic list at the end of the struct
definition. It also removes a lot of redundant `twi.`s from most class
members.
Clean up the code by converting from `#defines` to inline functions, get
rid of ternarys-as-ifs, use real enums, etc.
For slave_receiver.ino, the numbers are:
GIT Master IRAM: 0x723c
This push IRAM: 0x6fc0
For a savings of 636 total IRAM bytes (note, there may be a slight flash
text increase, but we have 1MB of flash to work with and only 32K of IRAM
so the tradeoff makes sense.
* Run astyle core.conf, clean up space/tab/etc.
Since the C++ version has significant text differences anyway, now is a
good time to clean up the mess of spaces, tabs, and differing cuddles.
* Add enum use comment, rename twi::delay, fix SDA/SCL_READ bool usage
Per review comments
* Replace clock stretch repeated code w/inline loop
There were multiple places where the code was waiting for a slave to
finish stretching the clock. Factor them out to an *inline* function
to reduce code smell.
* Remove slave code when not using slave mode
Add a new twi_setSlaveMode call which actually attached the interrupts
to the slave pin change code onSdaChenge/onSclChange. Don't attach
interrupts in the main twi_begin.
Because slave mode is only useful should a onoReceive or onRequest
callback, call twi_setSlaveMode and attach interrupts on the Wire
setters.
This allows GCC to not link in slave code unless slave mode is used,
saving over 1,000 bytes of IRAM in the common, master-only case.
* no-op test
* no-op test
* bionic
* missing python package for doc building with bionic
* fix previous commit
* remove external repo for gcc7 (causing issues), it is default under bionic
fix python3-setuptools install
* tryfix git submodule recursive (git 2.21/2.22 ?)
This change expands the NTP-TZ-DST example to list the active
SNTP servers. It lists the IP address server name (if used) and
reachability in ntpq style octal format.
Tests:
- Build against all LwIP stack configurations and correct
operation with a single SNTP server
- Vary connectivity to an SNTP server and check reachability
updates
- Configure 3 SNTP servers by name
- With a patched LwIP stack that supports simultaneous DHCP
and DHCPv6 SNTP servers check that all server details are
listed and update correctly during operation
cont_run is only called by loop_task(), which is not going to execute
during an IRQ and is stored, itself, in flash.
cont_yield cannot be called from an IRQ (since it's illegal to yield
inside IRQs), so move it out of IRAM, too.
Saves ~71 bytes of IRAM
This removes definitions relating to the built-in SNTP client that
are LwIP v1 specific. Instead of duplicating these pull in the
LwIP header that correspond to the required functions depending on
the version of the stack being used.
Without this fix calls to sntp_getserver() work but return invalid
data and can lead to stack exhaustion.
Update the NTP-TZ-DST example to use the Arduino sntp.h header
rather than duplicate the conditional checks to use the LwIP header.
Tests:
- Build against a simple SNTP API demonstratin app and all
LwIP configurations. Verify that the app runs for an extended
period and that the expected results are obtained.
* use a scheduled function for settimeofday_cb
* per review
* use a generic and clear name for trivial functional variable type name used for callbacks
use InterruptLock class for scoped interrupts instead of blindly disabling/enabling interrupts, which doesn't support nesting nor restore previous state.
Add forgotten include
Remove locks, simplify code
Fix typo
Drop needless include
This is another instance in the core library where we pass in read-only
parameters as pass-by-value, where in the case of String() that
is inefficient as it involves copy-constructor/temp string creations.
* Put longer string literals into PROGMEM
* Use Flash Strings for Debug output
This is hopefully very infrequently used, so it shouldn't
be in main memory.
Fixes#6590
The ASM block that implements the read-uint32-unaligned returns a
uint32_t. The old code was doing a cast like `(float)(uint32_t ret)
which actually goes and creates a new float of the positive uint value
(approx, of course due to exponent and sign bits) which is not correct.
C and C++ don't have a concise way to convert the bits in a register
from int to float interpretation, so avoid the whole issue by making a
new function which uses the same ASM block as the read-uint32-unaligned,
just make the destination and return values as floats.
* Align to latest EspSoftwareSerial release - nothing ESP8266 specific, but drifting versions otherwise makes life hard for users.
* ghostl array compatibility: aggregate initialization, no implicit cast to T*.
* Replace ASM block w/C marco for PSTR
GAS doesn't support the C language idiom of catenating two strings
together with quotes (i.e. "x" "y" === "xy").
Specify the section attribute fully in the section attribute, instead,
to allow this.
* Fix WString optimization
PR #6573 introduced a corner case where a blind String() without any
initialization was in an in invalid state because the buffer and len
would not be updated properly. Concatenating to the empty string could
cause a failure.
Now, set the default state in ::init() to SSO (which is what happened
before when we were using String(char *s="")) and fix the crash.
As @dirkmuller found out in #6568, there is a difference in code
executed between `String str(nullptr)` and `String str("")`, but in the
end the actual object is identical. It's a few bytes of code, but every
little bit counts.
Update the default `String()` constructor to use `nullptr` and not `""`.
This will remove a constant literal load and the execution of the
String::copy method and strlen().
* Remove duplicated sha1 implementation (Fixes#6568)
The Hash library had its own copy of a loop-unrolled sha1 implementation
adding a large code footprint for no good reason, as there are several
sha1 implementations already in tree (one in NONOS-SDK as well as one
in bearssl). Switching to the bearssl one is straightforward and removes
about 3kb of code size overhead.
Also cleanup some obvious inefficiencies (copy by value, string
summing, no reservation causing repeated reallocations) in the
implementation.
* Remove overload variants for sha1(...) that accept nonconst data
The data is always remaining unmodified, so non-const overloads
are confusing and redundant. Also optimize the hexify variant
a bit more.
The function accidentally compared the current location instead
of the passed in (new) location, which didn't match intended
logic and the code comment.
* Move all PSTRs to own section, allow string dedup
GNU ld can deduplicate strings, and does so for most normal char *s
automatically. However, for PSTRs we were using a unique section per
string *and* the section was not flagges as containing dedupable
0-terminated strings.
Modify the PSTR macro to emit assembly, which lets us set the section
flags required (SM) for the variables, and use inline assembly to get
the asm-block defined address.
Should result in smaller compiled binaries if any strings are
duplicated.
* Give each PSTR its own segment
* Allow disposing of unused strings before merging
Add the "a" section flag to allow the linker to throw away unneeded
strings. Without this flag, the linker will not discard unreferenced
strings and ROMs will increase in size, possibly dramatically.
