.editorconfig

+[**.c]
+indent_size = 4
+indent_style = space
+
+[**.yml]
+indent_size = 4
+indent_style = space

.gitignore

@@ -2,3 +2,8 @@
 prefix/
 sysroot/
 **/target/
+.gdb_history
+*.patch
+*.swp
+*.swo
+/.vim

.gitlab-ci.yml

 image: "redoxos/redoxer:latest"
 
+variables:
+  GIT_SUBMODULE_STRATEGY: recursive
+
 stages:
     - build
     - test
-
 before_script:
-    - apt-get update -qq
-    - apt-get install -qq git
-    - git submodule sync --recursive
-    - git submodule update --init --recursive
+    cargo install cbindgen
 
-cache:
-    paths:
-        - target/
+default:
+    cache:
+        paths:
+            - target/
 
 build:linux:
     stage: build
     script:
-        - rustup toolchain add "$(cat rust-toolchain)"
-        - rustup show      # Print version info for debugging
+        - rustup show # Ensure correct toolchain is downloaded and installed
         - make -j "$(nproc)" all
 
 build:redox:
@@ -26,34 +25,34 @@ build:redox:
     variables:
         TARGET: x86_64-unknown-redox
     script:
-        - export RUSTUP_TOOLCHAIN="$HOME/.redoxer/toolchain"
-        - export PATH="$RUSTUP_TOOLCHAIN/bin:$PATH"
-        - rustup show      # Print version info for debugging
-        - make -j "$(nproc)" all
+        - ./redoxer.sh -j "$(nproc)" all
 
 test:linux:
     stage: test
+    needs:
+        - build:linux
     dependencies:
         - build:linux
     script:
         - make test
 
-test:redox:
-    stage: test
-    dependencies:
-        - build:redox
-    variables:
-        TARGET: x86_64-unknown-redox
-    script:
-        - export CARGO_TEST="redoxer"
-        - export RUSTUP_TOOLCHAIN="$HOME/.redoxer/toolchain"
-        - export PATH="$RUSTUP_TOOLCHAIN/bin:$PATH"
-        - export TEST_RUNNER="redoxer exec --folder . -- sh --"
-        - make test
+#TODO: fix redoxer exec hangs
+# test:redox:
+#     stage: test
+#     needs:
+#         - build:redox
+#     dependencies:
+#         - build:redox
+#     variables:
+#         TARGET: x86_64-unknown-redox
+#     script:
+#         - ./redoxer.sh test
+#     # TODO: Out of memory
+#     allow_failure: true
 
 fmt:
     stage: test
+    needs: []
     script:
         - rustup component add rustfmt-preview
         - ./fmt.sh -- --check
-    allow_failure: true

.gitmodules

 [submodule "openlibm"]
 	path = openlibm
-	url = https://gitlab.redox-os.org/redox-os/openlibm.git
-[submodule "ralloc"]
-	path = ralloc
-	url = https://gitlab.redox-os.org/redox-os/ralloc.git
-[submodule "core_io"]
-	path = core_io
-	url = https://gitlab.redox-os.org/redox-os/core_io.git
+	url = https://github.com/JuliaMath/openlibm.git
+	branch = master
 [submodule "posix-regex"]
 	path = posix-regex
 	url = https://gitlab.redox-os.org/redox-os/posix-regex.git
-[submodule "pthreads-emb"]
-	path = pthreads-emb
-	url = https://gitlab.redox-os.org/redox-os/pthreads-emb.git
+[submodule "compiler-builtins"]
+	path = compiler-builtins
+	url = https://gitlab.redox-os.org/redox-os/compiler-builtins.git
+	branch = relibc_fix_dup_symbols
+[submodule "src/dlmalloc-rs"]
+	path = dlmalloc-rs
+	url = https://gitlab.redox-os.org/redox-os/dlmalloc-rs.git

.vscode/settings.json

+{
+    "cmake.ignoreCMakeListsMissing": true
+}
\ No newline at end of file

Cargo.toml

 [package]
 name = "relibc"
-version = "0.1.0"
+version = "0.2.5"
 authors = ["Jeremy Soller <jackpot51@gmail.com>"]
-edition = "2018"
+edition = "2021"
 
 [lib]
 name = "relibc"
 crate-type = ["staticlib"]
 
 [workspace]
-members = ["src/crt0", "src/crti", "src/crtn", "src/ld_so"]
-exclude = ["core_io", "ralloc"]
+members = [
+    "src/crt0",
+    "src/crti",
+    "src/crtn",
+    "redox-rt",
+    "ld_so",
+    "generic-rt",
+]
+exclude = ["tests", "dlmalloc-rs"]
 
 [build-dependencies]
-cbindgen = "0.13.2"
-cc = "1.0.25"
+cc = "1"
 
 [dependencies]
-cbitset = "0.1.0"
-core_io = { path = "core_io", features = ["collections"] }
-lazy_static = { version = "1.2.0", features = ["nightly", "spin_no_std"] }
-memoffset = "0.5.1"
+bitflags = "2"
+cbitset = "0.2"
 posix-regex = { path = "posix-regex", features = ["no_std"] }
-rand = { version = "0.5.5", default-features = false }
-memchr = { version = "2.2.0", default-features = false }
 
-[dependencies.goblin]
-version = "0.0.21"
-default-features = false
-features = ["elf32", "elf64", "endian_fd"]
+# TODO: For some reason, rand_jitter hasn't been updated to use the latest rand_core
+rand = { version = "0.8", default-features = false, features = ["small_rng"] }
+rand_xorshift = "0.3"
+rand_jitter = "0.4"
 
-[dependencies.ralloc]
-path = "ralloc"
+memchr = { version = "2.2.0", default-features = false }
+plain = "0.2"
+unicode-width = "0.1"
+__libc_only_for_layout_checks = { package = "libc", version = "0.2.149", optional = true }
+md5-crypto = { package = "md-5", version = "0.10.6", default-features = false }
+sha-crypt = { version = "0.5", default-features = false }
+base64ct = { version = "1.6", default-features = false, features = ["alloc"] }
+bcrypt-pbkdf = { version = "0.10", default-features = false, features = [
+    "alloc",
+] }
+scrypt = { version = "0.11", default-features = false, features = ["simple"] }
+pbkdf2 = { version = "0.12", features = ["sha2"] }
+sha2 = { version = "0.10", default-features = false }
+generic-rt = { path = "generic-rt" }
+chrono-tz = {version = "0.10", default-features = false}
+chrono = {version = "0.4", default-features = false, features = ["alloc"]}
+libm = "0.2"
+object = { version = "0.36.7", git = "https://gitlab.redox-os.org/andypython/object", default-features = false, features = ["elf", "read_core"] }
+spin = "0.9.8"
+
+[dependencies.dlmalloc]
+path = "dlmalloc-rs"
 default-features = false
-optional = true
+features = ["c_api"]
 
 [target.'cfg(target_os = "linux")'.dependencies]
-sc = "0.2.2"
+sc = "0.2.3"
 
 [target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall", rev = "0e1e7d5d" }
-spin = "0.4.10"
+redox_syscall = "0.5.8"
+redox-rt = { path = "redox-rt" }
+redox-path = "0.2"
+redox_event = { git = "https://gitlab.redox-os.org/redox-os/event.git", default-features = false, features = [
+    "redox_syscall",
+] }
 
 [features]
-default = []
+default = ["check_against_libc_crate"]
 trace = []
+check_against_libc_crate = ["__libc_only_for_layout_checks"]
 
 [profile.dev]
 panic = "abort"
 
 [profile.release]
 panic = "abort"
+
+[patch.crates-io]
+cc-11 = { git = "https://github.com/tea/cc-rs", branch = "riscv-abi-arch-fix", package = "cc" }

Makefile

-TARGET?=
+ifndef TARGET
+	export TARGET:=$(shell rustc -Z unstable-options --print target-spec-json | grep llvm-target | cut -d '"' -f4)
+endif
 
 CARGO?=cargo
 CARGO_TEST?=$(CARGO)
-CARGOFLAGS?=
+CARGO_COMMON_FLAGS=-Z build-std=core,alloc,compiler_builtins
+CARGOFLAGS?=$(CARGO_COMMON_FLAGS)
 RUSTCFLAGS?=
+export OBJCOPY?=objcopy
 
-# When using xargo, build it in local location
-export XARGO_HOME=$(CURDIR)/target/xargo
+BUILD?=$(shell pwd)/target/$(TARGET)
+CARGOFLAGS+=--target=$(TARGET)
 
-BUILD=target
-ifneq ($(TARGET),)
-	BUILD="target/$(TARGET)"
-	CARGOFLAGS+="--target=$(TARGET)"
-endif
+TARGET_HEADERS?=$(BUILD)/include
+export CFLAGS=-I$(TARGET_HEADERS)
+
+PROFILE?=release
+
+HEADERS_UNPARSED=$(shell find src/header -mindepth 1 -maxdepth 1 -type d -not -name "_*" -printf "%f\n")
+HEADERS_DEPS=$(shell find src/header -type f \( -name "cbindgen.toml" -o -name "*.rs" \))
+#HEADERS=$(patsubst %,%.h,$(subst _,/,$(HEADERS_UNPARSED)))
 
 ifeq ($(TARGET),aarch64-unknown-linux-gnu)
 	export CC=aarch64-linux-gnu-gcc
 	export LD=aarch64-linux-gnu-ld
 	export AR=aarch64-linux-gnu-ar
+	export NM=aarch64-linux-gnu-nm
+	export OBJCOPY=aarch64-linux-gnu-objcopy
+	export CPPFLAGS=
 endif
 
 ifeq ($(TARGET),aarch64-unknown-redox)
 	export CC=aarch64-unknown-redox-gcc
 	export LD=aarch64-unknown-redox-ld
 	export AR=aarch64-unknown-redox-ar
+	export NM=aarch64-unknown-redox-nm
+	export OBJCOPY=aarch64-unknown-redox-objcopy
+	export CPPFLAGS=
+endif
+
+ifeq ($(TARGET),x86_64-unknown-linux-gnu)
+	export CC=x86_64-linux-gnu-gcc
+	export LD=x86_64-linux-gnu-ld
+	export AR=x86_64-linux-gnu-ar
+	export NM=x86_64-linux-gnu-nm
+	export OBJCOPY=objcopy
+	export CPPFLAGS=
+endif
+
+ifeq ($(TARGET),i686-unknown-redox)
+	export CC=i686-unknown-redox-gcc
+	export LD=i686-unknown-redox-ld
+	export AR=i686-unknown-redox-ar
+	export NM=i686-unknown-redox-nm
+	export OBJCOPY=i686-unknown-redox-objcopy
+	export CPPFLAGS=
 endif
 
 ifeq ($(TARGET),x86_64-unknown-redox)
 	export CC=x86_64-unknown-redox-gcc
 	export LD=x86_64-unknown-redox-ld
 	export AR=x86_64-unknown-redox-ar
+	export NM=x86_64-unknown-redox-nm
+	export OBJCOPY=x86_64-unknown-redox-objcopy
+	export CPPFLAGS=
+endif
+
+ifeq ($(TARGET),riscv64gc-unknown-redox)
+	export CC=riscv64-unknown-redox-gcc
+	export LD=riscv64-unknown-redox-ld
+	export AR=riscv64-unknown-redox-ar
+	export NM=riscv64-unknown-redox-nm
+	export OBJCOPY=riscv64-unknown-redox-objcopy
+	export CPPFLAGS=-march=rv64gc -mabi=lp64d
 endif
 
 SRC=\
 	Cargo.* \
 	$(shell find src -type f)
 
-.PHONY: all clean fmt install install-headers libs test
-
-all: | libs
+BUILTINS_VERSION=0.1.70
+
+.PHONY: all clean fmt install install-libs install-headers install-tests libs headers submodules test
+
+all: | headers libs
+
+headers: $(HEADERS_DEPS)
+	rm -rf $(TARGET_HEADERS)
+	mkdir -pv $(TARGET_HEADERS)
+	cp -rv include/* $(TARGET_HEADERS)
+	cp -v "openlibm/include"/*.h $(TARGET_HEADERS)
+	cp -v "openlibm/src"/*.h $(TARGET_HEADERS)
+	set -e ; \
+	for header in $(HEADERS_UNPARSED); do \
+		echo "Header $$header"; \
+		if test -f "src/header/$$header/cbindgen.toml"; then \
+			out=`echo "$$header" | sed 's/_/\//g'`; \
+			out="$(TARGET_HEADERS)/$$out.h"; \
+			cat "src/header/$$header/cbindgen.toml" cbindgen.globdefs.toml \
+				 | cbindgen "src/header/$$header/mod.rs" --config=/dev/stdin --output "$$out"; \
+		fi \
+	done
 
 clean:
 	$(CARGO) clean
@@ -51,36 +113,46 @@ check:
 fmt:
 	./fmt.sh
 
-install-headers: libs
+install-headers: headers libs
 	mkdir -pv "$(DESTDIR)/include"
-	cp -rv "include"/* "$(DESTDIR)/include"
-	cp -rv "target/include"/* "$(DESTDIR)/include"
-	cp -v "openlibm/include"/*.h "$(DESTDIR)/include"
-	cp -v "openlibm/src"/*.h "$(DESTDIR)/include"
-	cp -v "pthreads-emb/"*.h "$(DESTDIR)/include"
+	cp -rv "$(TARGET_HEADERS)"/* "$(DESTDIR)/include"
 
 libs: \
-	$(BUILD)/release/libc.a \
-	$(BUILD)/release/libc.so \
-	$(BUILD)/release/crt0.o \
-	$(BUILD)/release/crti.o \
-	$(BUILD)/release/crtn.o \
-	$(BUILD)/release/ld_so
-
-install-libs: libs
+	$(BUILD)/$(PROFILE)/libc.a \
+	$(BUILD)/$(PROFILE)/libc.so \
+	$(BUILD)/$(PROFILE)/crt0.o \
+	$(BUILD)/$(PROFILE)/crti.o \
+	$(BUILD)/$(PROFILE)/crtn.o \
+	$(BUILD)/$(PROFILE)/ld_so
+
+install-libs: headers libs
 	mkdir -pv "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/release/libc.a" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/release/libc.so" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/release/crt0.o" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/release/crti.o" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/release/crtn.o" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/release/ld_so" "$(DESTDIR)/lib/ld64.so.1"
+	cp -v "$(BUILD)/$(PROFILE)/libc.a" "$(DESTDIR)/lib"
+	cp -v "$(BUILD)/$(PROFILE)/libc.so" "$(DESTDIR)/lib"
+	ln -vnfs libc.so "$(DESTDIR)/lib/libc.so.6"
+	cp -v "$(BUILD)/$(PROFILE)/crt0.o" "$(DESTDIR)/lib"
+	ln -vnfs crt0.o "$(DESTDIR)/lib/crt1.o"
+	cp -v "$(BUILD)/$(PROFILE)/crti.o" "$(DESTDIR)/lib"
+	cp -v "$(BUILD)/$(PROFILE)/crtn.o" "$(DESTDIR)/lib"
+	cp -v "$(BUILD)/$(PROFILE)/ld_so" "$(DESTDIR)/lib/ld64.so.1"
 	cp -v "$(BUILD)/openlibm/libopenlibm.a" "$(DESTDIR)/lib/libm.a"
-	cp -v "$(BUILD)/pthreads-emb/libpthread.a" "$(DESTDIR)/lib/libpthread.a"
+	# Empty libraries for dl, pthread, and rt
+	$(AR) -rcs "$(DESTDIR)/lib/libdl.a"
+	$(AR) -rcs "$(DESTDIR)/lib/libpthread.a"
+	$(AR) -rcs "$(DESTDIR)/lib/librt.a"
+
+install-tests: tests
+	$(MAKE) -C tests
+	mkdir -p "$(DESTDIR)/bin/relibc-tests"
+	cp -vr tests/bins_static/* "$(DESTDIR)/bin/relibc-tests/"
 
 install: install-headers install-libs
 
-sysroot: all
+submodules:
+	git submodule sync
+	git submodule update --init --recursive
+
+sysroot:
 	rm -rf $@
 	rm -rf $@.partial
 	mkdir -p $@.partial
@@ -89,12 +161,27 @@ sysroot: all
 	touch $@
 
 test: sysroot
-	$(CARGO_TEST) test
+	# TODO: Fix SIGILL when running cargo test
+	# $(CARGO_TEST) test
+	$(MAKE) -C tests run
 	$(MAKE) -C tests verify
 
+
+$(BUILD)/$(PROFILE)/libc.so: $(BUILD)/$(PROFILE)/librelibc.a $(BUILD)/openlibm/libopenlibm.a
+	$(CC) -nostdlib \
+		-shared \
+		-Wl,--gc-sections \
+		-Wl,-z,pack-relative-relocs \
+		-Wl,--sort-common \
+		-Wl,--allow-multiple-definition \
+		-Wl,--whole-archive $^ -Wl,--no-whole-archive \
+		-Wl,-soname,libc.so.6 \
+		-lgcc \
+		-o $@
+
 # Debug targets
 
-$(BUILD)/debug/libc.a: $(BUILD)/debug/librelibc.a $(BUILD)/pthreads-emb/libpthread.a $(BUILD)/openlibm/libopenlibm.a
+$(BUILD)/debug/libc.a: $(BUILD)/debug/librelibc.a $(BUILD)/openlibm/libopenlibm.a
 	echo "create $@" > "$@.mri"
 	for lib in $^; do\
 		echo "addlib $$lib" >> "$@.mri"; \
@@ -103,35 +190,33 @@ $(BUILD)/debug/libc.a: $(BUILD)/debug/librelibc.a $(BUILD)/pthreads-emb/libpthre
 	echo "end" >> "$@.mri"
 	$(AR) -M < "$@.mri"
 
-$(BUILD)/debug/libc.so: $(BUILD)/debug/librelibc.a $(BUILD)/pthreads-emb/libpthread.a $(BUILD)/openlibm/libopenlibm.a
-	$(CC) -nostdlib -shared -Wl,--allow-multiple-definition -Wl,--whole-archive $^ -Wl,--no-whole-archive -o $@
-
 $(BUILD)/debug/librelibc.a: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc $(CARGOFLAGS) -- --emit link=$@ $(RUSTCFLAGS)
+	$(CARGO) rustc $(CARGOFLAGS) -- --emit link=$@ -g -C debug-assertions=no $(RUSTCFLAGS)
+	./renamesyms.sh "$@" "$(BUILD)/debug/deps/"
 	touch $@
 
 $(BUILD)/debug/crt0.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/debug/crti.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/debug/crtn.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/debug/ld_so.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --manifest-path src/ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --manifest-path ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort -g -C debug-assertions=no $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/debug/ld_so: $(BUILD)/debug/ld_so.o $(BUILD)/debug/crti.o $(BUILD)/debug/libc.a $(BUILD)/debug/crtn.o
-	$(LD) --allow-multiple-definition --gc-sections --gc-keep-exported $^ -o $@
+	$(LD) --no-relax -T ld_so/ld_script/$(TARGET).ld --allow-multiple-definition --gc-sections $^ -o $@
 
 # Release targets
 
-$(BUILD)/release/libc.a: $(BUILD)/release/librelibc.a $(BUILD)/pthreads-emb/libpthread.a $(BUILD)/openlibm/libopenlibm.a
+$(BUILD)/release/libc.a: $(BUILD)/release/librelibc.a $(BUILD)/openlibm/libopenlibm.a
 	echo "create $@" > "$@.mri"
 	for lib in $^; do\
 		echo "addlib $$lib" >> "$@.mri"; \
@@ -140,31 +225,31 @@ $(BUILD)/release/libc.a: $(BUILD)/release/librelibc.a $(BUILD)/pthreads-emb/libp
 	echo "end" >> "$@.mri"
 	$(AR) -M < "$@.mri"
 
-$(BUILD)/release/libc.so: $(BUILD)/release/librelibc.a $(BUILD)/pthreads-emb/libpthread.a $(BUILD)/openlibm/libopenlibm.a
-	$(CC) -nostdlib -shared -Wl,--allow-multiple-definition -Wl,--whole-archive $^ -Wl,--no-whole-archive -o $@
-
 $(BUILD)/release/librelibc.a: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --release $(CARGOFLAGS) -- --emit link=$@ $(RUSTCFLAGS)
+	$(CARGO) rustc --release $(CARGOFLAGS) -- --emit link=$@ $(RUSTCFLAGS)
+	# TODO: Better to only allow a certain whitelisted set of symbols? Perhaps
+	# use some cbindgen hook, specify them manually, or grep for #[no_mangle].
+	./renamesyms.sh "$@" "$(BUILD)/release/deps/"
 	touch $@
 
 $(BUILD)/release/crt0.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --release --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --release --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/release/crti.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --release --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --release --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/release/crtn.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --release --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --release --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/release/ld_so.o: $(SRC)
-	CARGO_INCREMENTAL=0 $(CARGO) rustc --release --manifest-path src/ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
+	$(CARGO) rustc --release --manifest-path ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
 	touch $@
 
 $(BUILD)/release/ld_so: $(BUILD)/release/ld_so.o $(BUILD)/release/crti.o $(BUILD)/release/libc.a $(BUILD)/release/crtn.o
-	$(LD) --allow-multiple-definition --gc-sections --gc-keep-exported $^ -o $@
+	$(LD) --no-relax -T ld_so/ld_script/$(TARGET).ld --allow-multiple-definition --gc-sections $^ -o $@
 
 # Other targets
 
@@ -176,14 +261,5 @@ $(BUILD)/openlibm: openlibm
 	touch $@
 
 $(BUILD)/openlibm/libopenlibm.a: $(BUILD)/openlibm $(BUILD)/release/librelibc.a
-	$(MAKE) CC=$(CC) CPPFLAGS="-fno-stack-protector -I $(shell pwd)/include -I $(shell pwd)/target/include" -C $< libopenlibm.a
-
-$(BUILD)/pthreads-emb: pthreads-emb
-	rm -rf $@ $@.partial
-	mkdir -p $(BUILD)
-	cp -r $< $@.partial
-	mv $@.partial $@
-	touch $@
-
-$(BUILD)/pthreads-emb/libpthread.a: $(BUILD)/pthreads-emb $(BUILD)/release/librelibc.a
-	$(MAKE) CC=$(CC) CFLAGS="-fno-stack-protector -I $(shell pwd)/include -I $(shell pwd)/target/include" -C $< libpthread.a
+	$(MAKE) AR=$(AR) CC=$(CC) LD=$(LD) CPPFLAGS="$(CPPFLAGS) -fno-stack-protector -I$(shell pwd)/include -I$(TARGET_HEADERS)" -C $< libopenlibm.a
+	./renamesyms.sh "$@" "$(BUILD)/release/deps/"

README.md

-# relibc ![build](https://travis-ci.org/redox-os/relibc.svg?branch=master)
-relibc is a portable POSIX C standard library written in Rust. It is under heavy development, and currently supports Redox and Linux.
+# Redox C Library (relibc)
 
-The motivation for this project is twofold: Reduce issues the redox crew was having with newlib, and create a safer alternative to a C standard library written in C. It is mainly designed to be used under redox, as an alternative to newlib, but it also supports linux syscalls via the [sc](https://crates.io/crates/sc) crate.
+relibc is a portable POSIX C standard library written in Rust and is under heavy development.
 
-### [Contributing](CONTRIBUTING.md)
+The motivation for this project is twofold: Reduce issues that the Redox developers were having with [newlib](https://sourceware.org/newlib/), and create a safer alternative to a C standard library written in C. It is mainly designed to be used under Redox, as an alternative to newlib, but it also supports Linux system calls via the [sc](https://crates.io/crates/sc) crate.
+
+Currently Redox and Linux are supported.
+
+## redox-rt
+
+redox-rt is our equivalent for [vDSO](https://en.wikipedia.org/wiki/VDSO) from Linux.
+
+## Repository Layout
+
+- `include` - Header files (mostly macros and variadic functions `cbindgen` can't generate)
+- `src` - Source files
+- `src/c` - C code
+- `src/crt0` - Runtime code
+- `src/crti` - Runtime code
+- `src/crtn` - Runtime code
+- `src/header` - Header files implementation
+- `src/header/*` - Each folder has a `cbindgen.toml` file, it generates a C-to-Rust interface and header files
+- `src/ld_so` - Dynamic loader code
+- `src/platform` - Platform-specific and common code
+- `src/platform/redox` - Redox-specific code
+- `src/platform/linux` - Linux-specific code
+- `src/pthread` - pthread implementation
+- `src/sync` - Synchronization primitives
+- `tests` - C tests (each MR needs to give success in all of them)
+
+## Download the sources
+
+To download the relibc sources run the following command:
+
+```sh
+git clone --recursive https://gitlab.redox-os.org/redox-os/relibc
+```
+
+## Build Instructions
+
+To build relibc out of the Redox build system, do the following steps:
+
+### Dependencies
+
+- Install `cbindgen`
+
+```sh
+cargo install cbindgen
+```
+
+#### Install the `expect` tool
+
+- Debian, Ubuntu and PopOS:
+
+```sh
+sudo apt install expect
+```
+
+- Fedora:
+
+```sh
+sudo dnf install expect
+```
+
+- Arch Linux:
+
+```sh
+sudo pacman -S expect
+```
+
+### Build Relibc
+
+To build the relibc library objects, run the following command:
+
+```sh
+make all
+```
+
+- Clean old library objects and tests
+
+```sh
+make clean
+```
+
+## Build relibc inside the Redox build system
+
+Inside of your Redox build system, run:
+
+```sh
+make prefix
+```
+
+If you need to rebuild `relibc` for testing a Cookbook recipe, run:
+
+```sh
+touch relibc
+make prefix r.recipe-name
+```
+
+Touching (changing the "last modified time" of) the `relibc` folder is needed to trigger recompilation for `make prefix`. Replace `recipe-name` with your desired recipe name.
+
+Note: Do not edit `relibc` inside `prefix` folder! Do your work on `relibc` folder directly inside your Redox build system instead.
+
+## Tests
+
+This section explain how to build and run the tests.
+
+### Build
+
+To build the tests run `make all` on the `tests` folder, it will store the executables at `tests/bins_static`
+
+If you did changes to your tests, run `make clean all` to rebuild the executables.
+
+### Redox OS Testing
+
+To test on Redox do the following steps:
+
+- Add the `relibc-tests` recipe on your filesystem configuration at `config/your-cpu/your-config.toml` (generally `desktop.toml`)
+- Run the following commands to rebuild relibc with your changes, update the `relibc-tests` recipe and update your QEMU image:
+
+```sh
+touch relibc
+```
+
+```sh
+make prefix cr.relibc-tests image
+```
+
+- Run the tests
+
+```sh
+/usr/share/relibc-tests/bins_static/test-name
+```
+
+### Linux Testing
+
+Run `make test` on the relibc directory.
+
+If you want to run one test, run the following command:
+
+```sh
+tests/bins_static/test-name
+```
+
+## Issues
+
+#### I'm building for my own platform which I run, and am getting `x86_64-linux-gnu-ar: command not found` (or similar)
+
+The Makefile expects GNU compiler tools prefixed with the platform specifier, as would be present when you installed a cross compiler. Since you are building for your own platform, some Linux distributions (like Manjaro) don't install/symlink the prefixed executables.
+
+An easy fix would be to replace the corresponding lines in the Makefile, e.g.
+
+```diff
+ ifeq ($(TARGET),x86_64-unknown-linux-gnu)
+        export CC=x86_64-linux-gnu-gcc
+-       export LD=x86_64-linux-gnu-ld
+-       export AR=x86_64-linux-gnu-ar
++       export LD=ld
++       export AR=ar
+        export OBJCOPY=x86_64-linux-gnu-objcopy
+ endif
+```
+
+## Contributing
+
+Before starting to contribute, read [this](CONTRIBUTING.md) document.
 
 ## Supported OSes
 
- - Redox OS
- - Linux
+- Redox OS
+- Linux
 
 ## Supported architectures
 
- - x86\_64
- - Aarch64
+- i686 (Intel/AMD)
+- x86_64 (Intel/AMD)
+- Aarch64 (ARM64)

Xargo.toml

-[dependencies.alloc]

build.rs

-extern crate cbindgen;
 extern crate cc;
 
-use std::{env, fs, fs::DirEntry, path::Path};
+use std::{env, fs};
 
-// include src/header directories that don't start with '_'
-fn include_dir(d: &DirEntry) -> bool {
-    d.metadata().map(|m| m.is_dir()).unwrap_or(false)
-        && d.path()
-            .iter()
-            .nth(2)
-            .map_or(false, |c| c.to_str().map_or(false, |x| !x.starts_with("_")))
-}
-
-fn generate_bindings(cbindgen_config_path: &Path) {
-    let relative_path = cbindgen_config_path
-        .strip_prefix("src/header")
-        .ok()
-        .and_then(|p| p.parent())
-        .and_then(|p| p.to_str())
-        .unwrap()
-        .replace("_", "/");
-    let header_path = Path::new("target/include")
-        .join(&relative_path)
-        .with_extension("h");
-    let mod_path = cbindgen_config_path.with_file_name("mod.rs");
-    let config = cbindgen::Config::from_file(cbindgen_config_path).unwrap();
-    cbindgen::Builder::new()
-        .with_config(config)
-        .with_src(mod_path)
-        .generate()
-        .expect("Unable to generate bindings")
-        .write_to_file(header_path);
+fn get_target() -> String {
+    env::var("TARGET").unwrap_or(
+        option_env!("TARGET").map_or("x86_64-unknown-redox".to_string(), |x| x.to_string()),
+    )
 }
 
 fn main() {
     let crate_dir = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set");
+    let target = get_target();
+
+    println!("cargo:rerun-if-changed=src/c");
+
+    let mut cc_builder = &mut cc::Build::new();
+
+    cc_builder = cc_builder.flag("-nostdinc").flag("-nostdlib");
 
-    // Generate C includes
-    // - based on contents of src/header/**
-    // - headers written to target/include
-    fs::read_dir(&Path::new("src/header"))
-        .unwrap()
-        .into_iter()
-        .filter_map(Result::ok)
-        .filter(|d| include_dir(d))
-        .map(|d| d.path().as_path().join("cbindgen.toml"))
-        .filter(|p| p.exists())
-        .for_each(|p| {
-            println!("cargo:rerun-if-changed={:?}", p.parent().unwrap());
-            println!("cargo:rerun-if-changed={:?}", p);
-            println!("cargo:rerun-if-changed={:?}", p.with_file_name("mod.rs"));
-            generate_bindings(&p);
-        });
+    if target.starts_with("aarch64") {
+        cc_builder = cc_builder.flag("-mno-outline-atomics")
+    }
 
-    cc::Build::new()
-        .flag("-nostdinc")
-        .flag("-nostdlib")
-        .include(&format!("{}/include", crate_dir))
+    cc_builder
         .flag("-fno-stack-protector")
         .flag("-Wno-expansion-to-defined")
         .files(

cbindgen.globdefs.toml

+
+# needs a leading newline
+[defines]
+"target_os=redox" = "__redox__"
+"target_os=linux" = "__linux__"
+"target_pointer_width=64" = "__LP64__"
+"target_pointer_width=32" = "__LP32__"
+"target_arch=x86" = "__i386__"
+"target_arch=x86_64" = "__x86_64__"
+"target_arch=aarch64" = "__aarch64__"
+# This is not exact. It should be `defined(__riscv) && defined(__LP64__)`, or `defined(__riscv) && __riscv_xlen==64`
+# This will do however, as long as we only support riscv64 and not riscv32
+"target_arch=riscv64" = "__riscv"
+
+# XXX: silences a warning
+"feature = no_std" = "__relibc__"
+
+# Ensure attributes are passed down from Rust
+# <features.h> must be included where attributes are used in relibc
+[fn]
+must_use = "__nodiscard"
+deprecated = "__deprecated"
+deprecated_with_note = "__deprecatedNote({})"
+no_return = "__noreturn"

core_io @ 8f253772

-Subproject commit 8f253772c98389e8394eca99ba7ac72addf79dba

dlmalloc-rs @ 2242e05d

+Subproject commit 2242e05dc862f221fa1c0cc8ef23f0e9595b1dfa

fmt.sh

 #!/usr/bin/env bash
 
-cargo fmt --package relibc --package crt0 "$@"
+cargo fmt --package relibc --package crt0 --package redox-rt "$@"

generic-rt/Cargo.toml

+[package]
+name = "generic-rt"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

generic-rt/src/lib.rs

+#![no_std]
+#![feature(core_intrinsics)]
+
+use core::{
+    arch::asm,
+    mem::{self, offset_of},
+};
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct GenericTcb<Os> {
+    /// Pointer to the end of static TLS. Must be the first member
+    pub tls_end: *mut u8,
+    /// Size of the memory allocated for the static TLS in bytes (multiple of page size)
+    pub tls_len: usize,
+    /// Pointer to this structure
+    pub tcb_ptr: *mut Self,
+    /// Size of the memory allocated for this structure in bytes (should be same as page size)
+    pub tcb_len: usize,
+    pub os_specific: Os,
+}
+impl<Os> GenericTcb<Os> {
+    /// Architecture specific code to read a usize from the TCB - aarch64
+    #[inline(always)]
+    #[cfg(target_arch = "aarch64")]
+    pub unsafe fn arch_read(offset: usize) -> usize {
+        let abi_ptr: usize;
+        asm!(
+            "mrs {}, tpidr_el0",
+            out(reg) abi_ptr,
+        );
+
+        let tcb_ptr = *(abi_ptr as *const usize);
+        *((tcb_ptr + offset) as *const usize)
+    }
+
+    /// Architecture specific code to read a usize from the TCB - x86
+    #[inline(always)]
+    #[cfg(target_arch = "x86")]
+    pub unsafe fn arch_read(offset: usize) -> usize {
+        let value;
+        asm!(
+            "
+            mov {}, gs:[{}]
+            ",
+            out(reg) value,
+            in(reg) offset,
+        );
+        value
+    }
+
+    /// Architecture specific code to read a usize from the TCB - x86_64
+    #[inline(always)]
+    #[cfg(target_arch = "x86_64")]
+    pub unsafe fn arch_read(offset: usize) -> usize {
+        let value;
+        asm!(
+            "
+            mov {}, fs:[{}]
+            ",
+            out(reg) value,
+            in(reg) offset,
+        );
+        value
+    }
+
+    /// Architecture specific code to read a usize from the TCB - riscv64
+    #[inline(always)]
+    #[cfg(target_arch = "riscv64")]
+    unsafe fn arch_read(offset: usize) -> usize {
+        let value;
+        asm!(
+            "ld {value}, -8(tp)", // TCB
+            "add {value}, {value}, {offset}",
+            "ld {value}, 0({value})",
+            value = out(reg) value,
+            offset = in(reg) offset,
+        );
+        value
+    }
+
+    pub unsafe fn current_ptr() -> Option<*mut Self> {
+        let tcb_ptr = Self::arch_read(offset_of!(Self, tcb_ptr)) as *mut Self;
+        let tcb_len = Self::arch_read(offset_of!(Self, tcb_len));
+        if tcb_ptr.is_null() || tcb_len < mem::size_of::<Self>() {
+            None
+        } else {
+            Some(tcb_ptr)
+        }
+    }
+    pub unsafe fn current() -> Option<&'static mut Self> {
+        Some(&mut *Self::current_ptr()?)
+    }
+}
+pub fn panic_notls(msg: impl core::fmt::Display) -> ! {
+    //eprintln!("panicked in ld.so: {}", msg);
+
+    core::intrinsics::abort();
+}
+
+pub trait ExpectTlsFree {
+    type Unwrapped;
+
+    fn expect_notls(self, msg: &str) -> Self::Unwrapped;
+}
+impl<T, E: core::fmt::Debug> ExpectTlsFree for Result<T, E> {
+    type Unwrapped = T;
+
+    fn expect_notls(self, msg: &str) -> T {
+        match self {
+            Ok(t) => t,
+            Err(err) => panic_notls(format_args!(
+                "{}: expect failed for Result with err: {:?}",
+                msg, err
+            )),
+        }
+    }
+}
+impl<T> ExpectTlsFree for Option<T> {
+    type Unwrapped = T;
+
+    fn expect_notls(self, msg: &str) -> T {
+        match self {
+            Some(t) => t,
+            None => panic_notls(format_args!("{}: expect failed for Option", msg)),
+        }
+    }
+}

include/bits/assert.h

-#ifndef _BITS_ASSERT_H
-#define _BITS_ASSERT_H
+// Do not use include guard, to ensure assert is always defined
+#ifdef assert
+#undef assert
+#endif
 
 #ifdef NDEBUG
 # define assert(cond) (void) 0
@@ -7,5 +9,3 @@
 # define assert(cond) \
   ((void)((cond) || (__assert_fail(__func__, __FILE__, __LINE__, #cond), 0)))
 #endif
-
-#endif

include/bits/elf.h

+#ifndef _BITS_ELF_H                                                          
+#define _BITS_ELF_H
+#define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
+#define ELF32_ST_TYPE(val)		((val) & 0xf)
+#define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
+
+#define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
+#define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
+#define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
+
+
+#define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
+#define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
+
+#define ELF32_R_SYM(val)		((val) >> 8)
+#define ELF32_R_TYPE(val)		((val) & 0xff)
+#define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
+
+#define ELF64_R_SYM(i)			((i) >> 32)
+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
+#define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
+
+#define DT_VALRNGHI	0x6ffffdff
+#define DT_VALTAGIDX(tag)	(DT_VALRNGHI - (tag))
+
+#define DT_ADDRRNGHI	0x6ffffeff
+#define DT_ADDRTAGIDX(tag)	(DT_ADDRRNGHI - (tag))
+
+#define	DT_VERNEEDNUM	0x6fffffff
+#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))
+
+#define ELF32_M_SYM(info)	((info) >> 8)
+#define ELF32_M_SIZE(info)	((unsigned char) (info))
+#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
+
+#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
+#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
+#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
+
+#endif /* ifdef _BITS_ELF_H*/

include/bits/errno.h

@@ -5,10 +5,9 @@
 extern "C" {
 #endif
 
-#define ENOTSUP EOPNOTSUPP
-
 #define errno (*__errno_location())
 #define program_invocation_name (*__program_invocation_name())
+#define program_invocation_short_name (*__program_invocation_short_name())
 
 #ifdef __cplusplus
 } // extern "C"