openharmony/third_party_littlefs
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_littlefs synced 2024-11-30 10:31:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
OpenHarmony-3.2-Beta2
third_party_littlefs/Makefile

115 lines
2.1 KiB
Makefile
Raw Permalink Normal View History

Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
ifdef BUILDDIR
# make sure BUILDDIR ends with a slash
override BUILDDIR := $(BUILDDIR)/
# bit of a hack, but we want to make sure BUILDDIR directory structure
# is correct before any commands
$(if $(findstring n,$(MAKEFLAGS)),, $(shell mkdir -p \
$(BUILDDIR) \
$(BUILDDIR)bd \
$(BUILDDIR)tests))
endif
# overridable target/src/tools/flags/etc
Added quality of life improvements for main.c/test.c issues 1. Added check for main.c and test.c to decide compilation target 2. Added step to remove test.c after successful test completion The test.c file, which contains the expanded test main, is useful when debugging why tests are failing. However, keeping the test.c file around causes problems when a later attempt is made to compile a larger project containing the littlefs directory. Under (hopefully) normal operation, tests always pass. So it should be ok to remove the test.c file after a successful test run. Hopefully this behaviour doesn't cause too much confusion for contributors using the tests. On the other side of things, compiling the library with no main ends (successfully) with the "main not found" error message. By defaulting to lfs.a if neither test.c/main.c is avoid this in the common cases found by armijnhemel and Sim4n6
2018-07-06 18:13:36 +00:00
ifneq ($(wildcard test.c main.c),)
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
TARGET ?= $(BUILDDIR)lfs
else
TARGET ?= $(BUILDDIR)lfs.a
Added quality of life improvements for main.c/test.c issues 1. Added check for main.c and test.c to decide compilation target 2. Added step to remove test.c after successful test completion The test.c file, which contains the expanded test main, is useful when debugging why tests are failing. However, keeping the test.c file around causes problems when a later attempt is made to compile a larger project containing the littlefs directory. Under (hopefully) normal operation, tests always pass. So it should be ok to remove the test.c file after a successful test run. Hopefully this behaviour doesn't cause too much confusion for contributors using the tests. On the other side of things, compiling the library with no main ends (successfully) with the "main not found" error message. By defaulting to lfs.a if neither test.c/main.c is avoid this in the common cases found by armijnhemel and Sim4n6
2018-07-06 18:13:36 +00:00
endif
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
Fixed a recompilation issue in CI, tweaked coverage.py a bit more This was lost in the Travis -> GitHub transition, in serializing some of the jobs, I missed that we need to clean between tests with different geometry configurations. Otherwise we end up running outdated binaries, which explains some of the weird test behavior we were seeing. Also tweaked a few script things: - Better subprocess error reporting (dump stderr on failure) - Fixed a BUILDDIR rule issue in test.py - Changed test-not-run status to None instead of undefined
2021-01-03 21:38:48 +00:00
Added cross-compile targets for testing Using gcc cross compilers and qemu: - make test CC="arm-linux-gnueabi-gcc --static -mthumb" EXEC="qemu-arm" - make test CC="powerpc-linux-gnu-gcc --static" EXEC="qemu-ppc" - make test CC="mips-linux-gnu-gcc --static" EXEC="qemu-mips" Also separated out Travis jobs and added some size reporting
2018-02-18 20:22:24 +00:00
CC ?= gcc
AR ?= ar
SIZE ?= size
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
CTAGS ?= ctags
Added scripts/code_size.py, for more in-depth code-size reporting Inspired by Linux's Bloat-O-Meter, code_size.py wraps nm to provide function-level code size, and supports detailed comparison between different builds. One difference is that code_size.py invokes littlefs's build system similarly to test.py, creating a duplicate build in the "sizes" directory. This makes it easy to monitor a cross-compiled build size while simultaneously testing on the host machine.
2020-12-13 14:35:31 +00:00
NM ?= nm
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
LCOV ?= lcov
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
Reduced build sources to just the core littlefs Currently this is just lfs.c and lfs_util.c. Previously this included the block devices, but this meant all of the scripts needed to explicitly deselect the block devices to avoid reporting build size/coverage info on them. Note that test.py still explicitly adds the block devices for compiling tests, which is their main purpose. Humorously this means the block devices will probably be compiled into most builds in this repo anyways.
2021-01-05 08:49:30 +00:00
SRC ?= $(wildcard *.c)
Fixed a recompilation issue in CI, tweaked coverage.py a bit more This was lost in the Travis -> GitHub transition, in serializing some of the jobs, I missed that we need to clean between tests with different geometry configurations. Otherwise we end up running outdated binaries, which explains some of the weird test behavior we were seeing. Also tweaked a few script things: - Better subprocess error reporting (dump stderr on failure) - Fixed a BUILDDIR rule issue in test.py - Changed test-not-run status to None instead of undefined
2021-01-03 21:38:48 +00:00
OBJ := $(SRC:%.c=$(BUILDDIR)%.o)
DEP := $(SRC:%.c=$(BUILDDIR)%.d)
ASM := $(SRC:%.c=$(BUILDDIR)%.s)
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
ifdef DEBUG
Moved -Werror flag to CI only The most useful part of -Werror is preventing code from being merged that has warnings. However it is annoying for users who may have different compilers with different warnings. Limiting -Werror to CI only covers the main concern about warnings without limiting users.
2018-01-29 17:30:53 +00:00
override CFLAGS += -O0 -g3
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
else
Moved -Werror flag to CI only The most useful part of -Werror is preventing code from being merged that has warnings. However it is annoying for users who may have different compilers with different warnings. Limiting -Werror to CI only covers the main concern about warnings without limiting users.
2018-01-29 17:30:53 +00:00
override CFLAGS += -Os
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
endif
Added trace statements through LFS_YES_TRACE To use, compile and run with LFS_YES_TRACE defined: make CFLAGS+=-DLFS_YES_TRACE=1 test_format The name LFS_YES_TRACE was chosen to match the LFS_NO_DEBUG and LFS_NO_WARN defines for the similar levels of output. The YES is necessary to avoid a conflict with the actual LFS_TRACE macro that gets emitting. LFS_TRACE can also be defined directly to provide a custom trace formatter. Hopefully having trace statements at the littlefs C API helps debugging and reproducing issues.
2019-05-31 09:40:19 +00:00
ifdef TRACE
override CFLAGS += -DLFS_YES_TRACE
endif
Moved -Werror flag to CI only The most useful part of -Werror is preventing code from being merged that has warnings. However it is annoying for users who may have different compilers with different warnings. Limiting -Werror to CI only covers the main concern about warnings without limiting users.
2018-01-29 17:30:53 +00:00
override CFLAGS += -I.
Added -Wjump-misses-init and fixed uninitialized warnings
2018-09-26 15:11:40 +00:00
override CFLAGS += -std=c99 -Wall -pedantic
Fix build with -Wundef Part of https://github.com/mongoose-os-libs/vfs-fs-lfs/issues/2
2019-08-07 21:58:13 +00:00
override CFLAGS += -Wextra -Wshadow -Wjump-misses-init -Wundef
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
Cleaned up test script and directory naming - Removed old tests and test scripts - Reorganize the block devices to live under one directory - Plugged new test framework into Makefile renamed: - scripts/test_.py -> scripts/test.py - tests_ -> tests - {file,ram,test}bd/* -> bd/* It took a surprising amount of effort to make the Makefile behave since it turns out the "test_%" rule could override "tests/test_%.toml.test" which is generated as part of test.py.
2020-01-27 03:37:49 +00:00
ifdef VERBOSE
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
override TESTFLAGS += -v
override CODEFLAGS += -v
override COVERAGEFLAGS += -v
Cleaned up test script and directory naming - Removed old tests and test scripts - Reorganize the block devices to live under one directory - Plugged new test framework into Makefile renamed: - scripts/test_.py -> scripts/test.py - tests_ -> tests - {file,ram,test}bd/* -> bd/* It took a surprising amount of effort to make the Makefile behave since it turns out the "test_%" rule could override "tests/test_%.toml.test" which is generated as part of test.py.
2020-01-27 03:37:49 +00:00
endif
Added coverage.py, and optional coverage info to test.py Now coverage information can be collected if you provide the --coverage to test.py. Internally this uses GCC's gcov instrumentation along with a new script, coverage.py, to parse *.gcov files. The main use for this is finding coverage info during CI runs. There's a risk that the instrumentation may make it more difficult to debug, so I decided to not make coverage collection enabled by default.
2020-12-31 19:41:35 +00:00
ifdef EXEC
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
override TESTFLAGS += --exec="$(EXEC)"
endif
ifdef BUILDDIR
override TESTFLAGS += --build-dir="$(BUILDDIR:/=)"
override CODEFLAGS += --build-dir="$(BUILDDIR:/=)"
endif
ifneq ($(NM),nm)
override CODEFLAGS += --nm-tool="$(NM)"
Added coverage.py, and optional coverage info to test.py Now coverage information can be collected if you provide the --coverage to test.py. Internally this uses GCC's gcov instrumentation along with a new script, coverage.py, to parse *.gcov files. The main use for this is finding coverage info during CI runs. There's a risk that the instrumentation may make it more difficult to debug, so I decided to not make coverage collection enabled by default.
2020-12-31 19:41:35 +00:00
endif
Cleaned up test script and directory naming - Removed old tests and test scripts - Reorganize the block devices to live under one directory - Plugged new test framework into Makefile renamed: - scripts/test_.py -> scripts/test.py - tests_ -> tests - {file,ram,test}bd/* -> bd/* It took a surprising amount of effort to make the Makefile behave since it turns out the "test_%" rule could override "tests/test_%.toml.test" which is generated as part of test.py.
2020-01-27 03:37:49 +00:00
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
# commands
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
.PHONY: all build
all build: $(TARGET)
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
.PHONY: asm
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
asm: $(ASM)
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
.PHONY: size
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
size: $(OBJ)
$(SIZE) -t $^
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
.PHONY: tags
tags:
Reduced build sources to just the core littlefs Currently this is just lfs.c and lfs_util.c. Previously this included the block devices, but this meant all of the scripts needed to explicitly deselect the block devices to avoid reporting build size/coverage info on them. Note that test.py still explicitly adds the block devices for compiling tests, which is their main purpose. Humorously this means the block devices will probably be compiled into most builds in this repo anyways.
2021-01-05 08:49:30 +00:00
$(CTAGS) --totals --c-types=+p $(shell find -H -name '*.h') $(SRC)
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
.PHONY: code
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
code: $(OBJ)
./scripts/code.py $^ $(CODEFLAGS)
Added scripts/code_size.py, for more in-depth code-size reporting Inspired by Linux's Bloat-O-Meter, code_size.py wraps nm to provide function-level code size, and supports detailed comparison between different builds. One difference is that code_size.py invokes littlefs's build system similarly to test.py, creating a duplicate build in the "sizes" directory. This makes it easy to monitor a cross-compiled build size while simultaneously testing on the host machine.
2020-12-13 14:35:31 +00:00
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
.PHONY: test
Cleaned up test script and directory naming - Removed old tests and test scripts - Reorganize the block devices to live under one directory - Plugged new test framework into Makefile renamed: - scripts/test_.py -> scripts/test.py - tests_ -> tests - {file,ram,test}bd/* -> bd/* It took a surprising amount of effort to make the Makefile behave since it turns out the "test_%" rule could override "tests/test_%.toml.test" which is generated as part of test.py.
2020-01-27 03:37:49 +00:00
test:
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
./scripts/test.py $(TESTFLAGS)
Cleaned up test script and directory naming - Removed old tests and test scripts - Reorganize the block devices to live under one directory - Plugged new test framework into Makefile renamed: - scripts/test_.py -> scripts/test.py - tests_ -> tests - {file,ram,test}bd/* -> bd/* It took a surprising amount of effort to make the Makefile behave since it turns out the "test_%" rule could override "tests/test_%.toml.test" which is generated as part of test.py.
2020-01-27 03:37:49 +00:00
.SECONDEXPANSION:
test%: tests/test$$(firstword $$(subst \#, ,%)).toml
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
./scripts/test.py $@ $(TESTFLAGS)
Created initial implementation of revamped test.py This is the start of reworking littlefs's testing framework based on lessons learned from the initial testing framework. 1. The testing framework needs to be _flexible_. It was hacky, which by itself isn't a downside, but it wasn't _flexible_. This limited what could be done with the tests and there ended up being many workarounds just to reproduce bugs. The idea behind this revamped framework is to separate the description of tests (tests/test_dirs.toml) and the running of tests (scripts/test.py). Now, with the logic moved entirely to python, it's possible to run the test under varying environments. In addition to the "just don't assert" run, I'm also looking to run the tests in valgrind for memory checking, and an environment with simulated power-loss. The test description can also contain abstract attributes that help control how tests can be ran, such as "leaky" to identify tests where memory leaks are expected. This keeps test limitations at a minimum without limiting how the tests can be ran. 2. Multi-stage-process tests didn't really add value and limited what the testing environment. Unmounting + mounting can be done in a single process to test the same logic. It would be really difficult to make this fail only when memory is zeroed, though that can still be caught by power-resilient tests. Requiring every test to be a single process adds several options for test execution, such as using a RAM-backed block device for speed, or even running the tests on a device. 3. Added fancy assert interception. This wasn't really a requirement, but something I've been wanting to experiment with for a while. During testing, scripts/explode_asserts.py is added to the build process. This is a custom C-preprocessor that parses out assert statements and replaces them with _very_ verbose asserts that wouldn't normally be possible with just C macros. It even goes as far as to report the arguments to strcmp, since the lack of visibility here was very annoying. tests_/test_dirs.toml:186:assert: assert failed with "..", expected eq "..." assert(strcmp(info.name, "...") == 0); One downside is that simply parsing C in python is slower than the entire rest of the compilation, but fortunately this can be alleviated by parallelizing the test builds through make. Other neat bits: - All generated files are a suffix of the test description, this helps cleanup and means it's (theoretically) possible to parallelize the tests. - The generated test.c is shoved base64 into an ad-hoc Makefile, this means it doesn't force a rebuild of tests all the time. - Test parameterizing is now easier. - Hopefully this framework can be repurposed also for benchmarks in the future.
2019-12-29 05:13:59 +00:00
Fixed a recompilation issue in CI, tweaked coverage.py a bit more This was lost in the Travis -> GitHub transition, in serializing some of the jobs, I missed that we need to clean between tests with different geometry configurations. Otherwise we end up running outdated binaries, which explains some of the weird test behavior we were seeing. Also tweaked a few script things: - Better subprocess error reporting (dump stderr on failure) - Fixed a BUILDDIR rule issue in test.py - Changed test-not-run status to None instead of undefined
2021-01-03 21:38:48 +00:00
.PHONY: coverage
coverage:
./scripts/coverage.py $(BUILDDIR)tests/*.toml.info $(COVERAGEFLAGS)
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
# rules
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
-include $(DEP)
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
.SUFFIXES:
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
$(BUILDDIR)lfs: $(OBJ)
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
$(CC) $(CFLAGS) $^ $(LFLAGS) -o $@
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
$(BUILDDIR)%.a: $(OBJ)
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
$(AR) rcs $@ $^
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
$(BUILDDIR)%.o: %.c
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
$(CC) -c -MMD $(CFLAGS) $< -o $@
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
$(BUILDDIR)%.s: %.c
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
$(CC) -S $(CFLAGS) $< -o $@
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
# clean everything
Switched to lcov for coverage collection, greatly simplified coverage.py Since we already have fairly complicated scriptts, I figured it wouldn't be too hard to use the gcov tools and directly parse their output. Boy was I wrong. The gcov intermediary format is a bit of a mess. In version 5.4, a text-based intermediary format is written to a single .gcov file per executable. This changed sometime before version 7.5, when it started writing separate .gcov files per .o files. And in version 9 this intermediary format has been entirely replaced with an incompatible json format! Ironically, this means the internal-only .gcda/.gcno binary format has actually been more stable than the intermediary format. Also there's no way to avoid temporary .gcov files generated in the project root, which risks messing with how test.py runs parallel tests. Fortunately this looks like it will be fixed in gcov version 9. --- Ended up switching to lcov, which was the right way to go. lcov handles all of the gcov parsing, provides an easily parsable output, and even provides a set of higher-level commands to manage coverage collection from different runs. Since this is all provided by lcov, was able to simplify coverage.py quite a bit. Now it just parses the .info files output by lcov.
2021-01-02 05:35:16 +00:00
.PHONY: clean
Initial commit of block device interface and emulated block device
2017-02-25 20:31:14 +00:00
clean:
rm -f $(TARGET)
rm -f $(OBJ)
rm -f $(DEP)
rm -f $(ASM)
Added BUILDDIR, a bit of script reworking Now littlefs's Makefile can work with a custom build directory for compilation output. Just set the BUILDDIR variable and the Makefile will take care of the rest. make BUILDDIR=build size This makes it very easy to compare builds with different compile-time configurations or different cross-compilers. This meant most of code.py's build isolation is no longer needed, so revisted the scripts and cleaned/tweaked a number of things. Also bought code.py in line with coverage.py, fixing some of the inconsistencies that were created while developing these scripts. One change to note was removing the inline measuring logic, I realized this feature is unnecessary thanks to GCC's -fkeep-static-functions and -fno-inline flags.
2021-01-02 05:50:59 +00:00
rm -f $(BUILDDIR)tests/*.toml.*
Reference in New Issue Copy Permalink