diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000..e3c1b241e
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,32 @@
+name: build and run tests
+
+on:
+  push:
+    branches: [ mob ]
+
+jobs:
+  test-x86_64-linux:
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v3
+    - name: make & test tcc
+      run: ./configure && make && make test -k
+
+  test-x86_64-osx:
+    runs-on: macos-11
+    steps:
+    - uses: actions/checkout@v3
+    - name: make & test tcc
+      run: ./configure && make && make test -k
+
+  test-x86_64-win32:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v3
+    - name: make & test tcc
+      shell: cmd
+      run: |
+        set MSYS2_PATH_TYPE=inherit
+        set MSYSTEM=MINGW64
+        set CHERE_INVOKING=yes
+        C:\msys64\usr\bin\bash -l -c "./configure && make && make test -k"
diff --git a/.gitignore b/.gitignore
index 34804df4c..24ee96124 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,6 +16,8 @@
 a.out
 tcc_g
 tcc
+tcc_c
+tcc_p
 *-tcc
 libtcc*.def
 
@@ -24,10 +26,12 @@ config*.h
 config*.mak
 config.texi
 conftest*
+c2str
 tags
 TAGS
 tcc.1
-tcc.pod
+*.pod
+*.tcov
 tcc-doc.html
 tcc-doc.info
 
diff --git a/Changelog b/Changelog
index 17f5bdedf..7ccf11da1 100644
--- a/Changelog
+++ b/Changelog
@@ -1,3 +1,27 @@
+version 0.9.28:
+
+User interface:
+- -b : bounds checker much improved (herman ten brugge)
+- -bt : support for standalone backtraces also (grischka)
+- -gdwarf : debug format (herman ten brugge)
+- -M, -MM, and -MMD (Arthur Williams)
+- -W[no-]error=<option> (Steffen Nurpmeso)
+
+Platforms:
+- new RISC-V (riscv64) target (Michael Matz)
+- native macOS support for x86_64 (Michael Matz, Herman ten Brugge)
+- arm and riscv64 assemblers (Danny Milosavljevic)
+- Android support with position independent executables (grischka)
+
+Features:
+- _Static_assert() (matthias)
+- __attribute__ ((cleanup(func))) (matthias)
+- stdatomic (Dmitry Selyutin)
+- asm goto ("jmp %l[label]" : : : : label) (Michael Matz)
+
+Fixes:
+- ... many, see git shortlog release_0_9_27...release_0_9_27
+
 Version 0.9.27:
 
 User interface:
diff --git a/Makefile b/Makefile
index 15ece52a8..98d65f67b 100644
--- a/Makefile
+++ b/Makefile
@@ -8,12 +8,6 @@ ifndef TOP
  INCLUDED = no
 endif
 
-# Uncomment the next two commands to allow debug this Makefile
-# When enabled, GNU make will no longer execute commands directly.
-# All build commands will be executed using the shell. This needs more time
-#OLD_SHELL := $(SHELL)
-#SHELL = $(info Building $* $(if $<, (from $<))$(if $?, ($? newer)))$(OLD_SHELL)
-
 ifeq ($(findstring $(MAKECMDGOALS),clean distclean),)
  include $(TOP)/config.mak
 endif
@@ -36,13 +30,19 @@ ifdef CONFIG_WIN32
   LIBTCC = libtcc$(DLLSUF)
   LIBTCCDEF = libtcc.def
  endif
+ ifneq ($(CONFIG_debug),yes)
+  LDFLAGS += -s
+ endif
  NATIVE_TARGET = $(ARCH)-win$(if $(findstring arm,$(ARCH)),ce,32)
 else
  CFG = -unx
- LIBS=-lm -lpthread
+ LIBS+=-lm
  ifneq ($(CONFIG_ldl),no)
   LIBS+=-ldl
  endif
+ ifneq ($(CONFIG_pthread),no)
+  LIBS+=-lpthread
+ endif
  # make libtcc as static or dynamic library?
  ifeq ($(CONFIG_static),no)
   LIBTCC=libtcc$(DLLSUF)
@@ -55,8 +55,8 @@ else
       # `make test' when libtcc.dylib is used (configure --disable-static), so
       # we bake a relative path into the binary. $libdir is used after install.
       LINK_LIBTCC += -Wl,-rpath,"@executable_path/$(TOP)" -Wl,-rpath,"$(libdir)"
-      DYLIBVER += -current_version $(VERSION)
-      DYLIBVER += -compatibility_version $(VERSION)
+      DYLIBVER += -current_version $(MACOS_DYLIB_VERSION)
+      DYLIBVER += -compatibility_version $(MACOS_DYLIB_VERSION)
     endif
   endif
  endif
@@ -74,7 +74,8 @@ endif
 TCCFLAGS-unx = -B$(TOP) -I$(TOPSRC)/include -I$(TOPSRC) -I$(TOP)
 TCCFLAGS-win = -B$(TOPSRC)/win32 -I$(TOPSRC)/include -I$(TOPSRC) -I$(TOP) -L$(TOP)
 TCCFLAGS = $(TCCFLAGS$(CFG))
-TCC = $(TOP)/tcc$(EXESUF) $(TCCFLAGS)
+TCC_LOCAL = $(TOP)/tcc$(EXESUF)
+TCC = $(TCC_LOCAL) $(TCCFLAGS)
 
 CFLAGS_P = $(CFLAGS) -pg -static -DCONFIG_TCC_STATIC -DTCC_PROFILE
 LIBS_P = $(LIBS)
@@ -96,7 +97,12 @@ NATIVE_DEFINES_$(CONFIG_arm_vfp) += -DTCC_ARM_VFP
 NATIVE_DEFINES_$(CONFIG_arm64) += -DTCC_TARGET_ARM64
 NATIVE_DEFINES_$(CONFIG_riscv64) += -DTCC_TARGET_RISCV64
 NATIVE_DEFINES_$(CONFIG_BSD) += -DTARGETOS_$(TARGETOS)
+NATIVE_DEFINES_$(CONFIG_Android) += -DTARGETOS_ANDROID
 NATIVE_DEFINES_$(CONFIG_pie) += -DCONFIG_TCC_PIE
+NATIVE_DEFINES_$(CONFIG_pic) += -DCONFIG_TCC_PIC
+NATIVE_DEFINES_no_$(CONFIG_new_macho) += -DCONFIG_NEW_MACHO=0
+NATIVE_DEFINES_$(CONFIG_codesign) += -DCONFIG_CODESIGN
+NATIVE_DEFINES_$(CONFIG_new-dtags) += -DCONFIG_NEW_DTAGS
 NATIVE_DEFINES_no_$(CONFIG_bcheck) += -DCONFIG_TCC_BCHECK=0
 NATIVE_DEFINES_no_$(CONFIG_backtrace) += -DCONFIG_TCC_BACKTRACE=0
 NATIVE_DEFINES += $(NATIVE_DEFINES_yes) $(NATIVE_DEFINES_no_no)
@@ -174,14 +180,12 @@ DEFINES += $(if $(ROOT-$T),-DCONFIG_SYSROOT="\"$(ROOT-$T)\"")
 DEFINES += $(if $(CRT-$T),-DCONFIG_TCC_CRTPREFIX="\"$(CRT-$T)\"")
 DEFINES += $(if $(LIB-$T),-DCONFIG_TCC_LIBPATHS="\"$(LIB-$T)\"")
 DEFINES += $(if $(INC-$T),-DCONFIG_TCC_SYSINCLUDEPATHS="\"$(INC-$T)\"")
+DEFINES += $(if $(ELF-$T),-DCONFIG_TCC_ELFINTERP="\"$(ELF-$T)\"")
 DEFINES += $(DEF-$(or $(findstring win,$T),unx))
 
 ifneq ($(X),)
-ifeq ($(CONFIG_WIN32),yes)
-DEF-win += -DTCC_LIBTCC1="\"$(X)libtcc1.a\""
-DEF-unx += -DTCC_LIBTCC1="\"lib/$(X)libtcc1.a\""
-else
-DEF-all += -DTCC_LIBTCC1="\"$(X)libtcc1.a\""
+DEF-all += -DCONFIG_TCC_CROSSPREFIX="\"$X\""
+ifneq ($(CONFIG_WIN32),yes)
 DEF-win += -DCONFIG_TCCDIR="\"$(tccdir)/win32\""
 endif
 endif
@@ -189,7 +193,22 @@ endif
 # include custom configuration (see make help)
 -include config-extra.mak
 
-CORE_FILES = tcc.c tcctools.c libtcc.c tccpp.c tccgen.c tccelf.c tccasm.c tccrun.c
+ifneq ($(X),)
+ifneq ($(T),$(NATIVE_TARGET))
+# assume support files for cross-targets in "/usr/<triplet>" by default
+TRIPLET-i386 ?= i686-linux-gnu
+TRIPLET-x86_64 ?= x86_64-linux-gnu
+TRIPLET-arm ?= arm-linux-gnueabi
+TRIPLET-arm64 ?= aarch64-linux-gnu
+TRIPLET-riscv64 ?= riscv64-linux-gnu
+TR = $(if $(TRIPLET-$T),$T,ignored)
+CRT-$(TR) ?= /usr/$(TRIPLET-$T)/lib
+LIB-$(TR) ?= {B}:/usr/$(TRIPLET-$T)/lib
+INC-$(TR) ?= {B}/include:/usr/$(TRIPLET-$T)/include
+endif
+endif
+
+CORE_FILES = tcc.c tcctools.c libtcc.c tccpp.c tccgen.c tccdbg.c tccelf.c tccasm.c tccrun.c
 CORE_FILES += tcc.h config.h libtcc.h tcctok.h
 i386_FILES = $(CORE_FILES) i386-gen.c i386-link.c i386-asm.c i386-asm.h i386-tok.h
 i386-win32_FILES = $(i386_FILES) tccpe.c
@@ -228,23 +247,21 @@ $(TCC_FILES) : DEFINES += -DONE_SOURCE=0
 $(X)tccpp.o : $(TCCDEFS_H)
 endif
 
-GITHASH := $(shell git rev-parse >/dev/null 2>&1 && git rev-parse --short HEAD || echo no)
+GITHASH:=$(shell git rev-parse --abbrev-ref HEAD 2>/dev/null || echo no)
 ifneq ($(GITHASH),no)
-DEF_GITHASH := -DTCC_GITHASH="\"$(shell git rev-parse --abbrev-ref HEAD):$(GITHASH)$(shell git diff --quiet || echo '-mod')\""
+GITHASH:=$(shell git log -1 --date=short --pretty='format:%cd $(GITHASH)@%h')
+GITMODF:=$(shell git diff --quiet || echo '*')
+DEF_GITHASH:= -DTCC_GITHASH="\"$(GITHASH)$(GITMODF)\""
 endif
 
 ifeq ($(CONFIG_debug),yes)
 CFLAGS += -g
 LDFLAGS += -g
-else
-ifndef CONFIG_OSX
-LDFLAGS += -s
-endif
 endif
 
 # convert "include/tccdefs.h" to "tccdefs_.h"
 %_.h : include/%.h conftest.c
-	$S$(CC) -DC2STR $(filter %.c,$^) -o c2str$(EXESUF) && ./c2str$(EXESUF) $< $@
+	$S$(CC) -DC2STR $(filter %.c,$^) -o c2str.exe && ./c2str.exe $< $@
 
 # target specific object rule
 $(X)%.o : %.c $(LIBTCC_INC)
@@ -261,7 +278,7 @@ tcc$(EXESUF): tcc.o $(LIBTCC)
 # Cross Tiny C Compilers
 # (the TCCDEFS_H dependency is only necessary for parallel makes,
 # ala 'make -j x86_64-tcc i386-tcc tcc', which would create multiple
-# c2str and tccdefs_.h files in parallel, leading to access errors.
+# c2str.exe and tccdefs_.h files in parallel, leading to access errors.
 # This forces it to be made only once.  Make normally tracks multiple paths
 # to the same goals and only remakes it once, but that doesn't work over
 # sub-makes like in this target)
@@ -281,7 +298,7 @@ libtcc.a: $(LIBTCC_OBJ)
 
 # dynamic libtcc library
 libtcc.so: $(LIBTCC_OBJ)
-	$S$(CC) -shared -Wl,-soname,$@ -o $@ $^ $(LDFLAGS)
+	$S$(CC) -shared -Wl,-soname,$@ -o $@ $^ $(LIBS) $(LDFLAGS)
 
 libtcc.so: CFLAGS+=-fPIC
 libtcc.so: LDFLAGS+=-fPIC
@@ -315,7 +332,11 @@ libtcc1.a : tcc$(EXESUF) FORCE
 .PRECIOUS: %-libtcc1.a
 FORCE:
 
-run-if = $(if $(shell which $1),$S $1 $2)
+# WHICH = which $1 2>/dev/null
+# some versions of gnu-make do not recognize 'command' as a shell builtin
+WHICH = sh -c 'command -v $1'
+
+run-if = $(if $(shell $(call WHICH,$1)),$S $1 $2)
 S = $(if $(findstring yes,$(SILENT)),@$(info * $@))
 
 # --------------------------------------------------------------------------
@@ -328,10 +349,12 @@ tcc-doc.info: tcc-doc.texi
 
 tcc.1 : tcc-doc.pod
 	$(call run-if,pod2man,--section=1 --center="Tiny C Compiler" \
-		--release="$(VERSION)" $< >$@ && rm -f $<)
+		--release="$(VERSION)" $< >$@)
 %.pod : %.texi
 	$(call run-if,perl,$(TOPSRC)/texi2pod.pl $< $@)
 
+doc : $(TCCDOCS)
+
 # --------------------------------------------------------------------------
 # install
 
@@ -340,19 +363,21 @@ INSTALLBIN = install -m755 $(STRIP_$(CONFIG_strip))
 STRIP_yes = -s
 
 LIBTCC1_W = $(filter %-win32-libtcc1.a %-wince-libtcc1.a,$(LIBTCC1_CROSS))
-LIBTCC1_U = $(filter-out $(LIBTCC1_W),$(LIBTCC1_CROSS))
+LIBTCC1_U = $(filter-out $(LIBTCC1_W),$(wildcard *-libtcc1.a))
 IB = $(if $1,$(IM) mkdir -p $2 && $(INSTALLBIN) $1 $2)
 IBw = $(call IB,$(wildcard $1),$2)
 IF = $(if $1,$(IM) mkdir -p $2 && $(INSTALL) $1 $2)
 IFw = $(call IF,$(wildcard $1),$2)
 IR = $(IM) mkdir -p $2 && cp -r $1/. $2
-IM = $(info -> $2 : $1)@
+IM = @echo "-> $2 : $1" ;
+BINCHECK = $(if $(wildcard $(PROGS) *-tcc$(EXESUF)),,@echo "Makefile: nothing found to install" && exit 1)
 
 B_O = bcheck.o bt-exe.o bt-log.o bt-dll.o
 
 # install progs & libs
 install-unx:
-	$(call IBw,$(PROGS) $(PROGS_CROSS),"$(bindir)")
+	$(call BINCHECK)
+	$(call IBw,$(PROGS) *-tcc,"$(bindir)")
 	$(call IFw,$(LIBTCC1) $(B_O) $(LIBTCC1_U),"$(tccdir)")
 	$(call IF,$(TOPSRC)/include/*.h $(TOPSRC)/tcclib.h,"$(tccdir)/include")
 	$(call $(if $(findstring .so,$(LIBTCC)),IBw,IFw),$(LIBTCC),"$(libdir)")
@@ -368,39 +393,43 @@ endif
 
 # uninstall
 uninstall-unx:
-	@rm -fv $(foreach P,$(PROGS) $(PROGS_CROSS),"$(bindir)/$P")
-	@rm -fv "$(libdir)/libtcc.a" "$(libdir)/libtcc.so" "$(libdir)/libtcc.dylib" "$(includedir)/libtcc.h"
+	@rm -fv $(addprefix "$(bindir)/",$(PROGS) $(PROGS_CROSS))
+	@rm -fv $(addprefix "$(libdir)/", libtcc*.a libtcc*.so libtcc.dylib,$P)
+	@rm -fv $(addprefix "$(includedir)/", libtcc.h)
 	@rm -fv "$(mandir)/man1/tcc.1" "$(infodir)/tcc-doc.info"
 	@rm -fv "$(docdir)/tcc-doc.html"
 	@rm -frv "$(tccdir)"
 
 # install progs & libs on windows
 install-win:
-	$(call IBw,$(PROGS) $(PROGS_CROSS) $(subst libtcc.a,,$(LIBTCC)),"$(bindir)")
+	$(call BINCHECK)
+	$(call IBw,$(PROGS) *-tcc.exe libtcc.dll,"$(bindir)")
 	$(call IF,$(TOPSRC)/win32/lib/*.def,"$(tccdir)/lib")
 	$(call IFw,libtcc1.a $(B_O) $(LIBTCC1_W),"$(tccdir)/lib")
 	$(call IF,$(TOPSRC)/include/*.h $(TOPSRC)/tcclib.h,"$(tccdir)/include")
 	$(call IR,$(TOPSRC)/win32/include,"$(tccdir)/include")
 	$(call IR,$(TOPSRC)/win32/examples,"$(tccdir)/examples")
 	$(call IF,$(TOPSRC)/tests/libtcc_test.c,"$(tccdir)/examples")
-	$(call IFw,$(TOPSRC)/libtcc.h $(subst .dll,.def,$(LIBTCC)),"$(libdir)")
+	$(call IFw,$(TOPSRC)/libtcc.h libtcc.def,"$(libdir)")
 	$(call IFw,$(TOPSRC)/win32/tcc-win32.txt tcc-doc.html,"$(docdir)")
 ifneq "$(wildcard $(LIBTCC1_U))" ""
 	$(call IFw,$(LIBTCC1_U),"$(tccdir)/lib")
 	$(call IF,$(TOPSRC)/include/*.h $(TOPSRC)/tcclib.h,"$(tccdir)/lib/include")
 endif
 
-# the msys-git shell works to configure && make except it does not have install
-ifeq ($(CONFIG_WIN32)-$(shell which install || echo no),yes-no)
-install-win : INSTALL = cp
-install-win : INSTALLBIN = cp
-endif
-
 # uninstall on windows
 uninstall-win:
-	@rm -fv $(foreach P,libtcc.dll $(PROGS) *-tcc.exe,"$(bindir)"/$P)
-	@rm -fr $(foreach P,doc examples include lib libtcc,"$(tccdir)/$P"/*)
-	@rm -frv $(foreach P,doc examples include lib libtcc,"$(tccdir)/$P")
+	@rm -fv $(addprefix "$(bindir)/", libtcc*.dll $(PROGS) *-tcc.exe)
+	@rm -fr $(foreach P,doc examples include lib libtcc,"$(tccdir)/$P/*")
+	@rm -frv $(addprefix "$(tccdir)/", doc examples include lib libtcc)
+
+# the msys-git shell works to configure && make except it does not have install
+ifeq ($(OS),Windows_NT)
+ifeq ($(shell $(call WHICH,install) || echo no),no)
+INSTALL = cp
+INSTALLBIN = cp
+endif
+endif
 
 # --------------------------------------------------------------------------
 # other stuff
@@ -410,10 +439,6 @@ tags : ; ctags $(TAGFILES)
 # cannot have both tags and TAGS on windows
 ETAGS : ; etags $(TAGFILES)
 
-# documentation
-doc: tcc-doc.html tcc-doc.info tcc.1
-
-
 # create release tarball from *current* git branch (including tcc-doc.html
 # and converting two files to CRLF)
 TCC-VERSION = tcc-$(VERSION)
@@ -438,59 +463,64 @@ test:
 # run test(s) from tests2 subdir (see make help)
 tests2.%:
 	@$(MAKE) -C tests/tests2 $@
-
+# run test(s) from testspp subdir (see make help)
 testspp.%:
 	@$(MAKE) -C tests/pp $@
+# run tests with code coverage
+tcov-tes% : tcc_c$(EXESUF)
+	@rm -f $<.tcov
+	@$(MAKE) --no-print-directory TCC_LOCAL=$(CURDIR)/$< tes$*
+tcc_c$(EXESUF): $($T_FILES)
+	$S$(TCC) tcc.c -o $@ -ftest-coverage $(DEFINES) $(LIBS)
 
 clean:
-	@rm -f tcc$(EXESUF) tcc_p$(EXESUF) *-tcc$(EXESUF) tcc.pod tags ETAGS
-	@rm -f *.o *.a *.so* *.out *.log lib*.def *.exe *.dll a.out *.dylib *_.h
+	@rm -f tcc$(EXESUF) tcc_c$(EXESUF) tcc_p$(EXESUF) *-tcc$(EXESUF)
+	@rm -f tags ETAGS *.o *.a *.so* *.out *.log lib*.def *.exe *.dll
+	@rm -f a.out *.dylib *_.h *.pod *.tcov
 	@$(MAKE) -s -C lib $@
 	@$(MAKE) -s -C tests $@
 
 distclean: clean
-	@rm -fv config.h config.mak config.texi tcc.1 tcc-doc.info tcc-doc.html
+	@rm -vf config.h config.mak config.texi
+	@rm -vf $(TCCDOCS)
 
-.PHONY: all clean test tar tags ETAGS distclean install uninstall FORCE
+.PHONY: all clean test tar tags ETAGS doc distclean install uninstall FORCE
 
 help:
 	@echo "make"
 	@echo "   build native compiler (from separate objects)"
-	@echo ""
 	@echo "make cross"
 	@echo "   build cross compilers (from one source)"
-	@echo ""
 	@echo "make ONE_SOURCE=no/yes SILENT=no/yes"
 	@echo "   force building from separate/one object(s), less/more silently"
-	@echo ""
 	@echo "make cross-TARGET"
 	@echo "   build one specific cross compiler for 'TARGET'. Currently supported:"
-	@echo "      $(wordlist 1,6,$(TCC_X))"
-	@echo "      $(wordlist 7,99,$(TCC_X))"
-	@echo ""
+	@echo "   $(wordlist 1,8,$(TCC_X))"
+	@echo "   $(wordlist 9,99,$(TCC_X))"
 	@echo "make test"
 	@echo "   run all tests"
-	@echo ""
 	@echo "make tests2.all / make tests2.37 / make tests2.37+"
 	@echo "   run all/single test(s) from tests2, optionally update .expect"
-	@echo ""
 	@echo "make testspp.all / make testspp.17"
 	@echo "   run all/single test(s) from tests/pp"
-	@echo ""
+	@echo "make tcov-test / tcov-tests2... / tcov-testspp..."
+	@echo "   run tests as above with code coverage. After test(s) see tcc_c$(EXESUF).tcov"
 	@echo "Other supported make targets:"
 	@echo "   install install-strip doc clean tags ETAGS tar distclean help"
-	@echo ""
 	@echo "Custom configuration:"
 	@echo "   The makefile includes a file 'config-extra.mak' if it is present."
 	@echo "   This file may contain some custom configuration.  For example:"
 	@echo "      NATIVE_DEFINES += -D..."
 	@echo "   Or for example to configure the search paths for a cross-compiler"
-	@echo "   that expects the linux files in <tccdir>/i386-linux:"
-	@echo "      ROOT-i386 = {B}/i386-linux"
-	@echo "      CRT-i386  = {B}/i386-linux/usr/lib"
-	@echo "      LIB-i386  = {B}/i386-linux/lib:{B}/i386-linux/usr/lib"
-	@echo "      INC-i386  = {B}/lib/include:{B}/i386-linux/usr/include"
+	@echo "   assuming the support files in /usr/i686-linux-gnu:"
+	@echo "      ROOT-i386 = /usr/i686-linux-gnu"
+	@echo "      CRT-i386  = {R}/lib"
+	@echo "      LIB-i386  = {B}:{R}/lib"
+	@echo "      INC-i386  = {B}/include:{R}/include (*)"
 	@echo "      DEF-i386  += -D__linux__"
+	@echo "   Or also, for the cross platform files in /usr/<triplet>"
+	@echo "      TRIPLET-i386 = i686-linux-gnu"
+	@echo "   (*) tcc replaces {B} by 'tccdir' and {R} by 'CONFIG_SYSROOT'"
 
 # --------------------------------------------------------------------------
 endif # ($(INCLUDED),no)
diff --git a/RELICENSING b/RELICENSING
index 6c69612b0..7890d2b4b 100644
--- a/RELICENSING
+++ b/RELICENSING
@@ -42,6 +42,7 @@
  mingodad                   YES
  Pip Cet                    YES
  Shinichiro Hamaji          YES                 x86_64-gen.c
+ Steffen Nurpmeso           YES
  Vincent Lefèvre            YES
  Thomas Preud'homme         YES                 arm-gen.c
  Timo VJ Lähde (Timppa)     ?                   tiny_libmaker.c
@@ -50,6 +51,7 @@
  Urs Janssen                YES
  waddlesplash               YES
  Christian Jullien          YES                 Windows Cygwin build and tests
+ Reimar Döffinger           YES
 
 
  ------------------------------------------------------------------------------
diff --git a/TODO b/TODO
index d810088d9..a09c19324 100644
--- a/TODO
+++ b/TODO
@@ -1,5 +1,9 @@
 TODO list:
 
+Releases:
+
+- release tcc on a regular basis
+
 Bugs:
 
 - i386 fastcall is mostly wrong
@@ -33,7 +37,10 @@ Portability:
 
 Linking:
 
-- static linking (-static) does not work
+- static linking (-static) does sort of work
+	works with musl libc
+	glibc requires libc.so even when statically linked (very bad, but not
+	up to tcc)
 
 Bound checking:
 
diff --git a/USES b/USES
index 6d7a2d1ac..f74679a4d 100644
--- a/USES
+++ b/USES
@@ -7,6 +7,7 @@ bigz                   An infinite precision Z & Q library.
 gawk                   GNU awk.
 gmp                    Library for arbitrary precision arithmetic.
 gnumake                GNU makefile.
+gnu mes                using tinycc to bootstrap a system
 mpfr                   Multiple-precision floating-point library.
 mpc                    Complex floating-point library with exact rounding.
 mpv                    A free, open source, and cross-platform media player.
@@ -18,3 +19,50 @@ tcc                    Tiny CC which compiles itself.
 zlib                   Lossless data-compression library.
 
 (*) This list is ordered by name.
+
+
+
+Forks & Experiments
+-------------------
+
+arm-thumb target
+ by Erlend Sveen <erlend.sveen@hotmail.com>
+ https://git.erlendjs.no/erlendjs/tinycc.git
+
+riscv32 target
+ by Sam Ellicott <sellicott@cedarville.edu>
+ https://github.com/sellicott/tcc-riscv32.git
+
+Transputer target
+ by David Smith <agentdavo@mac.com>
+ https://github.com/agentdavo/tinycc-transputer
+
+tcc-65816 -  Tiny C Compiler for 65816 CPU (based on V0.9.23) from SNES-SDK
+ https://github.com/nArnoSNES/tcc-65816
+
+PE-UEFI arm64
+ by Andrei Warkentin <andrey.warkentin@gmail.com>
+ https://github.com/andreiw/tinycc/
+
+TCCLS - global register allocator (proof of concept)
+ by Sebastian Falbesoner <sebastian.falbesoner@gmail.com>
+ https://bitbucket.org/theStack/tccls_poc.git
+
+softfloat
+ by Giovanni Mascellani <gio@debian.org>
+ https://gitlab.com/giomasce/tinycc.git
+
+optimize 386
+ by Jason Hood <jadoxa@yahoo.com.au>
+
+tcctcl : tcl binding
+ https://code.google.com/archive/p/tcltcc/
+
+tcc4tcl : tcl binding
+ https://chiselapp.com/user/rkeene/repository/tcc4tcl/index
+
+lua-tcc : allows a Lua script to compile C code
+ https://github.com/javierguerragiraldez/lua-tcc
+
+tcclua : semi-high-level bindings for `libtcc`
+ https://github.com/nucular/tcclua/blob/master/tcc.lua
diff --git a/VERSION b/VERSION
index 9a542234e..7cdd3b469 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.9.27
+0.9.28rc
\ No newline at end of file
diff --git a/arm-asm.c b/arm-asm.c
index a4f974f65..a6dec4c3d 100644
--- a/arm-asm.c
+++ b/arm-asm.c
@@ -77,21 +77,6 @@ static int asm_parse_vfp_regvar(int t, int double_precision)
     return -1;
 }
 
-__attribute__((unused))
-static int asm_parse_vfp_status_regvar(int t)
-{
-    switch (t) {
-    case TOK_ASM_fpsid:
-        return 0;
-    case TOK_ASM_fpscr:
-        return 1;
-    case TOK_ASM_fpexc:
-        return 8;
-    default:
-        return -1;
-    }
-}
-
 /* Parse a text containing operand and store the result in OP */
 static void parse_operand(TCCState *s1, Operand *op)
 {
@@ -2240,6 +2225,20 @@ static void asm_floating_point_data_processing_opcode(TCCState *s1, int token) {
     asm_emit_coprocessor_opcode(condition_code_of_token(token), coprocessor, opcode1, ops[0].reg, (ops[1].type == OP_IM8) ? ops[1].e.v : ops[1].reg, (ops[2].type == OP_IM8) ? ops[2].e.v : ops[2].reg, opcode2, 0);
 }
 
+static int asm_parse_vfp_status_regvar(int t)
+{
+    switch (t) {
+    case TOK_ASM_fpsid:
+        return 0;
+    case TOK_ASM_fpscr:
+        return 1;
+    case TOK_ASM_fpexc:
+        return 8;
+    default:
+        return -1;
+    }
+}
+
 static void asm_floating_point_status_register_opcode(TCCState* s1, int token)
 {
     uint8_t coprocessor = CP_SINGLE_PRECISION_FLOAT;
diff --git a/arm-gen.c b/arm-gen.c
index 0d466d4ff..5eea781b9 100644
--- a/arm-gen.c
+++ b/arm-gen.c
@@ -543,7 +543,7 @@ static void load_value(SValue *sv, int r)
 {
     o(0xE59F0000|(intr(r)<<12)); /* ldr r, [pc] */
     o(0xEA000000); /* b $+4 */
-#ifndef CONFIG_TCC_PIE
+#ifndef CONFIG_TCC_PIC
     if(sv->r & VT_SYM)
         greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
     o(sv->c.i);
@@ -866,7 +866,7 @@ static void gen_bounds_epilog(void)
     *bounds_ptr = 0;
 
     sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
-                           func_bound_offset, lbounds_section->data_offset);
+                           func_bound_offset, PTR_SIZE);
 
     /* generate bound local allocation */
     if (offset_modified) {
diff --git a/arm-link.c b/arm-link.c
index 5d40f8430..242bb9456 100644
--- a/arm-link.c
+++ b/arm-link.c
@@ -27,6 +27,7 @@ enum float_abi {
 
 #include "tcc.h"
 
+#ifdef NEED_RELOC_TYPE
 /* Returns 1 for a code relocation, 0 for a data relocation. For unknown
    relocations, returns -1. */
 int code_reloc (int reloc_type)
@@ -106,7 +107,7 @@ int gotplt_entry_type (int reloc_type)
     return -1;
 }
 
-#ifndef TCC_TARGET_PE
+#ifdef NEED_BUILD_GOT
 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
 {
     Section *plt = s1->plt;
@@ -176,6 +177,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
     }
 }
 #endif
+#endif
 
 void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t addr, addr_t val)
 {
@@ -212,7 +214,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                 h = x & 2;
                 th_ko = (x & 3) && (!blx_avail || !is_call);
                 if (th_ko || x >= 0x2000000 || x < -0x2000000)
-                    tcc_error("can't relocate value at %x,%d",addr, type);
+                    tcc_error_noabort("can't relocate value at %x,%d",addr, type);
                 x >>= 2;
                 x &= 0xffffff;
                 /* Only reached if blx is avail and it is a call */
@@ -301,7 +303,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                      - instruction must be a call (bl) or a jump to PLT */
                 if (!to_thumb || x >= 0x1000000 || x < -0x1000000)
                     if (to_thumb || (val & 2) || (!is_call && !to_plt))
-                        tcc_error("can't relocate value at %x,%d",addr, type);
+                        tcc_error_noabort("can't relocate value at %x,%d",addr, type);
 
                 /* Compute and store final offset */
                 s = (x >> 24) & 1;
@@ -372,13 +374,13 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                 x = (x * 2) / 2;
                 x += val - addr;
                 if((x^(x>>1))&0x40000000)
-                    tcc_error("can't relocate value at %x,%d",addr, type);
+                    tcc_error_noabort("can't relocate value at %x,%d",addr, type);
                 (*(int *)ptr) |= x & 0x7fffffff;
             }
             return;
         case R_ARM_ABS32:
         case R_ARM_TARGET1:
-            if (s1->output_type == TCC_OUTPUT_DLL) {
+            if (s1->output_type & TCC_OUTPUT_DYN) {
                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
                 qrel->r_offset = rel->r_offset;
                 if (esym_index) {
diff --git a/arm64-gen.c b/arm64-gen.c
index 25b50fabd..e314de583 100644
--- a/arm64-gen.c
+++ b/arm64-gen.c
@@ -38,7 +38,9 @@
 
 #define MAX_ALIGN 16
 
+#ifndef TCC_TARGET_MACHO
 #define CHAR_IS_UNSIGNED
+#endif
 
 /* define if return values need to be extended explicitely
    at caller side (for interfacing with non-TCC compilers) */
@@ -51,12 +53,11 @@
 #include <assert.h>
 
 ST_DATA const char * const target_machine_defs =
-#if defined(__APPLE__)
     "__aarch64__\0"
+#if defined(TCC_TARGET_MACHO)
     "__arm64__\0"
-#else
-    "__aarch64__\0"
 #endif
+    "__AARCH64EL__\0"
     ;
 
 ST_DATA const int reg_classes[NB_REGS] = {
@@ -487,7 +488,7 @@ static void arm64_load_cmp(int r, SValue *sv);
 ST_FUNC void load(int r, SValue *sv)
 {
     int svtt = sv->type.t;
-    int svr = sv->r & ~VT_BOUNDED;
+    int svr = sv->r & ~(VT_BOUNDED | VT_NONCONST);
     int svrv = svr & VT_VALMASK;
     uint64_t svcul = (uint32_t)sv->c.i;
     svcul = svcul >> 31 & 1 ? svcul - ((uint64_t)1 << 32) : svcul;
@@ -710,7 +711,7 @@ static void gen_bounds_epilog(void)
     *bounds_ptr = 0;
 
     sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
-                           func_bound_offset, lbounds_section->data_offset);
+                           func_bound_offset, PTR_SIZE);
 
     /* generate bound local allocation */
     if (offset_modified) {
@@ -810,7 +811,7 @@ static int arm64_hfa(CType *type, unsigned *fsize)
     return 0;
 }
 
-static unsigned long arm64_pcs_aux(int n, CType **type, unsigned long *a)
+static unsigned long arm64_pcs_aux(int variadic, int n, CType **type, unsigned long *a)
 {
     int nx = 0; // next integer register
     int nv = 0; // next vector register
@@ -827,6 +828,12 @@ static unsigned long arm64_pcs_aux(int n, CType **type, unsigned long *a)
         else
             size = type_size(type[i], &align);
 
+#if defined(TCC_TARGET_MACHO)
+        if (variadic && i == variadic) {
+            nx = 8;
+            nv = 8;
+	}
+#endif
         if (hfa)
             // B.2
             ;
@@ -931,7 +938,7 @@ static unsigned long arm64_pcs_aux(int n, CType **type, unsigned long *a)
     return ns - 32;
 }
 
-static unsigned long arm64_pcs(int n, CType **type, unsigned long *a)
+static unsigned long arm64_pcs(int variadic, int n, CType **type, unsigned long *a)
 {
     unsigned long stack;
 
@@ -939,12 +946,12 @@ static unsigned long arm64_pcs(int n, CType **type, unsigned long *a)
     if ((type[0]->t & VT_BTYPE) == VT_VOID)
         a[0] = -1;
     else {
-        arm64_pcs_aux(1, type, a);
+        arm64_pcs_aux(0, 1, type, a);
         assert(a[0] == 0 || a[0] == 1 || a[0] == 16);
     }
 
     // Argument types:
-    stack = arm64_pcs_aux(n, type + 1, a + 1);
+    stack = arm64_pcs_aux(variadic, n, type + 1, a + 1);
 
     if (0) {
         int i;
@@ -970,6 +977,16 @@ static unsigned long arm64_pcs(int n, CType **type, unsigned long *a)
     return stack;
 }
 
+static int n_func_args(CType *type)
+{
+    int n_args = 0;
+    Sym *arg;
+
+    for (arg = type->ref->next; arg; arg = arg->next)
+        n_args++;
+    return n_args;
+}
+
 ST_FUNC void gfunc_call(int nb_args)
 {
     CType *return_type;
@@ -977,6 +994,8 @@ ST_FUNC void gfunc_call(int nb_args)
     unsigned long *a, *a1;
     unsigned long stack;
     int i;
+    int variadic = (vtop[-nb_args].type.ref->f.func_type == FUNC_ELLIPSIS);
+    int var_nb_arg = n_func_args(&vtop[-nb_args].type);
 
 #ifdef CONFIG_TCC_BCHECK
     if (tcc_state->do_bounds_check)
@@ -995,7 +1014,7 @@ ST_FUNC void gfunc_call(int nb_args)
     for (i = 0; i < nb_args; i++)
         t[nb_args - i] = &vtop[-i].type;
 
-    stack = arm64_pcs(nb_args, t, a);
+    stack = arm64_pcs(variadic ? var_nb_arg : 0, nb_args, t, a);
 
     // Allocate space for structs replaced by pointer:
     for (i = nb_args; i; i--)
@@ -1055,7 +1074,7 @@ ST_FUNC void gfunc_call(int nb_args)
             }
             else {
                 gv(RC_INT);
-                arm64_strx(arm64_type_size(vtop[0].type.t),
+                arm64_strx(3, // arm64_type_size(vtop[0].type.t),
                            intr(vtop[0].r), 31, a[i] - 32);
             }
         }
@@ -1167,6 +1186,8 @@ ST_FUNC void gfunc_prolog(Sym *func_sym)
     int use_x8 = 0;
     int last_int = 0;
     int last_float = 0;
+    int variadic = func_sym->type.ref->f.func_type == FUNC_ELLIPSIS;
+    int var_nb_arg = n_func_args(&func_sym->type);
 
     func_vc = 144; // offset of where x8 is stored
 
@@ -1178,18 +1199,18 @@ ST_FUNC void gfunc_prolog(Sym *func_sym)
     for (sym = func_type->ref; sym; sym = sym->next)
         t[i++] = &sym->type;
 
-    arm64_func_va_list_stack = arm64_pcs(n - 1, t, a);
+    arm64_func_va_list_stack = arm64_pcs(variadic ? var_nb_arg : 0, n - 1, t, a);
 
-    if (func_sym->type.ref->f.func_type == FUNC_ELLIPSIS) {
+#if !defined(TCC_TARGET_MACHO)
+    if (variadic) {
         use_x8 = 1;
         last_int = 4;
         last_float = 4;
     }
+#endif
     if (a && a[0] == 1)
         use_x8 = 1;
     for (i = 1, sym = func_type->ref->next; sym; i++, sym = sym->next) {
-        if (a[i] == 1)
-	    use_x8 = 1;
         if (a[i] < 16) {
             int last, align, size = type_size(&sym->type, &align);
 	    last = a[i] / 4 + 1 + (size - 1) / 8;
@@ -1282,6 +1303,7 @@ ST_FUNC void gen_va_start(void)
         o(0x910383be); // add x30,x29,#224
     o(0xf900001e | r << 5); // str x30,[x(r)]
 
+#if !defined(TCC_TARGET_MACHO)
     if (arm64_func_va_list_gr_offs) {
         if (arm64_func_va_list_stack)
             o(0x910383be); // add x30,x29,#224
@@ -1298,6 +1320,7 @@ ST_FUNC void gen_va_start(void)
 
     arm64_movimm(30, arm64_func_va_list_vr_offs);
     o(0xb9001c1e | r << 5); // str w30,[x(r),#28]
+#endif
 
     --vtop;
 }
@@ -1321,6 +1344,7 @@ ST_FUNC void gen_va_arg(CType *t)
 
     if (!hfa) {
         uint32_t n = size > 16 ? 8 : (size + 7) & -8;
+#if !defined(TCC_TARGET_MACHO)
         o(0xb940181e | r0 << 5); // ldr w30,[x(r0),#24] // __gr_offs
         if (align == 16) {
             assert(0); // this path untested but needed for __uint128_t
@@ -1329,23 +1353,28 @@ ST_FUNC void gen_va_arg(CType *t)
         }
         o(0x310003c0 | r1 | n << 10); // adds w(r1),w30,#(n)
         o(0x540000ad); // b.le .+20
+#endif
         o(0xf9400000 | r1 | r0 << 5); // ldr x(r1),[x(r0)] // __stack
         o(0x9100001e | r1 << 5 | n << 10); // add x30,x(r1),#(n)
         o(0xf900001e | r0 << 5); // str x30,[x(r0)] // __stack
+#if !defined(TCC_TARGET_MACHO)
         o(0x14000004); // b .+16
         o(0xb9001800 | r1 | r0 << 5); // str w(r1),[x(r0),#24] // __gr_offs
         o(0xf9400400 | r1 | r0 << 5); // ldr x(r1),[x(r0),#8] // __gr_top
         o(0x8b3ec000 | r1 | r1 << 5); // add x(r1),x(r1),w30,sxtw
+#endif
         if (size > 16)
             o(0xf9400000 | r1 | r1 << 5); // ldr x(r1),[x(r1)]
     }
     else {
-        uint32_t rsz = hfa << 4;
         uint32_t ssz = (size + 7) & -(uint32_t)8;
+#if !defined(TCC_TARGET_MACHO)
+        uint32_t rsz = hfa << 4;
         uint32_t b1, b2;
         o(0xb9401c1e | r0 << 5); // ldr w30,[x(r0),#28] // __vr_offs
         o(0x310003c0 | r1 | rsz << 10); // adds w(r1),w30,#(rsz)
         b1 = ind; o(0x5400000d); // b.le lab1
+#endif
         o(0xf9400000 | r1 | r0 << 5); // ldr x(r1),[x(r0)] // __stack
         if (fsize == 16) {
             o(0x91003c00 | r1 | r1 << 5); // add x(r1),x(r1),#15
@@ -1353,6 +1382,7 @@ ST_FUNC void gen_va_arg(CType *t)
         }
         o(0x9100001e | r1 << 5 | ssz << 10); // add x30,x(r1),#(ssz)
         o(0xf900001e | r0 << 5); // str x30,[x(r0)] // __stack
+#if !defined(TCC_TARGET_MACHO)
         b2 = ind; o(0x14000000); // b lab2
         // lab1:
         write32le(cur_text_section->data + b1, 0x5400000d | (ind - b1) << 3);
@@ -1376,6 +1406,7 @@ ST_FUNC void gen_va_arg(CType *t)
         }
         // lab2:
         write32le(cur_text_section->data + b2, 0x14000000 | (ind - b2) >> 2);
+#endif
     }
 }
 
@@ -1390,7 +1421,7 @@ ST_FUNC void gfunc_return(CType *func_type)
     CType *t = func_type;
     unsigned long a;
 
-    arm64_pcs(0, &t, &a);
+    arm64_pcs(0, 0, &t, &a);
     switch (a) {
     case -1:
         break;
diff --git a/arm64-link.c b/arm64-link.c
index 99916693b..568ac1fef 100644
--- a/arm64-link.c
+++ b/arm64-link.c
@@ -21,6 +21,7 @@
 
 #include "tcc.h"
 
+#ifdef NEED_RELOC_TYPE
 /* Returns 1 for a code relocation, 0 for a data relocation. For unknown
    relocations, returns -1. */
 int code_reloc (int reloc_type)
@@ -90,7 +91,7 @@ int gotplt_entry_type (int reloc_type)
     return -1;
 }
 
-__attribute__((unused))
+#ifdef NEED_BUILD_GOT
 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
 {
     Section *plt = s1->plt;
@@ -110,7 +111,6 @@ ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_
 
 /* relocate the PLT: compute addresses and offsets in the PLT now that final
    address for PLT and GOT are known (see fill_program_header) */
-__attribute__((unused))
 ST_FUNC void relocate_plt(TCCState *s1)
 {
     uint8_t *p, *p_end;
@@ -126,7 +126,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
         uint64_t got = s1->got->sh_addr + 16;
         uint64_t off = (got >> 12) - (plt >> 12);
         if ((off + ((uint32_t)1 << 20)) >> 21)
-            tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);
+            tcc_error_noabort("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);
         write32le(p, 0xa9bf7bf0); // stp x16,x30,[sp,#-16]!
         write32le(p + 4, (0x90000010 | // adrp x16,...
 			  (off & 0x1ffffc) << 3 | (off & 3) << 29));
@@ -145,7 +145,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
             uint64_t addr = got + read64le(p);
             uint64_t off = (addr >> 12) - (pc >> 12);
             if ((off + ((uint32_t)1 << 20)) >> 21)
-                tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);
+                tcc_error_noabort("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);
             write32le(p, (0x90000010 | // adrp x16,...
 			  (off & 0x1ffffc) << 3 | (off & 3) << 29));
             write32le(p + 4, (0xf9400211 | // ldr x17,[x16,#...]
@@ -165,6 +165,8 @@ ST_FUNC void relocate_plt(TCCState *s1)
 	}
     }
 }
+#endif
+#endif
 
 void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t addr, addr_t val)
 {
@@ -175,7 +177,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
 
     switch(type) {
         case R_AARCH64_ABS64:
-            if (s1->output_type == TCC_OUTPUT_DLL) {
+            if ((s1->output_type & TCC_OUTPUT_DYN)) {
                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
                 qrel->r_offset = rel->r_offset;
                 if (esym_index) {
@@ -192,7 +194,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
             add64le(ptr, val);
             return;
         case R_AARCH64_ABS32:
-            if (s1->output_type == TCC_OUTPUT_DLL) {
+            if (s1->output_type & TCC_OUTPUT_DYN) {
                 /* XXX: this logic may depend on TCC's codegen
                    now TCC uses R_AARCH64_RELATIVE even for a 64bit pointer */
                 qrel->r_offset = rel->r_offset;
@@ -237,7 +239,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
         case R_AARCH64_ADR_PREL_PG_HI21: {
             uint64_t off = (val >> 12) - (addr >> 12);
             if ((off + ((uint64_t)1 << 20)) >> 21)
-                tcc_error("R_AARCH64_ADR_PREL_PG_HI21 relocation failed");
+                tcc_error_noabort("R_AARCH64_ADR_PREL_PG_HI21 relocation failed");
             write32le(ptr, ((read32le(ptr) & 0x9f00001f) |
                             (off & 0x1ffffc) << 3 | (off & 3) << 29));
             return;
@@ -270,7 +272,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
 		    (char *) symtab_section->link->data + sym->st_name);
 #endif
             if (((val - addr) + ((uint64_t)1 << 27)) & ~(uint64_t)0xffffffc)
-                tcc_error("R_AARCH64_(JUMP|CALL)26 relocation failed"
+                tcc_error_noabort("R_AARCH64_(JUMP|CALL)26 relocation failed"
                           " (val=%lx, addr=%lx)", (long)val, (long)addr);
             write32le(ptr, (0x14000000 |
                             (uint32_t)(type == R_AARCH64_CALL26) << 31 |
@@ -281,7 +283,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                 (((s1->got->sh_addr +
                    get_sym_attr(s1, sym_index, 0)->got_offset) >> 12) - (addr >> 12));
             if ((off + ((uint64_t)1 << 20)) >> 21)
-                tcc_error("R_AARCH64_ADR_GOT_PAGE relocation failed");
+                tcc_error_noabort("R_AARCH64_ADR_GOT_PAGE relocation failed");
             write32le(ptr, ((read32le(ptr) & 0x9f00001f) |
                             (off & 0x1ffffc) << 3 | (off & 3) << 29));
             return;
diff --git a/c67-link.c b/c67-link.c
index 514689c55..8e7a8b2f4 100644
--- a/c67-link.c
+++ b/c67-link.c
@@ -67,7 +67,7 @@ int gotplt_entry_type (int reloc_type)
 
 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
 {
-    tcc_error("C67 got not implemented");
+    tcc_error_noabort("C67 got not implemented");
     return 0;
 }
 
diff --git a/configure b/configure
index 4063ac721..799973b10 100755
--- a/configure
+++ b/configure
@@ -27,8 +27,7 @@ mandir=""
 infodir=""
 sysroot=""
 cross_prefix=""
-test -z "$CC" && CC="gcc"
-test -z "$cc" && cc="$CC"
+cc="gcc"
 ar="ar"
 bigendian="no"
 mingw32="no"
@@ -46,44 +45,21 @@ confvars=
 suggest="yes"
 gcc_major=0
 gcc_minor=0
-cc_name="$cc"
+cc_name="gcc"
 ar_set=
-darwin=
 cpu=
 cpuver=
+dwarf=
+targetos=
+build_cross=
 
-# OS specific
-cpu_sys=`uname -m`
-targetos=`uname`
-
-case $targetos in
-  Darwin)
-    darwin=yes
-    confvars="$confvars OSX dll=no"
-    cc=`which cc`
-    cc=`readlink $cc || echo clang`
-    tcc_usrinclude="`xcrun --show-sdk-path`/usr/include"
-    DLLSUF=".dylib"
-    ;;
-  Windows_NT|MINGW*|MSYS*|CYGWIN*)
-    mingw32=yes
-    targetos=WIN32
-    ;;
-  DragonFly|OpenBSD|FreeBSD|NetBSD)
-    confvars="$confvars BSD ldl=no"
-    ;;
-  *)
-    ;;
-esac
+# use CC/AR from environment when set
+test -n "$CC" && cc="$CC"
+test -n "$AR" && ar="$AR"
 
 # find source path
 source_path=${0%configure}
 source_path=${source_path%/}
-source_path_used="yes"
-if test -z "$source_path" -o "$source_path" = "." ; then
-    source_path=`pwd`
-    source_path_used="no"
-fi
 
 for opt do
   eval opt=\"$opt\"
@@ -110,6 +86,8 @@ for opt do
   ;;
   --sysroot=*) sysroot=`echo $opt | cut -d '=' -f 2-`
   ;;
+  --targetos=*) targetos=`echo $opt | cut -d '=' -f 2-`
+  ;;
   --source-path=*) source_path=`echo $opt | cut -d '=' -f 2-`
   ;;
   --cross-prefix=*) cross_prefix=`echo $opt | cut -d '=' -f 2-`
@@ -136,6 +114,8 @@ for opt do
   ;;
   --cpu=*) cpu=`echo $opt | cut -d '=' -f 2-`
   ;;
+  --dwarf=*) dwarf=`echo $opt | cut -d '=' -f 2-`
+  ;;
   --enable-cross) confvars="$confvars cross"
   ;;
   --disable-static) confvars="$confvars static=no"
@@ -150,6 +130,8 @@ for opt do
   ;;
   --with-selinux) confvars="$confvars selinux"
   ;;
+  --tcc-switches=*) tcc_switches=`echo $opt | cut -d '=' -f 2-`
+  ;;
   --config-mingw32*) mingw32=$(echo "$opt=yes" | cut -d '=' -f 2)
   ;;
   --config-*) confvars="$confvars ${opt#--config-}"; suggest="no"
@@ -161,20 +143,120 @@ for opt do
   esac
 done
 
-cc="${cross_prefix}${cc}"
-ar="${cross_prefix}${ar}"
+show_help() {
+cat << EOF
+Usage: configure [options]
+Options: [defaults in brackets after descriptions]
+
+Standard options:
+  --help                   print this message
+  --prefix=PREFIX          install in PREFIX [$prefix]
+  --exec-prefix=EPREFIX    install architecture-dependent files in EPREFIX
+			   [same as prefix]
+  --bindir=DIR             user executables in DIR [EPREFIX/bin]
+  --libdir=DIR             object code libraries in DIR [EPREFIX/lib]
+  --tccdir=DIR             installation directory [EPREFIX/lib/tcc]
+  --includedir=DIR         C header files in DIR [PREFIX/include]
+  --sharedir=DIR           documentation root DIR [PREFIX/share]
+  --docdir=DIR             documentation in DIR [SHAREDIR/doc/tcc]
+  --mandir=DIR             man documentation in DIR [SHAREDIR/man]
+  --infodir=DIR            info documentation in DIR [SHAREDIR/info]
+
+Advanced options (experts only):
+  --source-path=PATH       path of source code [$source_path]
+  --sysroot=PREFIX         prepend PREFIX to library/include paths [$sysroot]
+  --cc=CC                  use C compiler CC [$cc]
+  --ar=AR                  create archives using AR [$ar]
+  --extra-cflags=          specify compiler flags [$CFLAGS]
+  --extra-ldflags=         specify linker options [$LDFLAGS]
+
+  --debug                  include debug info with resulting binaries
+  --disable-static         make libtcc.so instead of libtcc.a
+  --enable-static          make libtcc.a instead of libtcc.dll (win32)
+  --disable-rpath          disable use of -rpath with libtcc.so
+  --with-libgcc            use libgcc_s.so.1 instead of libtcc1.a
+  --with-selinux           use mmap for executable memory (tcc -run)
+  --enable-cross           build cross compilers (see also 'make help')
+
+  --sysincludepaths=...    specify system include paths, colon separated
+  --libpaths=...           specify system library paths, colon separated
+  --crtprefix=...          specify locations of crt?.o, colon separated
+  --elfinterp=...          specify elf interpreter
+  --triplet=...            specify system library/include directory triplet
+  --tcc-switches=...       specify implicit switches passed to tcc
+
+  --config-uClibc,-musl    enable system specific configurations
+  --config-mingw32         build on windows using msys, busybox, etc.
+  --config-backtrace=no    disable stack backtraces (with -run or -bt)
+  --config-bcheck=no       disable bounds checker (-b)
+  --config-predefs=no      do not compile tccdefs.h, instead just include
+  --config-new_macho=no|yes Force apple object format (autodetect osx <= 10)
+  --config-codesign=no     do not use codesign on apple to sign executables
+  --dwarf=x                Use dwarf debug info instead of stabs (x=2..5)
+
+Cross build options (experimental):
+  --cpu=CPU                target CPU [$cpu]
+  --targetos=...           target OS (Darwin,WIN32,Android/Termux) [$targetos]
+  --cross-prefix=PREFIX    use PREFIX for compile tools [$cross_prefix]
+EOF
+exit 1
+}
+
+default() # set variable unless already set
+{
+    local v
+    eval v=\"\$$1\"
+    test -z "$v" && eval $1=\"$2\"
+}
 
-# Checking for CFLAGS
-test -z "$CFLAGS" && CFLAGS="-Wall -O2"
+default_conf() # add to confvars unless already present
+{
+    local v=${1%=*}
+    test "${confvars%$v*}" = "${confvars}" && confvars="$confvars $1"
+}
 
-# on OSX M1 with --cpu=x86_64, build a tcc to run under rosetta entirely
-if test "$darwin" = "yes" -a "$cpu" = "x86_64" -a "$cpu_sys" = "arm64"; then
-    CFLAGS="$CFLAGS -arch $cpu"
-    LDFLAGS="$LDFLAGS -arch $cpu"
+if test -z "$source_path" -o "$source_path" = "." ; then
+  source_path=$(pwd)
+  source_path_used="no"
+else
+  source_path_used="yes"
 fi
 
-# checking for cpu
-test -z "$cpu" && cpu="$cpu_sys"
+# OS specific
+buildos=$(uname)
+
+case $buildos in
+  Windows_NT|MINGW*|MSYS*|CYGWIN*)
+    buildos="WIN32"
+  ;;
+  Linux)
+    if test "$(uname -o)" = "Android"; then
+      buildos=Android
+      if test -n "$TERMUX_VERSION"; then
+        buildos=Termux
+      fi
+    fi
+  ;;
+esac
+
+if test "$mingw32" = "yes"; then
+  default targetos WIN32
+else
+  default targetos "$buildos"
+fi
+
+cpu_sys=$(uname -m)
+default cpu "$cpu_sys"
+cpu_set="$cpu"
+
+# check for crpss build
+if test "$cpu_set" != "$cpu_sys" \
+  -o "$targetos" != "$buildos" \
+  -o -n "$cross_prefix" ; then
+  build_cross="yes"
+  cc="${cross_prefix}${cc}"
+  ar="${cross_prefix}${ar}"
+fi
 
 case "$cpu" in
   x86|i386|i486|i586|i686|i86pc|BePC|i686-AT386)
@@ -234,107 +316,104 @@ case "$cpu" in
   ;;
 esac
 
-if test "$mingw32" = "yes" ; then
-    if test "$source_path_used" = "no"; then
-      source_path="."
+case $targetos in
+  Darwin)
+    dwarf=4
+    confvars="$confvars OSX"
+    default_conf "codesign"
+    DLLSUF=".dylib"
+    if test -z "$build_cross"; then
+      cc=`command -v cc`
+      cc=`readlink $cc || echo clang`
+      tcc_usrinclude="`xcrun --show-sdk-path`/usr/include"
+      if test "${confvars%new_macho*}" = "${confvars}"; then
+          # if new_macho was not specified and (known) ver <= 10, use old (=no)
+          osxver=$(sw_vers -productVersion 2>/dev/null)  # X.Y.Z
+          osxver=${osxver%%.*}  # major version (or empty on sw_vers error)
+          [ "${osxver:-11}" -ge 11 ] || confvars="$confvars new_macho=no"
+      fi
+    fi
+    # on OSX M1 with --cpu=x86_64, build a tcc to run under rosetta entirely
+    if test "$cpu" = "x86_64" -a "$cpu_sys" = "arm64"; then
+        CFLAGS="$CFLAGS -arch $cpu"
+        LDFLAGS="$LDFLAGS -arch $cpu"
+    fi
+    ;;
+  DragonFly|OpenBSD|FreeBSD|NetBSD)
+    confvars="$confvars BSD ldl=no"
+    ;;
+  Android|Termux)
+    if test "$targetos" = "Termux"; then
+      targetos=Android
+      default sysroot "/data/data/com.termux/files/usr"
+    else
+      default sysroot "/usr"
     fi
-    test -z "$prefix" && prefix="C:/Program Files/tcc"
-    test -z "$tccdir" && tccdir="${prefix}" && tccdir_auto="yes"
-    test -z "$bindir" && bindir="${tccdir}"
-    test -z "$docdir" && docdir="${tccdir}/doc"
-    test -z "$libdir" && libdir="${tccdir}/libtcc"
+    default prefix "${sysroot}"
+    confvars="$confvars Android new-dtags rpath=no"
+    test "${cpu}" != "i386" && confvars="$confvars pie"
+    default_conf "static=no"
+    if test "${cpu}" = "arm"; then
+      default triplet "arm-linux-androideabi"
+      cpuver=7
+    else
+      default triplet "${cpu_set}-linux-android"
+    fi
+    test "${cpu%64}" != "${cpu}" && S="64" || S=""
+    default tcc_sysincludepaths "{B}/include:{R}/include:{R}/include/${triplet}"
+    default tcc_libpaths "{B}:{R}/lib:/system/lib${S}"
+    default tcc_crtprefix "{R}/lib"
+    default tcc_elfinterp "/system/bin/linker${S}"
+    default tcc_switches "-Wl,-rpath=$sysroot/lib,-section-alignment=0x1000"
+    ;;
+  WIN32)
+    mingw32="yes"
     confvars="$confvars WIN32"
+    default prefix "C:/Program Files/tcc"
+    default tccdir "${prefix}"
+    default bindir "${tccdir}"
+    default docdir "${tccdir}/doc"
+    default libdir "${tccdir}/libtcc"
+    test "$tccdir" = "$bindir" && tccdir_auto="yes"
     LIBSUF=".lib"
     EXESUF=".exe"
     DLLSUF=".dll"
-else
-    if test -z "$prefix" ; then
-      prefix="/usr/local"
-    fi
-    if test -z "$sharedir" ; then
-      sharedir="${prefix}/share"
-    fi
-    if test x"$execprefix" = x""; then
-      execprefix="${prefix}"
-    fi
-    if test x"$libdir" = x""; then
-      libdir="${execprefix}/lib"
-    fi
-    if test x"$bindir" = x""; then
-      bindir="${execprefix}/bin"
-    fi
-    if test x"$docdir" = x""; then
-      docdir="${sharedir}/doc"
-    fi
-    if test x"$mandir" = x""; then
-      mandir="${sharedir}/man"
-    fi
-    if test x"$infodir" = x""; then
-      infodir="${sharedir}/info"
-    fi
-    if test x"$tccdir" = x""; then
-      tccdir="${libdir}/tcc"
-    fi
-    if test x"$includedir" = x""; then
-      includedir="${prefix}/include"
+    if test "$source_path_used" = "no"; then
+      source_path="."
     fi
-fi # mingw32
-
-if test x"$show_help" = "xyes" ; then
-cat << EOF
-Usage: configure [options]
-Options: [defaults in brackets after descriptions]
-
-Standard options:
-  --help                   print this message
-  --prefix=PREFIX          install in PREFIX [$prefix]
-  --exec-prefix=EPREFIX    install architecture-dependent files in EPREFIX
-			   [same as prefix]
-  --bindir=DIR             user executables in DIR [EPREFIX/bin]
-  --libdir=DIR             object code libraries in DIR [EPREFIX/lib]
-  --tccdir=DIR             installation directory [EPREFIX/lib/tcc]
-  --includedir=DIR         C header files in DIR [PREFIX/include]
-  --sharedir=DIR           documentation root DIR [PREFIX/share]
-  --docdir=DIR             documentation in DIR [SHAREDIR/doc/tcc]
-  --mandir=DIR             man documentation in DIR [SHAREDIR/man]
-  --infodir=DIR            info documentation in DIR [SHAREDIR/info]
+    ;;
+  *)
+    ;;
+esac
 
-Advanced options (experts only):
-  --source-path=PATH       path of source code [$source_path]
-  --cross-prefix=PREFIX    use PREFIX for compile tools [$cross_prefix]
-  --sysroot=PREFIX         prepend PREFIX to library/include paths [$sysroot]
-  --cc=CC                  use C compiler CC [$cc]
-  --ar=AR                  create archives using AR [$ar]
-  --extra-cflags=          specify compiler flags [$CFLAGS]
-  --extra-ldflags=         specify linker options [$LDFLAGS]
-  --cpu=CPU                CPU [$cpu]
+if test "$mingw32" = "no"; then
+  default prefix       "/usr/local"
+  default execprefix   "${prefix}"
+  default libdir       "${execprefix}/lib"
+  default bindir       "${execprefix}/bin"
+  default tccdir       "${libdir}/tcc"
+  default includedir   "${prefix}/include"
+  default sharedir     "${prefix}/share"
+  default docdir       "${sharedir}/doc"
+  default mandir       "${sharedir}/man"
+  default infodir      "${sharedir}/info"
+fi
 
-  --debug                  include debug info with resulting binaries
-  --disable-static         make libtcc.so instead of libtcc.a
-  --enable-static          make libtcc.a instead of libtcc.dll (win32)
-  --disable-rpath          disable use of -rpath with libtcc.so
-  --with-libgcc            use libgcc_s.so.1 instead of libtcc1.a
-  --with-selinux           use mmap for executable memory (tcc -run)
-  --enable-cross           build cross compilers (see also 'make help')
+# set default CFLAGS
+default CFLAGS "-Wall -O2"
 
-  --sysincludepaths=...    specify system include paths, colon separated
-  --libpaths=...           specify system library paths, colon separated
-  --crtprefix=...          specify locations of crt?.o, colon separated
-  --elfinterp=...          specify elf interpreter
-  --triplet=...            specify system library/include directory triplet
+if test "$mingw32" = "yes" -a "$cc_name" = "gcc"; then
+  # avoid mingw dependencies such as 'libgcc_s_dw2-1.dll'
+  default LDFLAGS "-static"
+fi
 
-  --config-uClibc,-musl    enable system specific configurations
-  --config-mingw32         build on windows using msys, busybox, etc.
-  --config-backtrace=no    disable stack backtraces (with -run or -bt)
-  --config-bcheck=no       disable bounds checker (-b)
-  --config-predefs=no      do not compile tccdefs.h, instead just include
-EOF
-exit 1
+if test x"$show_help" = "xyes" ; then
+    show_help
 fi
 
-if test -z "$cross_prefix" ; then
+if test -z "$build_cross"; then
   CONFTEST=./conftest$EXESUF
-  if ! $cc -o $CONFTEST $source_path/conftest.c 2>/dev/null ; then
+  if ! $cc -o $CONFTEST $source_path/conftest.c ; then
     echo "configure: error: '$cc' failed to compile conftest.c."
   else
     cc_name="$($CONFTEST compiler)"
@@ -344,13 +423,11 @@ if test -z "$cross_prefix" ; then
     _triplet="$($CONFTEST triplet)"
   fi
   if test "$mingw32" = "no" ; then
-
-      if test -z "$triplet"; then
-        if test -n "$_triplet" -a -f "/usr/lib/$_triplet/crti.o" ; then
+      if test -z "$triplet" -a -n "$_triplet"; then
+        if test -f "/usr/lib/$_triplet/crti.o"; then
           triplet="$_triplet"
         fi
       fi
-
       if test -z "$triplet"; then
         if test $cpu = "x86_64" -o $cpu = "arm64" -o $cpu = "riscv64" ; then
           if test -f "/usr/lib64/crti.o" ; then
@@ -358,22 +435,6 @@ if test -z "$cross_prefix" ; then
           fi
         fi
       fi
-
-      if test "$cpu" = "arm" ; then
-	if test "${triplet%eabihf}" != "$triplet" ; then
-	   confvars="$confvars arm_eabihf arm_vfp"
-	elif test "${triplet%eabi}" != "$triplet" ; then
-	   confvars="$confvars arm_eabi arm_vfp"
-	elif test "${_triplet%eabihf}" != "$_triplet" ; then
-	   confvars="$confvars arm_eabihf arm_vfp"
-	elif test "${_triplet%eabi}" != "$_triplet" ; then
-	   confvars="$confvars arm_eabi arm_vfp"
-	fi
-	if grep -s -q "^Features.* \(vfp\|iwmmxt\) " /proc/cpuinfo ; then
-	   confvars="$confvars arm_vfp"
-	fi
-      fi
-
       if test "$suggest" = "yes"; then
         if test -f "/lib/ld-uClibc.so.0" ; then
           echo "Perhaps you want ./configure --config-uClibc"
@@ -382,31 +443,52 @@ if test -z "$cross_prefix" ; then
           echo "Perhaps you want ./configure --config-musl"
         fi
       fi
-  else # mingw32 = yes
-      if test "$cc_name" = "gcc"; then
-        # avoid mingw dependencies such as 'libgcc_s_dw2-1.dll'
-        test -z "$LDFLAGS" && LDFLAGS="-static"
-      fi
   fi
 else
-  # if cross compiling, cannot launch a program, so make a static guess
+  # can only make guesses about compiler and target
+  if test "${cc%tcc*}" != "$cc"; then
+    cc_name="tcc"
+  elif test "${cc%clang*}" != "$cc"; then
+    cc_name="clang"
+  fi
   case $cpu in
     ppc|mips|s390)  bigendian=yes;;
   esac
+  case $targetos in
+    Linux)
+      default triplet "$cpu_set-linux-gnu"
+  esac
 fi
 
 if test "$bigendian" = "yes" ; then
   confvars="$confvars BIGENDIAN"
 fi
 
+if test "$cpu" = "arm"; then
+  if test "${triplet%eabihf}" != "$triplet" ; then
+    confvars="$confvars arm_eabihf arm_vfp"
+  elif test "${triplet%eabi}" != "$triplet" ; then
+    confvars="$confvars arm_eabi arm_vfp"
+  elif test -z "$build_cross"; then
+    if test "${_triplet%eabihf}" != "$_triplet" ; then
+      confvars="$confvars arm_eabihf arm_vfp"
+    elif test "${_triplet%eabi}" != "$_triplet" ; then
+      confvars="$confvars arm_eabi arm_vfp"
+    elif grep -s -q "^Features.* \(vfp\|iwmmxt\) " /proc/cpuinfo ; then
+      confvars="$confvars arm_vfp"
+    fi
+  fi
+fi
+
 # a final configuration tuning
 if test "$cc_name" != "tcc"; then
   OPT1="-Wdeclaration-after-statement -fno-strict-aliasing"
   # we want -Wno- but gcc does not always reject unknown -Wno- options
   OPT2="-Wpointer-sign -Wsign-compare -Wunused-result -Wformat-truncation"
+  OPT2="$OPT2 -Wstringop-truncation"
   if test "$cc_name" = "clang"; then
     OPT1="$OPT1 -fheinous-gnu-extensions"
-    OPT2="$OPT2 -Wstring-plus-int"
+    OPT2="$OPT2 -Wstring-plus-int -Wdeprecated-declarations"
   fi
   $cc $OPT1 $OPT2 -o a.out -c -xc - < /dev/null > cc_msg.txt 2>&1
   for o in $OPT1; do # enable these options
@@ -438,6 +520,11 @@ echo "C compiler          $cc ($gcc_major.$gcc_minor)"
 echo "Target OS           $targetos"
 echo "CPU                 $cpu"
 fcho "Triplet             " "$triplet"
+fcho "Libs                " "$tcc_libpaths"
+fcho "Sysinclude          " "$tcc_sysincludepaths"
+fcho "Crt                 " "$tcc_crtprefix"
+fcho "Elfinterp           " "$tcc_elfinterp"
+fcho "Switches            " "$tcc_switches"
 fcho "Config              " "${confvars# }"
 echo "Creating config.mak and config.h"
 
@@ -485,17 +572,20 @@ echo "/* Automatically generated by configure - do not modify */" > $TMPH
 
 print_inc CONFIG_SYSROOT "$sysroot"
 test "$tccdir_auto" = "yes" || print_inc CONFIG_TCCDIR "$tccdir"
+print_inc DWARF_VERSION "$dwarf" num
 print_mak CONFIG_USR_INCLUDE "$tcc_usrinclude"
 print_mak CONFIG_TCC_SYSINCLUDEPATHS "$tcc_sysincludepaths"
 print_mak CONFIG_TCC_LIBPATHS "$tcc_libpaths"
 print_mak CONFIG_TCC_CRTPREFIX "$tcc_crtprefix"
 print_mak CONFIG_TCC_ELFINTERP "$tcc_elfinterp"
+print_mak CONFIG_TCC_SWITCHES "$tcc_switches"
 print_mak CONFIG_LDDIR "$tcc_lddir"
 print_mak CONFIG_TRIPLET "$triplet"
 print_mak TCC_CPU_VERSION "$cpuver" num
 
 echo "ARCH=$cpu" >> config.mak
 echo "TARGETOS=$targetos" >> config.mak
+echo "BUILDOS=$buildos" >> config.mak
 
 predefs="1"
 for v in $confvars ; do
@@ -513,6 +603,12 @@ echo "VERSION = $version" >> config.mak
 echo "#define TCC_VERSION \"$version\"" >> $TMPH
 echo "@set VERSION $version" > config.texi
 
+if test "$targetos" = "Darwin"; then
+  # On macOS, -current_version and -compatibility_version must not contain letters.
+  macos_dylib_version=`echo $version | sed 's/[^0-9.]//g'`
+  echo "MACOS_DYLIB_VERSION = $macos_dylib_version" >> config.mak
+fi
+
 if test "$source_path_used" = "yes" ; then
     case $source_path in
        /*) echo "TOPSRC=$source_path";;
diff --git a/conftest.c b/conftest.c
index e8e1220a2..a4450d514 100644
--- a/conftest.c
+++ b/conftest.c
@@ -1,8 +1,8 @@
 /* ----------------------------------------------------------------------- */
-#if C2STR
-
 /* with -D C2STR: convert tccdefs.h to C-strings */
 
+#if C2STR
+
 #include <stdio.h>
 #include <string.h>
 
@@ -21,6 +21,8 @@ const char *platform_macros[] = {
     "__OpenBSD__",          "TARGETOS_OpenBSD",
     "__NetBSD__",           "TARGETOS_NetBSD",
     "__linux__",            "TARGETOS_Linux",
+    "__ANDROID__",          "TARGETOS_ANDROID",
+
     "__SIZEOF_POINTER__",   "PTR_SIZE",
     "__SIZEOF_LONG__",      "LONG_SIZE",
     0
@@ -164,14 +166,16 @@ int main(int argc, char **argv)
 }
 
 /* ----------------------------------------------------------------------- */
-#elif 1
-
 /* get some information from the host compiler for configure */
 
+#elif 1
+
 #include <stdio.h>
 
 #if defined(_WIN32)
 #include <fcntl.h>
+#include <io.h>
+int _CRT_glob = 0;
 #endif
 
 /* Define architecture */
@@ -206,15 +210,21 @@ int main(int argc, char **argv)
 # define TRIPLET_OS "unknown"
 #endif
 
+#if defined __ANDROID__
+# define ABI_PREFIX "android"
+#else
+# define ABI_PREFIX "gnu"
+#endif
+
 /* Define calling convention and ABI */
 #if defined (__ARM_EABI__)
 # if defined (__ARM_PCS_VFP)
-#  define TRIPLET_ABI "gnueabihf"
+#  define TRIPLET_ABI ABI_PREFIX"eabihf"
 # else
-#  define TRIPLET_ABI "gnueabi"
+#  define TRIPLET_ABI ABI_PREFIX"eabi"
 # endif
 #else
-# define TRIPLET_ABI "gnu"
+# define TRIPLET_ABI ABI_PREFIX
 #endif
 
 #if defined _WIN32
@@ -225,10 +235,6 @@ int main(int argc, char **argv)
 # define TRIPLET TRIPLET_ARCH "-" TRIPLET_OS "-" TRIPLET_ABI
 #endif
 
-#if defined(_WIN32)
-int _CRT_glob = 0;
-#endif
-
 int main(int argc, char *argv[])
 {
 #if defined(_WIN32)
diff --git a/dwarf.h b/dwarf.h
new file mode 100644
index 000000000..c961bc366
--- /dev/null
+++ b/dwarf.h
@@ -0,0 +1,1046 @@
+/* This file defines standard DWARF types, structures, and macros.
+   Copyright (C) 2000-2011, 2014, 2016, 2017, 2018 Red Hat, Inc.
+   This file is part of elfutils.
+
+   This file is free software; you can redistribute it and/or modify
+   it under the terms of either
+
+     * the GNU Lesser General Public License as published by the Free
+       Software Foundation; either version 3 of the License, or (at
+       your option) any later version
+
+   or
+
+     * the GNU General Public License as published by the Free
+       Software Foundation; either version 2 of the License, or (at
+       your option) any later version
+
+   or both in parallel, as here.
+
+   elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received copies of the GNU General Public License and
+   the GNU Lesser General Public License along with this program.  If
+   not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef _DWARF_H
+#define	_DWARF_H 1
+
+/* DWARF Unit Header Types.  */
+enum
+  {
+    DW_UT_compile = 0x01,
+    DW_UT_type = 0x02,
+    DW_UT_partial = 0x03,
+    DW_UT_skeleton = 0x04,
+    DW_UT_split_compile = 0x05,
+    DW_UT_split_type = 0x06,
+
+    DW_UT_lo_user = 0x80,
+    DW_UT_hi_user = 0xff
+  };
+
+/* DWARF tags.  */
+enum
+  {
+    DW_TAG_array_type = 0x01,
+    DW_TAG_class_type = 0x02,
+    DW_TAG_entry_point = 0x03,
+    DW_TAG_enumeration_type = 0x04,
+    DW_TAG_formal_parameter = 0x05,
+    /* 0x06 reserved.  */
+    /* 0x07 reserved.  */
+    DW_TAG_imported_declaration = 0x08,
+    /* 0x09 reserved.  */
+    DW_TAG_label = 0x0a,
+    DW_TAG_lexical_block = 0x0b,
+    /* 0x0c reserved.  */
+    DW_TAG_member = 0x0d,
+    /* 0x0e reserved.  */
+    DW_TAG_pointer_type = 0x0f,
+    DW_TAG_reference_type = 0x10,
+    DW_TAG_compile_unit = 0x11,
+    DW_TAG_string_type = 0x12,
+    DW_TAG_structure_type = 0x13,
+    /* 0x14 reserved.  */
+    DW_TAG_subroutine_type = 0x15,
+    DW_TAG_typedef = 0x16,
+    DW_TAG_union_type = 0x17,
+    DW_TAG_unspecified_parameters = 0x18,
+    DW_TAG_variant = 0x19,
+    DW_TAG_common_block = 0x1a,
+    DW_TAG_common_inclusion = 0x1b,
+    DW_TAG_inheritance = 0x1c,
+    DW_TAG_inlined_subroutine = 0x1d,
+    DW_TAG_module = 0x1e,
+    DW_TAG_ptr_to_member_type = 0x1f,
+    DW_TAG_set_type = 0x20,
+    DW_TAG_subrange_type = 0x21,
+    DW_TAG_with_stmt = 0x22,
+    DW_TAG_access_declaration = 0x23,
+    DW_TAG_base_type = 0x24,
+    DW_TAG_catch_block = 0x25,
+    DW_TAG_const_type = 0x26,
+    DW_TAG_constant = 0x27,
+    DW_TAG_enumerator = 0x28,
+    DW_TAG_file_type = 0x29,
+    DW_TAG_friend = 0x2a,
+    DW_TAG_namelist = 0x2b,
+    DW_TAG_namelist_item = 0x2c,
+    DW_TAG_packed_type = 0x2d,
+    DW_TAG_subprogram = 0x2e,
+    DW_TAG_template_type_parameter = 0x2f,
+    DW_TAG_template_value_parameter = 0x30,
+    DW_TAG_thrown_type = 0x31,
+    DW_TAG_try_block = 0x32,
+    DW_TAG_variant_part = 0x33,
+    DW_TAG_variable = 0x34,
+    DW_TAG_volatile_type = 0x35,
+    DW_TAG_dwarf_procedure = 0x36,
+    DW_TAG_restrict_type = 0x37,
+    DW_TAG_interface_type = 0x38,
+    DW_TAG_namespace = 0x39,
+    DW_TAG_imported_module = 0x3a,
+    DW_TAG_unspecified_type = 0x3b,
+    DW_TAG_partial_unit = 0x3c,
+    DW_TAG_imported_unit = 0x3d,
+    /* 0x3e reserved.  Was DW_TAG_mutable_type.  */
+    DW_TAG_condition = 0x3f,
+    DW_TAG_shared_type = 0x40,
+    DW_TAG_type_unit = 0x41,
+    DW_TAG_rvalue_reference_type = 0x42,
+    DW_TAG_template_alias = 0x43,
+    DW_TAG_coarray_type = 0x44,
+    DW_TAG_generic_subrange = 0x45,
+    DW_TAG_dynamic_type = 0x46,
+    DW_TAG_atomic_type = 0x47,
+    DW_TAG_call_site = 0x48,
+    DW_TAG_call_site_parameter = 0x49,
+    DW_TAG_skeleton_unit = 0x4a,
+    DW_TAG_immutable_type = 0x4b,
+
+    DW_TAG_lo_user = 0x4080,
+
+    DW_TAG_MIPS_loop = 0x4081,
+    DW_TAG_format_label = 0x4101,
+    DW_TAG_function_template = 0x4102,
+    DW_TAG_class_template = 0x4103,
+
+    DW_TAG_GNU_BINCL = 0x4104,
+    DW_TAG_GNU_EINCL = 0x4105,
+
+    DW_TAG_GNU_template_template_param = 0x4106,
+    DW_TAG_GNU_template_parameter_pack = 0x4107,
+    DW_TAG_GNU_formal_parameter_pack = 0x4108,
+    DW_TAG_GNU_call_site = 0x4109,
+    DW_TAG_GNU_call_site_parameter = 0x410a,
+
+    DW_TAG_hi_user = 0xffff
+  };
+
+
+/* Children determination encodings.  */
+enum
+  {
+    DW_CHILDREN_no = 0,
+    DW_CHILDREN_yes = 1
+  };
+
+
+/* DWARF attributes encodings.  */
+enum
+  {
+    DW_AT_sibling = 0x01,
+    DW_AT_location = 0x02,
+    DW_AT_name = 0x03,
+    /* 0x04 reserved.  */
+    /* 0x05 reserved.  */
+    /* 0x06 reserved.  */
+    /* 0x07 reserved.  */
+    /* 0x08 reserved.  */
+    DW_AT_ordering = 0x09,
+    /* 0x0a reserved.  */
+    DW_AT_byte_size = 0x0b,
+    DW_AT_bit_offset = 0x0c,  /* Deprecated in DWARF4.  */
+    DW_AT_bit_size = 0x0d,
+    /* 0x0e reserved.  */
+    /* 0x0f reserved.  */
+    DW_AT_stmt_list = 0x10,
+    DW_AT_low_pc = 0x11,
+    DW_AT_high_pc = 0x12,
+    DW_AT_language = 0x13,
+    /* 0x14 reserved.  */
+    DW_AT_discr = 0x15,
+    DW_AT_discr_value = 0x16,
+    DW_AT_visibility = 0x17,
+    DW_AT_import = 0x18,
+    DW_AT_string_length = 0x19,
+    DW_AT_common_reference = 0x1a,
+    DW_AT_comp_dir = 0x1b,
+    DW_AT_const_value = 0x1c,
+    DW_AT_containing_type = 0x1d,
+    DW_AT_default_value = 0x1e,
+    /* 0x1f reserved.  */
+    DW_AT_inline = 0x20,
+    DW_AT_is_optional = 0x21,
+    DW_AT_lower_bound = 0x22,
+    /* 0x23 reserved.  */
+    /* 0x24 reserved.  */
+    DW_AT_producer = 0x25,
+    /* 0x26 reserved.  */
+    DW_AT_prototyped = 0x27,
+    /* 0x28 reserved.  */
+    /* 0x29 reserved.  */
+    DW_AT_return_addr = 0x2a,
+    /* 0x2b reserved.  */
+    DW_AT_start_scope = 0x2c,
+    /* 0x2d reserved.  */
+    DW_AT_bit_stride = 0x2e,
+    DW_AT_upper_bound = 0x2f,
+    /* 0x30 reserved.  */
+    DW_AT_abstract_origin = 0x31,
+    DW_AT_accessibility = 0x32,
+    DW_AT_address_class = 0x33,
+    DW_AT_artificial = 0x34,
+    DW_AT_base_types = 0x35,
+    DW_AT_calling_convention = 0x36,
+    DW_AT_count = 0x37,
+    DW_AT_data_member_location = 0x38,
+    DW_AT_decl_column = 0x39,
+    DW_AT_decl_file = 0x3a,
+    DW_AT_decl_line = 0x3b,
+    DW_AT_declaration = 0x3c,
+    DW_AT_discr_list = 0x3d,
+    DW_AT_encoding = 0x3e,
+    DW_AT_external = 0x3f,
+    DW_AT_frame_base = 0x40,
+    DW_AT_friend = 0x41,
+    DW_AT_identifier_case = 0x42,
+    DW_AT_macro_info = 0x43, /* Deprecated in DWARF5.  */
+    DW_AT_namelist_item = 0x44,
+    DW_AT_priority = 0x45,
+    DW_AT_segment = 0x46,
+    DW_AT_specification = 0x47,
+    DW_AT_static_link = 0x48,
+    DW_AT_type = 0x49,
+    DW_AT_use_location = 0x4a,
+    DW_AT_variable_parameter = 0x4b,
+    DW_AT_virtuality = 0x4c,
+    DW_AT_vtable_elem_location = 0x4d,
+    DW_AT_allocated = 0x4e,
+    DW_AT_associated = 0x4f,
+    DW_AT_data_location = 0x50,
+    DW_AT_byte_stride = 0x51,
+    DW_AT_entry_pc = 0x52,
+    DW_AT_use_UTF8 = 0x53,
+    DW_AT_extension = 0x54,
+    DW_AT_ranges = 0x55,
+    DW_AT_trampoline = 0x56,
+    DW_AT_call_column = 0x57,
+    DW_AT_call_file = 0x58,
+    DW_AT_call_line = 0x59,
+    DW_AT_description = 0x5a,
+    DW_AT_binary_scale = 0x5b,
+    DW_AT_decimal_scale = 0x5c,
+    DW_AT_small = 0x5d,
+    DW_AT_decimal_sign = 0x5e,
+    DW_AT_digit_count = 0x5f,
+    DW_AT_picture_string = 0x60,
+    DW_AT_mutable = 0x61,
+    DW_AT_threads_scaled = 0x62,
+    DW_AT_explicit = 0x63,
+    DW_AT_object_pointer = 0x64,
+    DW_AT_endianity = 0x65,
+    DW_AT_elemental = 0x66,
+    DW_AT_pure = 0x67,
+    DW_AT_recursive = 0x68,
+    DW_AT_signature = 0x69,
+    DW_AT_main_subprogram = 0x6a,
+    DW_AT_data_bit_offset = 0x6b,
+    DW_AT_const_expr = 0x6c,
+    DW_AT_enum_class = 0x6d,
+    DW_AT_linkage_name = 0x6e,
+    DW_AT_string_length_bit_size = 0x6f,
+    DW_AT_string_length_byte_size = 0x70,
+    DW_AT_rank = 0x71,
+    DW_AT_str_offsets_base = 0x72,
+    DW_AT_addr_base = 0x73,
+    DW_AT_rnglists_base = 0x74,
+    /* 0x75 reserved.  */
+    DW_AT_dwo_name = 0x76,
+    DW_AT_reference = 0x77,
+    DW_AT_rvalue_reference = 0x78,
+    DW_AT_macros = 0x79,
+    DW_AT_call_all_calls = 0x7a,
+    DW_AT_call_all_source_calls = 0x7b,
+    DW_AT_call_all_tail_calls = 0x7c,
+    DW_AT_call_return_pc = 0x7d,
+    DW_AT_call_value = 0x7e,
+    DW_AT_call_origin = 0x7f,
+    DW_AT_call_parameter = 0x80,
+    DW_AT_call_pc = 0x81,
+    DW_AT_call_tail_call = 0x82,
+    DW_AT_call_target = 0x83,
+    DW_AT_call_target_clobbered = 0x84,
+    DW_AT_call_data_location = 0x85,
+    DW_AT_call_data_value = 0x86,
+    DW_AT_noreturn = 0x87,
+    DW_AT_alignment = 0x88,
+    DW_AT_export_symbols = 0x89,
+    DW_AT_deleted = 0x8a,
+    DW_AT_defaulted = 0x8b,
+    DW_AT_loclists_base = 0x8c,
+
+    DW_AT_lo_user = 0x2000,
+
+    DW_AT_MIPS_fde = 0x2001,
+    DW_AT_MIPS_loop_begin = 0x2002,
+    DW_AT_MIPS_tail_loop_begin = 0x2003,
+    DW_AT_MIPS_epilog_begin = 0x2004,
+    DW_AT_MIPS_loop_unroll_factor = 0x2005,
+    DW_AT_MIPS_software_pipeline_depth = 0x2006,
+    DW_AT_MIPS_linkage_name = 0x2007,
+    DW_AT_MIPS_stride = 0x2008,
+    DW_AT_MIPS_abstract_name = 0x2009,
+    DW_AT_MIPS_clone_origin = 0x200a,
+    DW_AT_MIPS_has_inlines = 0x200b,
+    DW_AT_MIPS_stride_byte = 0x200c,
+    DW_AT_MIPS_stride_elem = 0x200d,
+    DW_AT_MIPS_ptr_dopetype = 0x200e,
+    DW_AT_MIPS_allocatable_dopetype = 0x200f,
+    DW_AT_MIPS_assumed_shape_dopetype = 0x2010,
+    DW_AT_MIPS_assumed_size = 0x2011,
+
+    /* GNU extensions.  */
+    DW_AT_sf_names = 0x2101,
+    DW_AT_src_info = 0x2102,
+    DW_AT_mac_info = 0x2103,
+    DW_AT_src_coords = 0x2104,
+    DW_AT_body_begin = 0x2105,
+    DW_AT_body_end = 0x2106,
+    DW_AT_GNU_vector = 0x2107,
+    DW_AT_GNU_guarded_by = 0x2108,
+    DW_AT_GNU_pt_guarded_by = 0x2109,
+    DW_AT_GNU_guarded = 0x210a,
+    DW_AT_GNU_pt_guarded = 0x210b,
+    DW_AT_GNU_locks_excluded = 0x210c,
+    DW_AT_GNU_exclusive_locks_required = 0x210d,
+    DW_AT_GNU_shared_locks_required = 0x210e,
+    DW_AT_GNU_odr_signature = 0x210f,
+    DW_AT_GNU_template_name = 0x2110,
+    DW_AT_GNU_call_site_value = 0x2111,
+    DW_AT_GNU_call_site_data_value = 0x2112,
+    DW_AT_GNU_call_site_target = 0x2113,
+    DW_AT_GNU_call_site_target_clobbered = 0x2114,
+    DW_AT_GNU_tail_call = 0x2115,
+    DW_AT_GNU_all_tail_call_sites = 0x2116,
+    DW_AT_GNU_all_call_sites = 0x2117,
+    DW_AT_GNU_all_source_call_sites = 0x2118,
+    DW_AT_GNU_locviews = 0x2137,
+    DW_AT_GNU_entry_view = 0x2138,
+    DW_AT_GNU_macros = 0x2119,
+    DW_AT_GNU_deleted = 0x211a,
+    /* GNU Debug Fission extensions.  */
+    DW_AT_GNU_dwo_name = 0x2130,
+    DW_AT_GNU_dwo_id = 0x2131,
+    DW_AT_GNU_ranges_base = 0x2132,
+    DW_AT_GNU_addr_base = 0x2133,
+    DW_AT_GNU_pubnames = 0x2134,
+    DW_AT_GNU_pubtypes = 0x2135,
+
+    /* https://gcc.gnu.org/wiki/DW_AT_GNU_numerator_denominator  */
+    DW_AT_GNU_numerator = 0x2303,
+    DW_AT_GNU_denominator = 0x2304,
+    /* https://gcc.gnu.org/wiki/DW_AT_GNU_bias  */
+    DW_AT_GNU_bias = 0x2305,
+
+    DW_AT_hi_user = 0x3fff
+  };
+
+/* Old unofficially attribute names.  Should not be used.
+   Will not appear in known-dwarf.h  */
+
+/* DWARF1 array subscripts and element data types.  */
+#define DW_AT_subscr_data	0x0a
+/* DWARF1 enumeration literals.  */
+#define DW_AT_element_list	0x0f
+/* DWARF1 reference for variable to member structure, class or union.  */
+#define DW_AT_member		0x14
+
+/* DWARF form encodings.  */
+enum
+  {
+    DW_FORM_addr = 0x01,
+    DW_FORM_block2 = 0x03,
+    DW_FORM_block4 = 0x04,
+    DW_FORM_data2 = 0x05,
+    DW_FORM_data4 = 0x06,
+    DW_FORM_data8 = 0x07,
+    DW_FORM_string = 0x08,
+    DW_FORM_block = 0x09,
+    DW_FORM_block1 = 0x0a,
+    DW_FORM_data1 = 0x0b,
+    DW_FORM_flag = 0x0c,
+    DW_FORM_sdata = 0x0d,
+    DW_FORM_strp = 0x0e,
+    DW_FORM_udata = 0x0f,
+    DW_FORM_ref_addr = 0x10,
+    DW_FORM_ref1 = 0x11,
+    DW_FORM_ref2 = 0x12,
+    DW_FORM_ref4 = 0x13,
+    DW_FORM_ref8 = 0x14,
+    DW_FORM_ref_udata = 0x15,
+    DW_FORM_indirect = 0x16,
+    DW_FORM_sec_offset = 0x17,
+    DW_FORM_exprloc = 0x18,
+    DW_FORM_flag_present = 0x19,
+    DW_FORM_strx = 0x1a,
+    DW_FORM_addrx = 0x1b,
+    DW_FORM_ref_sup4 = 0x1c,
+    DW_FORM_strp_sup = 0x1d,
+    DW_FORM_data16 = 0x1e,
+    DW_FORM_line_strp = 0x1f,
+    DW_FORM_ref_sig8 = 0x20,
+    DW_FORM_implicit_const = 0x21,
+    DW_FORM_loclistx = 0x22,
+    DW_FORM_rnglistx = 0x23,
+    DW_FORM_ref_sup8 = 0x24,
+    DW_FORM_strx1 = 0x25,
+    DW_FORM_strx2 = 0x26,
+    DW_FORM_strx3 = 0x27,
+    DW_FORM_strx4 = 0x28,
+    DW_FORM_addrx1 = 0x29,
+    DW_FORM_addrx2 = 0x2a,
+    DW_FORM_addrx3 = 0x2b,
+    DW_FORM_addrx4 = 0x2c,
+
+    /* GNU Debug Fission extensions.  */
+    DW_FORM_GNU_addr_index = 0x1f01,
+    DW_FORM_GNU_str_index = 0x1f02,
+
+    DW_FORM_GNU_ref_alt = 0x1f20, /* offset in alternate .debuginfo.  */
+    DW_FORM_GNU_strp_alt = 0x1f21 /* offset in alternate .debug_str. */
+  };
+
+
+/* DWARF location operation encodings.  */
+enum
+  {
+    DW_OP_addr = 0x03,		/* Constant address.  */
+    DW_OP_deref = 0x06,
+    DW_OP_const1u = 0x08,	/* Unsigned 1-byte constant.  */
+    DW_OP_const1s = 0x09,	/* Signed 1-byte constant.  */
+    DW_OP_const2u = 0x0a,	/* Unsigned 2-byte constant.  */
+    DW_OP_const2s = 0x0b,	/* Signed 2-byte constant.  */
+    DW_OP_const4u = 0x0c,	/* Unsigned 4-byte constant.  */
+    DW_OP_const4s = 0x0d,	/* Signed 4-byte constant.  */
+    DW_OP_const8u = 0x0e,	/* Unsigned 8-byte constant.  */
+    DW_OP_const8s = 0x0f,	/* Signed 8-byte constant.  */
+    DW_OP_constu = 0x10,	/* Unsigned LEB128 constant.  */
+    DW_OP_consts = 0x11,	/* Signed LEB128 constant.  */
+    DW_OP_dup = 0x12,
+    DW_OP_drop = 0x13,
+    DW_OP_over = 0x14,
+    DW_OP_pick = 0x15,		/* 1-byte stack index.  */
+    DW_OP_swap = 0x16,
+    DW_OP_rot = 0x17,
+    DW_OP_xderef = 0x18,
+    DW_OP_abs = 0x19,
+    DW_OP_and = 0x1a,
+    DW_OP_div = 0x1b,
+    DW_OP_minus = 0x1c,
+    DW_OP_mod = 0x1d,
+    DW_OP_mul = 0x1e,
+    DW_OP_neg = 0x1f,
+    DW_OP_not = 0x20,
+    DW_OP_or = 0x21,
+    DW_OP_plus = 0x22,
+    DW_OP_plus_uconst = 0x23,	/* Unsigned LEB128 addend.  */
+    DW_OP_shl = 0x24,
+    DW_OP_shr = 0x25,
+    DW_OP_shra = 0x26,
+    DW_OP_xor = 0x27,
+    DW_OP_bra = 0x28,		/* Signed 2-byte constant.  */
+    DW_OP_eq = 0x29,
+    DW_OP_ge = 0x2a,
+    DW_OP_gt = 0x2b,
+    DW_OP_le = 0x2c,
+    DW_OP_lt = 0x2d,
+    DW_OP_ne = 0x2e,
+    DW_OP_skip = 0x2f,		/* Signed 2-byte constant.  */
+    DW_OP_lit0 = 0x30,		/* Literal 0.  */
+    DW_OP_lit1 = 0x31,		/* Literal 1.  */
+    DW_OP_lit2 = 0x32,		/* Literal 2.  */
+    DW_OP_lit3 = 0x33,		/* Literal 3.  */
+    DW_OP_lit4 = 0x34,		/* Literal 4.  */
+    DW_OP_lit5 = 0x35,		/* Literal 5.  */
+    DW_OP_lit6 = 0x36,		/* Literal 6.  */
+    DW_OP_lit7 = 0x37,		/* Literal 7.  */
+    DW_OP_lit8 = 0x38,		/* Literal 8.  */
+    DW_OP_lit9 = 0x39,		/* Literal 9.  */
+    DW_OP_lit10 = 0x3a,		/* Literal 10.  */
+    DW_OP_lit11 = 0x3b,		/* Literal 11.  */
+    DW_OP_lit12 = 0x3c,		/* Literal 12.  */
+    DW_OP_lit13 = 0x3d,		/* Literal 13.  */
+    DW_OP_lit14 = 0x3e,		/* Literal 14.  */
+    DW_OP_lit15 = 0x3f,		/* Literal 15.  */
+    DW_OP_lit16 = 0x40,		/* Literal 16.  */
+    DW_OP_lit17 = 0x41,		/* Literal 17.  */
+    DW_OP_lit18 = 0x42,		/* Literal 18.  */
+    DW_OP_lit19 = 0x43,		/* Literal 19.  */
+    DW_OP_lit20 = 0x44,		/* Literal 20.  */
+    DW_OP_lit21 = 0x45,		/* Literal 21.  */
+    DW_OP_lit22 = 0x46,		/* Literal 22.  */
+    DW_OP_lit23 = 0x47,		/* Literal 23.  */
+    DW_OP_lit24 = 0x48,		/* Literal 24.  */
+    DW_OP_lit25 = 0x49,		/* Literal 25.  */
+    DW_OP_lit26 = 0x4a,		/* Literal 26.  */
+    DW_OP_lit27 = 0x4b,		/* Literal 27.  */
+    DW_OP_lit28 = 0x4c,		/* Literal 28.  */
+    DW_OP_lit29 = 0x4d,		/* Literal 29.  */
+    DW_OP_lit30 = 0x4e,		/* Literal 30.  */
+    DW_OP_lit31 = 0x4f,		/* Literal 31.  */
+    DW_OP_reg0 = 0x50,		/* Register 0.  */
+    DW_OP_reg1 = 0x51,		/* Register 1.  */
+    DW_OP_reg2 = 0x52,		/* Register 2.  */
+    DW_OP_reg3 = 0x53,		/* Register 3.  */
+    DW_OP_reg4 = 0x54,		/* Register 4.  */
+    DW_OP_reg5 = 0x55,		/* Register 5.  */
+    DW_OP_reg6 = 0x56,		/* Register 6.  */
+    DW_OP_reg7 = 0x57,		/* Register 7.  */
+    DW_OP_reg8 = 0x58,		/* Register 8.  */
+    DW_OP_reg9 = 0x59,		/* Register 9.  */
+    DW_OP_reg10 = 0x5a,		/* Register 10.  */
+    DW_OP_reg11 = 0x5b,		/* Register 11.  */
+    DW_OP_reg12 = 0x5c,		/* Register 12.  */
+    DW_OP_reg13 = 0x5d,		/* Register 13.  */
+    DW_OP_reg14 = 0x5e,		/* Register 14.  */
+    DW_OP_reg15 = 0x5f,		/* Register 15.  */
+    DW_OP_reg16 = 0x60,		/* Register 16.  */
+    DW_OP_reg17 = 0x61,		/* Register 17.  */
+    DW_OP_reg18 = 0x62,		/* Register 18.  */
+    DW_OP_reg19 = 0x63,		/* Register 19.  */
+    DW_OP_reg20 = 0x64,		/* Register 20.  */
+    DW_OP_reg21 = 0x65,		/* Register 21.  */
+    DW_OP_reg22 = 0x66,		/* Register 22.  */
+    DW_OP_reg23 = 0x67,		/* Register 24.  */
+    DW_OP_reg24 = 0x68,		/* Register 24.  */
+    DW_OP_reg25 = 0x69,		/* Register 25.  */
+    DW_OP_reg26 = 0x6a,		/* Register 26.  */
+    DW_OP_reg27 = 0x6b,		/* Register 27.  */
+    DW_OP_reg28 = 0x6c,		/* Register 28.  */
+    DW_OP_reg29 = 0x6d,		/* Register 29.  */
+    DW_OP_reg30 = 0x6e,		/* Register 30.  */
+    DW_OP_reg31 = 0x6f,		/* Register 31.  */
+    DW_OP_breg0 = 0x70,		/* Base register 0.  */
+    DW_OP_breg1 = 0x71,		/* Base register 1.  */
+    DW_OP_breg2 = 0x72,		/* Base register 2.  */
+    DW_OP_breg3 = 0x73,		/* Base register 3.  */
+    DW_OP_breg4 = 0x74,		/* Base register 4.  */
+    DW_OP_breg5 = 0x75,		/* Base register 5.  */
+    DW_OP_breg6 = 0x76,		/* Base register 6.  */
+    DW_OP_breg7 = 0x77,		/* Base register 7.  */
+    DW_OP_breg8 = 0x78,		/* Base register 8.  */
+    DW_OP_breg9 = 0x79,		/* Base register 9.  */
+    DW_OP_breg10 = 0x7a,	/* Base register 10.  */
+    DW_OP_breg11 = 0x7b,	/* Base register 11.  */
+    DW_OP_breg12 = 0x7c,	/* Base register 12.  */
+    DW_OP_breg13 = 0x7d,	/* Base register 13.  */
+    DW_OP_breg14 = 0x7e,	/* Base register 14.  */
+    DW_OP_breg15 = 0x7f,	/* Base register 15.  */
+    DW_OP_breg16 = 0x80,	/* Base register 16.  */
+    DW_OP_breg17 = 0x81,	/* Base register 17.  */
+    DW_OP_breg18 = 0x82,	/* Base register 18.  */
+    DW_OP_breg19 = 0x83,	/* Base register 19.  */
+    DW_OP_breg20 = 0x84,	/* Base register 20.  */
+    DW_OP_breg21 = 0x85,	/* Base register 21.  */
+    DW_OP_breg22 = 0x86,	/* Base register 22.  */
+    DW_OP_breg23 = 0x87,	/* Base register 23.  */
+    DW_OP_breg24 = 0x88,	/* Base register 24.  */
+    DW_OP_breg25 = 0x89,	/* Base register 25.  */
+    DW_OP_breg26 = 0x8a,	/* Base register 26.  */
+    DW_OP_breg27 = 0x8b,	/* Base register 27.  */
+    DW_OP_breg28 = 0x8c,	/* Base register 28.  */
+    DW_OP_breg29 = 0x8d,	/* Base register 29.  */
+    DW_OP_breg30 = 0x8e,	/* Base register 30.  */
+    DW_OP_breg31 = 0x8f,	/* Base register 31.  */
+    DW_OP_regx = 0x90,		/* Unsigned LEB128 register.  */
+    DW_OP_fbreg = 0x91,		/* Signed LEB128 offset.  */
+    DW_OP_bregx = 0x92,		/* ULEB128 register followed by SLEB128 off. */
+    DW_OP_piece = 0x93,		/* ULEB128 size of piece addressed. */
+    DW_OP_deref_size = 0x94,	/* 1-byte size of data retrieved.  */
+    DW_OP_xderef_size = 0x95,	/* 1-byte size of data retrieved.  */
+    DW_OP_nop = 0x96,
+    DW_OP_push_object_address = 0x97,
+    DW_OP_call2 = 0x98,
+    DW_OP_call4 = 0x99,
+    DW_OP_call_ref = 0x9a,
+    DW_OP_form_tls_address = 0x9b,/* TLS offset to address in current thread */
+    DW_OP_call_frame_cfa = 0x9c,/* CFA as determined by CFI.  */
+    DW_OP_bit_piece = 0x9d,	/* ULEB128 size and ULEB128 offset in bits.  */
+    DW_OP_implicit_value = 0x9e, /* DW_FORM_block follows opcode.  */
+    DW_OP_stack_value = 0x9f,	 /* No operands, special like DW_OP_piece.  */
+
+    DW_OP_implicit_pointer = 0xa0,
+    DW_OP_addrx = 0xa1,
+    DW_OP_constx = 0xa2,
+    DW_OP_entry_value = 0xa3,
+    DW_OP_const_type = 0xa4,
+    DW_OP_regval_type = 0xa5,
+    DW_OP_deref_type = 0xa6,
+    DW_OP_xderef_type = 0xa7,
+    DW_OP_convert = 0xa8,
+    DW_OP_reinterpret = 0xa9,
+
+    /* GNU extensions.  */
+    DW_OP_GNU_push_tls_address = 0xe0,
+    DW_OP_GNU_uninit = 0xf0,
+    DW_OP_GNU_encoded_addr = 0xf1,
+    DW_OP_GNU_implicit_pointer = 0xf2,
+    DW_OP_GNU_entry_value = 0xf3,
+    DW_OP_GNU_const_type = 0xf4,
+    DW_OP_GNU_regval_type = 0xf5,
+    DW_OP_GNU_deref_type = 0xf6,
+    DW_OP_GNU_convert = 0xf7,
+    DW_OP_GNU_reinterpret = 0xf9,
+    DW_OP_GNU_parameter_ref = 0xfa,
+
+    /* GNU Debug Fission extensions.  */
+    DW_OP_GNU_addr_index = 0xfb,
+    DW_OP_GNU_const_index = 0xfc,
+
+    DW_OP_GNU_variable_value = 0xfd,
+
+    DW_OP_lo_user = 0xe0,	/* Implementation-defined range start.  */
+    DW_OP_hi_user = 0xff	/* Implementation-defined range end.  */
+  };
+
+
+/* DWARF base type encodings.  */
+enum
+  {
+    DW_ATE_void = 0x0,
+    DW_ATE_address = 0x1,
+    DW_ATE_boolean = 0x2,
+    DW_ATE_complex_float = 0x3,
+    DW_ATE_float = 0x4,
+    DW_ATE_signed = 0x5,
+    DW_ATE_signed_char = 0x6,
+    DW_ATE_unsigned = 0x7,
+    DW_ATE_unsigned_char = 0x8,
+    DW_ATE_imaginary_float = 0x9,
+    DW_ATE_packed_decimal = 0xa,
+    DW_ATE_numeric_string = 0xb,
+    DW_ATE_edited = 0xc,
+    DW_ATE_signed_fixed = 0xd,
+    DW_ATE_unsigned_fixed = 0xe,
+    DW_ATE_decimal_float = 0xf,
+    DW_ATE_UTF = 0x10,
+    DW_ATE_UCS = 0x11,
+    DW_ATE_ASCII = 0x12,
+
+    DW_ATE_lo_user = 0x80,
+    DW_ATE_hi_user = 0xff
+  };
+
+
+/* DWARF decimal sign encodings.  */
+enum
+  {
+    DW_DS_unsigned = 1,
+    DW_DS_leading_overpunch = 2,
+    DW_DS_trailing_overpunch = 3,
+    DW_DS_leading_separate = 4,
+    DW_DS_trailing_separate = 5,
+  };
+
+
+/* DWARF endianity encodings.  */
+enum
+  {
+    DW_END_default = 0,
+    DW_END_big = 1,
+    DW_END_little = 2,
+
+    DW_END_lo_user = 0x40,
+    DW_END_hi_user = 0xff
+  };
+
+
+/* DWARF accessibility encodings.  */
+enum
+  {
+    DW_ACCESS_public = 1,
+    DW_ACCESS_protected = 2,
+    DW_ACCESS_private = 3
+  };
+
+
+/* DWARF visibility encodings.  */
+enum
+  {
+    DW_VIS_local = 1,
+    DW_VIS_exported = 2,
+    DW_VIS_qualified = 3
+  };
+
+
+/* DWARF virtuality encodings.  */
+enum
+  {
+    DW_VIRTUALITY_none = 0,
+    DW_VIRTUALITY_virtual = 1,
+    DW_VIRTUALITY_pure_virtual = 2
+  };
+
+
+/* DWARF language encodings.  */
+enum
+  {
+    DW_LANG_C89 = 0x0001,	     /* ISO C:1989 */
+    DW_LANG_C = 0x0002,		     /* C */
+    DW_LANG_Ada83 = 0x0003,	     /* ISO Ada:1983 */
+    DW_LANG_C_plus_plus	= 0x0004,    /* ISO C++:1998 */
+    DW_LANG_Cobol74 = 0x0005,	     /* ISO Cobol:1974 */
+    DW_LANG_Cobol85 = 0x0006,	     /* ISO Cobol:1985 */
+    DW_LANG_Fortran77 = 0x0007,	     /* ISO FORTRAN 77 */
+    DW_LANG_Fortran90 = 0x0008,	     /* ISO Fortran 90 */
+    DW_LANG_Pascal83 = 0x0009,	     /* ISO Pascal:1983 */
+    DW_LANG_Modula2 = 0x000a,	     /* ISO Modula-2:1996 */
+    DW_LANG_Java = 0x000b,	     /* Java */
+    DW_LANG_C99 = 0x000c,	     /* ISO C:1999 */
+    DW_LANG_Ada95 = 0x000d,	     /* ISO Ada:1995 */
+    DW_LANG_Fortran95 = 0x000e,	     /* ISO Fortran 95 */
+    DW_LANG_PLI = 0x000f,	     /* ISO PL/1:1976 */
+    DW_LANG_ObjC = 0x0010,	     /* Objective-C */
+    DW_LANG_ObjC_plus_plus = 0x0011, /* Objective-C++ */
+    DW_LANG_UPC = 0x0012,	     /* Unified Parallel C */
+    DW_LANG_D = 0x0013,		     /* D */
+    DW_LANG_Python = 0x0014,	     /* Python */
+    DW_LANG_OpenCL = 0x0015,	     /* OpenCL */
+    DW_LANG_Go = 0x0016,	     /* Go */
+    DW_LANG_Modula3 = 0x0017,	     /* Modula-3 */
+    DW_LANG_Haskell = 0x0018,	     /* Haskell */
+    DW_LANG_C_plus_plus_03 = 0x0019, /* ISO C++:2003 */
+    DW_LANG_C_plus_plus_11 = 0x001a, /* ISO C++:2011 */
+    DW_LANG_OCaml = 0x001b,	     /* OCaml */
+    DW_LANG_Rust = 0x001c,	     /* Rust */
+    DW_LANG_C11 = 0x001d,	     /* ISO C:2011 */
+    DW_LANG_Swift = 0x001e,	     /* Swift */
+    DW_LANG_Julia = 0x001f,	     /* Julia */
+    DW_LANG_Dylan = 0x0020,	     /* Dylan */
+    DW_LANG_C_plus_plus_14 = 0x0021, /* ISO C++:2014 */
+    DW_LANG_Fortran03 = 0x0022,	     /* ISO/IEC 1539-1:2004 */
+    DW_LANG_Fortran08 = 0x0023,	     /* ISO/IEC 1539-1:2010 */
+    DW_LANG_RenderScript = 0x0024,   /* RenderScript Kernal Language */
+    DW_LANG_BLISS = 0x0025,	     /* BLISS */
+
+    DW_LANG_lo_user = 0x8000,
+    DW_LANG_Mips_Assembler = 0x8001, /* Assembler */
+    DW_LANG_hi_user = 0xffff
+  };
+
+/* Old (typo) '1' != 'I'.  */
+#define DW_LANG_PL1 DW_LANG_PLI
+
+/* DWARF identifier case encodings.  */
+enum
+  {
+    DW_ID_case_sensitive = 0,
+    DW_ID_up_case = 1,
+    DW_ID_down_case = 2,
+    DW_ID_case_insensitive = 3
+  };
+
+
+/* DWARF calling conventions encodings.
+   Used as values of DW_AT_calling_convention for subroutines
+   (normal, program or nocall) or structures, unions and class types
+   (normal, reference or value).  */
+enum
+  {
+    DW_CC_normal = 0x1,
+    DW_CC_program = 0x2,
+    DW_CC_nocall = 0x3,
+    DW_CC_pass_by_reference = 0x4,
+    DW_CC_pass_by_value = 0x5,
+    DW_CC_lo_user = 0x40,
+    DW_CC_hi_user = 0xff
+  };
+
+
+/* DWARF inline encodings.  */
+enum
+  {
+    DW_INL_not_inlined = 0,
+    DW_INL_inlined = 1,
+    DW_INL_declared_not_inlined = 2,
+    DW_INL_declared_inlined = 3
+  };
+
+
+/* DWARF ordering encodings.  */
+enum
+  {
+    DW_ORD_row_major = 0,
+    DW_ORD_col_major = 1
+  };
+
+
+/* DWARF discriminant descriptor encodings.  */
+enum
+  {
+    DW_DSC_label = 0,
+    DW_DSC_range = 1
+  };
+
+/* DWARF defaulted member function encodings.  */
+enum
+  {
+    DW_DEFAULTED_no = 0,
+    DW_DEFAULTED_in_class = 1,
+    DW_DEFAULTED_out_of_class = 2
+  };
+
+/* DWARF line content descriptions.  */
+enum
+  {
+    DW_LNCT_path = 0x1,
+    DW_LNCT_directory_index = 0x2,
+    DW_LNCT_timestamp = 0x3,
+    DW_LNCT_size = 0x4,
+    DW_LNCT_MD5 = 0x5,
+    DW_LNCT_lo_user = 0x2000,
+    DW_LNCT_hi_user = 0x3fff
+  };
+
+/* DWARF standard opcode encodings.  */
+enum
+  {
+    DW_LNS_copy = 1,
+    DW_LNS_advance_pc = 2,
+    DW_LNS_advance_line = 3,
+    DW_LNS_set_file = 4,
+    DW_LNS_set_column = 5,
+    DW_LNS_negate_stmt = 6,
+    DW_LNS_set_basic_block = 7,
+    DW_LNS_const_add_pc = 8,
+    DW_LNS_fixed_advance_pc = 9,
+    DW_LNS_set_prologue_end = 10,
+    DW_LNS_set_epilogue_begin = 11,
+    DW_LNS_set_isa = 12
+  };
+
+
+/* DWARF extended opcode encodings.  */
+enum
+  {
+    DW_LNE_end_sequence = 1,
+    DW_LNE_set_address = 2,
+    DW_LNE_define_file = 3,
+    DW_LNE_set_discriminator = 4,
+
+    DW_LNE_lo_user = 128,
+
+    DW_LNE_NVIDIA_inlined_call = 144,
+    DW_LNE_NVIDIA_set_function_name = 145,
+
+    DW_LNE_hi_user = 255
+  };
+
+
+/* DWARF macinfo type encodings.  */
+enum
+  {
+    DW_MACINFO_define = 1,
+    DW_MACINFO_undef = 2,
+    DW_MACINFO_start_file = 3,
+    DW_MACINFO_end_file = 4,
+    DW_MACINFO_vendor_ext = 255
+  };
+
+
+/* DWARF debug_macro type encodings.  */
+enum
+  {
+    DW_MACRO_define = 0x01,
+    DW_MACRO_undef = 0x02,
+    DW_MACRO_start_file = 0x03,
+    DW_MACRO_end_file = 0x04,
+    DW_MACRO_define_strp = 0x05,
+    DW_MACRO_undef_strp = 0x06,
+    DW_MACRO_import = 0x07,
+    DW_MACRO_define_sup = 0x08,
+    DW_MACRO_undef_sup = 0x09,
+    DW_MACRO_import_sup = 0x0a,
+    DW_MACRO_define_strx = 0x0b,
+    DW_MACRO_undef_strx = 0x0c,
+    DW_MACRO_lo_user = 0xe0,
+    DW_MACRO_hi_user = 0xff
+  };
+
+/* Old GNU extension names for DWARF5 debug_macro type encodings.
+   There are no equivalents for the supplementary object file (sup)
+   and indirect string references (strx).  */
+#define DW_MACRO_GNU_define		 DW_MACRO_define
+#define DW_MACRO_GNU_undef		 DW_MACRO_undef
+#define DW_MACRO_GNU_start_file		 DW_MACRO_start_file
+#define DW_MACRO_GNU_end_file		 DW_MACRO_end_file
+#define DW_MACRO_GNU_define_indirect	 DW_MACRO_define_strp
+#define DW_MACRO_GNU_undef_indirect	 DW_MACRO_undef_strp
+#define DW_MACRO_GNU_transparent_include DW_MACRO_import
+#define DW_MACRO_GNU_lo_user		 DW_MACRO_lo_user
+#define DW_MACRO_GNU_hi_user		 DW_MACRO_hi_user
+
+
+/* Range list entry encoding.  */
+enum
+  {
+    DW_RLE_end_of_list = 0x0,
+    DW_RLE_base_addressx = 0x1,
+    DW_RLE_startx_endx = 0x2,
+    DW_RLE_startx_length = 0x3,
+    DW_RLE_offset_pair = 0x4,
+    DW_RLE_base_address = 0x5,
+    DW_RLE_start_end = 0x6,
+    DW_RLE_start_length = 0x7
+  };
+
+
+/* Location list entry encoding.  */
+enum
+  {
+    DW_LLE_end_of_list = 0x0,
+    DW_LLE_base_addressx = 0x1,
+    DW_LLE_startx_endx = 0x2,
+    DW_LLE_startx_length = 0x3,
+    DW_LLE_offset_pair = 0x4,
+    DW_LLE_default_location = 0x5,
+    DW_LLE_base_address = 0x6,
+    DW_LLE_start_end = 0x7,
+    DW_LLE_start_length = 0x8
+  };
+
+
+/* GNU DebugFission list entry encodings (.debug_loc.dwo).  */
+enum
+  {
+    DW_LLE_GNU_end_of_list_entry = 0x0,
+    DW_LLE_GNU_base_address_selection_entry = 0x1,
+    DW_LLE_GNU_start_end_entry = 0x2,
+    DW_LLE_GNU_start_length_entry = 0x3
+  };
+
+/* DWARF5 package file section identifiers.  */
+enum
+  {
+    DW_SECT_INFO = 1,
+    /* Reserved = 2, */
+    DW_SECT_ABBREV = 3,
+    DW_SECT_LINE = 4,
+    DW_SECT_LOCLISTS = 5,
+    DW_SECT_STR_OFFSETS = 6,
+    DW_SECT_MACRO = 7,
+    DW_SECT_RNGLISTS = 8,
+  };
+
+
+/* DWARF call frame instruction encodings.  */
+enum
+  {
+    DW_CFA_advance_loc = 0x40,
+    DW_CFA_offset = 0x80,
+    DW_CFA_restore = 0xc0,
+    DW_CFA_extended = 0,
+
+    DW_CFA_nop = 0x00,
+    DW_CFA_set_loc = 0x01,
+    DW_CFA_advance_loc1 = 0x02,
+    DW_CFA_advance_loc2 = 0x03,
+    DW_CFA_advance_loc4 = 0x04,
+    DW_CFA_offset_extended = 0x05,
+    DW_CFA_restore_extended = 0x06,
+    DW_CFA_undefined = 0x07,
+    DW_CFA_same_value = 0x08,
+    DW_CFA_register = 0x09,
+    DW_CFA_remember_state = 0x0a,
+    DW_CFA_restore_state = 0x0b,
+    DW_CFA_def_cfa = 0x0c,
+    DW_CFA_def_cfa_register = 0x0d,
+    DW_CFA_def_cfa_offset = 0x0e,
+    DW_CFA_def_cfa_expression = 0x0f,
+    DW_CFA_expression = 0x10,
+    DW_CFA_offset_extended_sf = 0x11,
+    DW_CFA_def_cfa_sf = 0x12,
+    DW_CFA_def_cfa_offset_sf = 0x13,
+    DW_CFA_val_offset = 0x14,
+    DW_CFA_val_offset_sf = 0x15,
+    DW_CFA_val_expression = 0x16,
+
+    DW_CFA_low_user = 0x1c,
+    DW_CFA_MIPS_advance_loc8 = 0x1d,
+    DW_CFA_GNU_window_save = 0x2d,
+    DW_CFA_AARCH64_negate_ra_state = 0x2d,
+    DW_CFA_GNU_args_size = 0x2e,
+    DW_CFA_GNU_negative_offset_extended = 0x2f,
+    DW_CFA_high_user = 0x3f
+  };
+
+/* ID indicating CIE as opposed to FDE in .debug_frame.  */
+enum
+  {
+    DW_CIE_ID_32 = 0xffffffffU,		 /* In 32-bit format CIE header.  */
+    DW_CIE_ID_64 = 0xffffffffffffffffULL /* In 64-bit format CIE header.  */
+  };
+
+
+/* Information for GNU unwind information.  */
+enum
+  {
+    DW_EH_PE_absptr = 0x00,
+    DW_EH_PE_omit = 0xff,
+
+    /* FDE data encoding.  */
+    DW_EH_PE_uleb128 = 0x01,
+    DW_EH_PE_udata2 = 0x02,
+    DW_EH_PE_udata4 = 0x03,
+    DW_EH_PE_udata8 = 0x04,
+    DW_EH_PE_sleb128 = 0x09,
+    DW_EH_PE_sdata2 = 0x0a,
+    DW_EH_PE_sdata4 = 0x0b,
+    DW_EH_PE_sdata8 = 0x0c,
+    DW_EH_PE_signed = 0x08,
+
+    /* FDE flags.  */
+    DW_EH_PE_pcrel = 0x10,
+    DW_EH_PE_textrel = 0x20,
+    DW_EH_PE_datarel = 0x30,
+    DW_EH_PE_funcrel = 0x40,
+    DW_EH_PE_aligned = 0x50,
+
+    DW_EH_PE_indirect = 0x80
+  };
+
+
+/* DWARF XXX.  */
+#define DW_ADDR_none	0
+
+/* Section 7.2.2 of the DWARF3 specification defines a range of escape
+   codes that can appear in the length field of certain DWARF structures.
+
+   These defines enumerate the minimum and maximum values of this range.
+   Currently only the maximum value is used (to indicate that 64-bit
+   values are going to be used in the dwarf data that accompanies the
+   structure).  The other values are reserved.
+
+   Note: There is a typo in DWARF3 spec (published Dec 20, 2005).  In
+   sections 7.4, 7.5.1, 7.19, 7.20 the minimum escape code is referred to
+   as 0xffffff00 whereas in fact it should be 0xfffffff0.  */
+#define DWARF3_LENGTH_MIN_ESCAPE_CODE 0xfffffff0u
+#define DWARF3_LENGTH_MAX_ESCAPE_CODE 0xffffffffu
+#define DWARF3_LENGTH_64_BIT          DWARF3_LENGTH_MAX_ESCAPE_CODE
+
+#endif	/* dwarf.h */
diff --git a/elf.h b/elf.h
index 65a1dac1c..14cfdcfff 100644
--- a/elf.h
+++ b/elf.h
@@ -159,7 +159,12 @@ typedef struct
 #define ELFOSABI_TRU64		10	/* Compaq TRU64 UNIX.  */
 #define ELFOSABI_MODESTO	11	/* Novell Modesto.  */
 #define ELFOSABI_OPENBSD	12	/* OpenBSD.  */
-#define ELFOSABI_ARM_AEABI	64	/* ARM EABI */
+#define ELFOSABI_OPENVMS        13
+#define ELFOSABI_NSK            14      /* Hewlett-Packard Non-Stop Kernel.  */
+#define ELFOSABI_AROS           15      /* Amiga Research OS.  */
+#define ELFOSABI_FENIXOS        16      /* FenixOS.  */
+#define ELFOSABI_ARM_AEABI	64	/* ARM EABI.  */
+#define ELFOSABI_C6000_LINUX    65      /* Linux TMS320C6000.  */
 #define ELFOSABI_ARM		97	/* ARM */
 #define ELFOSABI_STANDALONE	255	/* Standalone (embedded) application */
 
@@ -820,6 +825,7 @@ typedef struct
 #define	DF_1_SYMINTPOSE	0x00800000	/* Object has individual interposers.  */
 #define	DF_1_GLOBAUDIT	0x01000000	/* Global auditing required.  */
 #define	DF_1_SINGLETON	0x02000000	/* Singleton symbols are used.  */
+#define	DF_1_PIE	0x08000000
 
 /* Flags for the feature selection in DT_FEATURE_1.  */
 #define DTF_1_PARINIT	0x00000001
diff --git a/i386-asm.c b/i386-asm.c
index aca6c97eb..3cc8d18b8 100644
--- a/i386-asm.c
+++ b/i386-asm.c
@@ -40,6 +40,8 @@
 #define OPC_ARITH      0x30 /* arithmetic opcodes */
 #define OPC_FARITH     0x40 /* FPU arithmetic opcodes */
 #define OPC_TEST       0x50 /* test opcodes */
+#define OPC_0F01       0x60 /* 0x0f01XX (group 7, XX is 2nd opcode,
+                               no operands and unstructured mod/rm) */
 #define OPCT_IS(v,i) (((v) & OPCT_MASK) == (i))
 
 #define OPC_0F        0x100 /* Is secondary map (0x0f prefix) */
@@ -682,7 +684,7 @@ static void maybe_print_stats (void)
 ST_FUNC void asm_opcode(TCCState *s1, int opcode)
 {
     const ASMInstr *pa;
-    int i, modrm_index, modreg_index, reg, v, op1, seg_prefix, pc;
+    int i, modrm_index, modreg_index, reg, v, op1, seg_prefix, pc, p;
     int nb_ops, s;
     Operand ops[MAX_OPERANDS], *pop;
     int op_type[3]; /* decoded op type */
@@ -833,6 +835,7 @@ ST_FUNC void asm_opcode(TCCState *s1, int opcode)
                 goto next;
 	    alltypes |= ops[i].type;
         }
+        (void)alltypes; /* maybe unused */
         /* all is matching ! */
         break;
     next: ;
@@ -890,30 +893,6 @@ ST_FUNC void asm_opcode(TCCState *s1, int opcode)
         }
     }
 
-#ifdef TCC_TARGET_X86_64
-    /* Generate addr32 prefix if needed */
-    for(i = 0; i < nb_ops; i++) {
-        if (ops[i].type & OP_EA32) {
-	    g(0x67);
-	    break;
-        }
-    }
-#endif
-    /* generate data16 prefix if needed */
-    p66 = 0;
-    if (s == 1)
-        p66 = 1;
-    else {
-	/* accepting mmx+sse in all operands --> needs 0x66 to
-	   switch to sse mode.  Accepting only sse in an operand --> is
-	   already SSE insn and needs 0x66/f2/f3 handling.  */
-        for (i = 0; i < nb_ops; i++)
-            if ((op_type[i] & (OP_MMX | OP_SSE)) == (OP_MMX | OP_SSE)
-	        && ops[i].type & OP_SSE)
-	        p66 = 1;
-    }
-    if (p66)
-        g(0x66);
 #ifdef TCC_TARGET_X86_64
     rex64 = 0;
     if (pa->instr_type & OPC_48)
@@ -946,8 +925,45 @@ ST_FUNC void asm_opcode(TCCState *s1, int opcode)
         g(0x9b);
     if (seg_prefix)
         g(seg_prefix);
+#ifdef TCC_TARGET_X86_64
+    /* Generate addr32 prefix if needed */
+    for(i = 0; i < nb_ops; i++) {
+        if (ops[i].type & OP_EA32) {
+	    g(0x67);
+	    break;
+        }
+    }
+#endif
+    /* generate data16 prefix if needed */
+    p66 = 0;
+    if (s == 1)
+        p66 = 1;
+    else {
+	/* accepting mmx+sse in all operands --> needs 0x66 to
+	   switch to sse mode.  Accepting only sse in an operand --> is
+	   already SSE insn and needs 0x66/f2/f3 handling.  */
+        for (i = 0; i < nb_ops; i++)
+            if ((op_type[i] & (OP_MMX | OP_SSE)) == (OP_MMX | OP_SSE)
+	        && ops[i].type & OP_SSE)
+	        p66 = 1;
+    }
+    if (p66)
+        g(0x66);
 
     v = pa->opcode;
+    p = v >> 8;  /* possibly prefix byte(s) */
+    switch (p) {
+        case 0: break;  /* no prefix */
+        case 0x48: break; /* REX, handled elsewhere */
+        case 0x66:
+        case 0x67:
+        case 0xf2:
+        case 0xf3: v = v & 0xff; g(p); break;
+        case 0xd4: case 0xd5: break; /* aam and aad, not prefix, but hardcoded immediate argument "10" */
+        case 0xd8: case 0xd9: case 0xda: case 0xdb: /* x87, no normal prefix */
+        case 0xdc: case 0xdd: case 0xde: case 0xdf: break;
+        default: tcc_error("bad prefix 0x%2x in opcode table", p); break;
+    }
     if (pa->instr_type & OPC_0F)
         v = ((v & ~0xff) << 8) | 0x0f00 | (v & 0xff);
     if ((v == 0x69 || v == 0x6b) && nb_ops == 2) {
@@ -1058,6 +1074,8 @@ ST_FUNC void asm_opcode(TCCState *s1, int opcode)
     }
     if (OPCT_IS(pa->instr_type, OPC_TEST))
         v += test_bits[opcode - pa->sym];
+    else if (OPCT_IS(pa->instr_type, OPC_0F01))
+        v |= 0x0f0100;
     op1 = v >> 16;
     if (op1)
         g(op1);
diff --git a/i386-asm.h b/i386-asm.h
index dfc51837a..0f99b286c 100644
--- a/i386-asm.h
+++ b/i386-asm.h
@@ -73,6 +73,11 @@ ALT(DEF_ASM_OP2(btrw, 0x0fba, 6, OPC_MODRM | OPC_WLX, OPT_IM8, OPT_REGW | OPT_EA
 ALT(DEF_ASM_OP2(btcw, 0x0fbb, 0, OPC_MODRM | OPC_WLX, OPT_REGW, OPT_REGW | OPT_EA))
 ALT(DEF_ASM_OP2(btcw, 0x0fba, 7, OPC_MODRM | OPC_WLX, OPT_IM8, OPT_REGW | OPT_EA))
 
+ALT(DEF_ASM_OP2(popcntw, 0xf30fb8, 0, OPC_MODRM | OPC_WLX, OPT_REGW | OPT_EA, OPT_REGW))
+
+ALT(DEF_ASM_OP2(tzcntw, 0xf30fbc, 0, OPC_MODRM | OPC_WLX, OPT_REGW | OPT_EA, OPT_REGW))
+ALT(DEF_ASM_OP2(lzcntw, 0xf30fbd, 0, OPC_MODRM | OPC_WLX, OPT_REGW | OPT_EA, OPT_REGW))
+
      /* prefixes */
      DEF_ASM_OP0(wait, 0x9b)
      DEF_ASM_OP0(fwait, 0x9b)
diff --git a/i386-gen.c b/i386-gen.c
index 8c245ada3..7aebc5cd8 100644
--- a/i386-gen.c
+++ b/i386-gen.c
@@ -31,10 +31,10 @@
 #define RC_INT     0x0001 /* generic integer register */
 #define RC_FLOAT   0x0002 /* generic float register */
 #define RC_EAX     0x0004
-#define RC_ST0     0x0008 
+#define RC_EDX     0x0008
 #define RC_ECX     0x0010
-#define RC_EDX     0x0020
-#define RC_EBX     0x0040
+#define RC_EBX     0x0020
+#define RC_ST0     0x0040
 
 #define RC_IRET    RC_EAX /* function return: integer register */
 #define RC_IRE2    RC_EDX /* function return: second integer register */
@@ -380,14 +380,15 @@ static const uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
 ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int *regsize)
 {
 #if defined(TCC_TARGET_PE) || TARGETOS_FreeBSD || TARGETOS_OpenBSD
-    int size, align;
+    int size, align, nregs;
     *ret_align = 1; // Never have to re-align return values for x86
     *regsize = 4;
     size = type_size(vt, &align);
     if (size > 8 || (size & (size - 1)))
         return 0;
+    nregs = 1;
     if (size == 8)
-        ret->t = VT_LLONG;
+        ret->t = VT_INT, nregs = 2;
     else if (size == 4)
         ret->t = VT_INT;
     else if (size == 2)
@@ -395,7 +396,7 @@ ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int
     else
         ret->t = VT_BYTE;
     ret->ref = NULL;
-    return 1;
+    return nregs;
 #else
     *ret_align = 1; // Never have to re-align return values for x86
     return 0;
@@ -1071,7 +1072,7 @@ static void gen_bounds_epilog(void)
     *bounds_ptr = 0;
 
     sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
-                           func_bound_offset, lbounds_section->data_offset);
+                           func_bound_offset, PTR_SIZE);
 
     /* generate bound local allocation */
     if (offset_modified) {
diff --git a/i386-link.c b/i386-link.c
index a7969f074..2fb14637b 100644
--- a/i386-link.c
+++ b/i386-link.c
@@ -22,7 +22,7 @@
 
 #include "tcc.h"
 
-#ifndef ELF_OBJ_ONLY
+#ifdef NEED_RELOC_TYPE
 /* Returns 1 for a code relocation, 0 for a data relocation. For unknown
    relocations, returns -1. */
 int code_reloc (int reloc_type)
@@ -91,6 +91,7 @@ int gotplt_entry_type (int reloc_type)
     return -1;
 }
 
+#ifdef NEED_BUILD_GOT
 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
 {
     Section *plt = s1->plt;
@@ -99,7 +100,7 @@ ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_
     unsigned plt_offset, relofs;
 
     /* on i386 if we build a DLL, we add a %ebx offset */
-    if (s1->output_type == TCC_OUTPUT_DLL)
+    if (s1->output_type & TCC_OUTPUT_DYN)
         modrm = 0xa3;
     else
         modrm = 0x25;
@@ -147,7 +148,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
     p = s1->plt->data;
     p_end = p + s1->plt->data_offset;
 
-    if (s1->output_type != TCC_OUTPUT_DLL && p < p_end) {
+    if (!(s1->output_type & TCC_OUTPUT_DYN) && p < p_end) {
         add32le(p + 2, s1->got->sh_addr);
         add32le(p + 8, s1->got->sh_addr);
         p += 16;
@@ -168,6 +169,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
     }
 }
 #endif
+#endif
 
 void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t addr, addr_t val)
 {
@@ -177,7 +179,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
 
     switch (type) {
         case R_386_32:
-            if (s1->output_type == TCC_OUTPUT_DLL) {
+            if (s1->output_type & TCC_OUTPUT_DYN) {
                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
                 qrel->r_offset = rel->r_offset;
                 if (esym_index) {
@@ -225,7 +227,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
         case R_386_16:
             if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {
             output_file:
-                tcc_error("can only produce 16-bit binary files");
+                tcc_error_noabort("can only produce 16-bit binary files");
             }
             write16le(ptr, read16le(ptr) + val);
             return;
@@ -272,7 +274,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                     add32le(ptr + 5, -x);
                 }
                 else
-                    tcc_error("unexpected R_386_TLS_GD pattern");
+                    tcc_error_noabort("unexpected R_386_TLS_GD pattern");
             }
             return;
         case R_386_TLS_LDM:
@@ -295,7 +297,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                     rel[1].r_info = ELFW(R_INFO)(0, R_386_NONE);
                 }
                 else
-                    tcc_error("unexpected R_386_TLS_LDM pattern");
+                    tcc_error_noabort("unexpected R_386_TLS_LDM pattern");
             }
             return;
         case R_386_TLS_LDO_32:
diff --git a/i386-tok.h b/i386-tok.h
index e3ef2c75c..290710591 100644
--- a/i386-tok.h
+++ b/i386-tok.h
@@ -268,6 +268,9 @@
  DEF_WLX(bts)
  DEF_WLX(btr)
  DEF_WLX(btc)
+ DEF_WLX(popcnt)
+ DEF_WLX(tzcnt)
+ DEF_WLX(lzcnt)
 
  DEF_WLX(lar)
  DEF_WLX(lsl)
diff --git a/include/stdatomic.h b/include/stdatomic.h
index f00c62f09..2d423d1a9 100644
--- a/include/stdatomic.h
+++ b/include/stdatomic.h
@@ -14,6 +14,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
 
 #define __ATOMIC_RELAXED 0
 #define __ATOMIC_CONSUME 1
@@ -77,42 +78,65 @@ typedef struct {
 } atomic_flag;
 
 #define ATOMIC_FLAG_INIT {0}
+#define ATOMIC_VAR_INIT(value) (value)
 
-#define atomic_flag_test_and_set(object) \
-    __atomic_exchange(&(object)->value, 1, __ATOMIC_SEQ_CST)
-#define atomic_flag_test_and_set_explicit(object, order) \
-    __atomic_exchange(&(object)->value, 1, order)
+#define atomic_flag_test_and_set_explicit(object, order)                  \
+    __atomic_test_and_set((void *)(&((object)->value)), order)
+#define atomic_flag_test_and_set(object)                                  \
+    atomic_flag_test_and_set_explicit(object, __ATOMIC_SEQ_CST)
 
+#define atomic_flag_clear_explicit(object, order)                         \
+    __atomic_clear((bool *)(&((object)->value)), order)
 #define atomic_flag_clear(object) \
-    __atomic_store(&(object)->value, 0, __ATOMIC_SEQ_CST)
-#define atomic_flag_clear_explicit(object, order) \
-    __atomic_store(&(object)->value, 0, order)
+    atomic_flag_clear_explicit(object, __ATOMIC_SEQ_CST)
 
 /* Generic routines */
-#define atomic_init(object, desired) \
-    __atomic_store(object, desired, __ATOMIC_RELAXED)
+#define atomic_init(object, desired)                                      \
+    atomic_store_explicit(object, desired, __ATOMIC_RELAXED)
+
+#define atomic_store_explicit(object, desired, order)                     \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp = (desired);                                 \
+       __atomic_store (ptr, &tmp, (order));                               \
+    })
+#define atomic_store(object, desired)                                     \
+     atomic_store_explicit (object, desired, __ATOMIC_SEQ_CST)
+
+#define atomic_load_explicit(object, order)                               \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp;                                             \
+       __atomic_load (ptr, &tmp, (order));                                \
+       tmp;                                                               \
+    })
+#define atomic_load(object) atomic_load_explicit (object, __ATOMIC_SEQ_CST)
+
+#define atomic_exchange_explicit(object, desired, order)                  \
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) val = (desired);                                 \
+       __typeof__ (*ptr) tmp;                                             \
+       __atomic_exchange (ptr, &val, &tmp, (order));                      \
+       tmp;                                                               \
+    })
+#define atomic_exchange(object, desired)                                  \
+  atomic_exchange_explicit (object, desired, __ATOMIC_SEQ_CST)
 
-#define atomic_store(object, desired) \
-    __atomic_store(object, desired, __ATOMIC_SEQ_CST)
-#define atomic_store_explicit __atomic_store
-
-#define atomic_load(object) \
-    __atomic_load(object, __ATOMIC_SEQ_CST)
-#define atomic_load_explicit __atomic_load
-
-#define atomic_exchange(object, desired) \
-    __atomic_exchange(object, desired, __ATOMIC_SEQ_CST)
-#define atomic_exchange_explicit __atomic_exchange
-
-#define atomic_compare_exchange_strong(object, expected, desired) \
-    __atomic_compare_exchange(object, expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
 #define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
-    __atomic_compare_exchange(object, expected, desired, 0, success, failure)
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp = desired;                                   \
+       __atomic_compare_exchange(ptr, expected, &tmp, 0, success, failure); \
+    })
+#define atomic_compare_exchange_strong(object, expected, desired)         \
+    atomic_compare_exchange_strong_explicit (object, expected, desired,   \
+                                             __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
 
-#define atomic_compare_exchange_weak(object, expected, desired) \
-    __atomic_compare_exchange(object, expected, desired, 1, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
 #define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
-    __atomic_compare_exchange(object, expected, desired, 1, success, failure)
+    ({ __typeof__ (object) ptr = (object);                                \
+       __typeof__ (*ptr) tmp = desired;                                   \
+       __atomic_compare_exchange(ptr, expected, &tmp, 1, success, failure); \
+    })
+#define atomic_compare_exchange_weak(object, expected, desired)           \
+    atomic_compare_exchange_weak_explicit (object, expected, desired,     \
+                                           __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
 
 #define atomic_fetch_add(object, operand) \
     __atomic_fetch_add(object, operand, __ATOMIC_SEQ_CST)
@@ -134,4 +158,16 @@ typedef struct {
     __atomic_fetch_and(object, operand, __ATOMIC_SEQ_CST)
 #define atomic_fetch_and_explicit __atomic_fetch_and
 
+extern void atomic_thread_fence (memory_order);
+extern void __atomic_thread_fence (memory_order);
+#define atomic_thread_fence(order) __atomic_thread_fence (order)
+extern void atomic_signal_fence (memory_order);
+extern void __atomic_signal_fence (memory_order);
+#define atomic_signal_fence(order) __atomic_signal_fence  (order)
+extern bool __atomic_is_lock_free(size_t size, void *ptr);
+#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))
+
+extern bool __atomic_test_and_set (void *, memory_order);
+extern void __atomic_clear (bool *, memory_order);
+
 #endif /* _STDATOMIC_H */
diff --git a/include/tccdefs.h b/include/tccdefs.h
index 83e3c3880..8c173f007 100644
--- a/include/tccdefs.h
+++ b/include/tccdefs.h
@@ -18,7 +18,7 @@
 
 #if __SIZEOF_POINTER__ == 4
     /* 32bit systems. */
-#if defined TARGETOS_OpenBSD
+#if defined  __OpenBSD__
     #define __SIZE_TYPE__ unsigned long
     #define __PTRDIFF_TYPE__ long
 #else
@@ -68,7 +68,7 @@
     #define __WINT_TYPE__ int
 #endif
 
-    #if __STDC_VERSION__ == 201112L
+    #if __STDC_VERSION__ >= 201112L
     # define __STDC_NO_ATOMICS__ 1
     # define __STDC_NO_COMPLEX__ 1
     # define __STDC_NO_THREADS__ 1
@@ -124,6 +124,15 @@
     /* avoids usage of GCC/clang specific builtins in libc-headerfiles: */
     #define __FINITE_MATH_ONLY__ 1
     #define _FORTIFY_SOURCE 0
+    #define __has_builtin(x) 0
+
+#elif defined __ANDROID__
+    #define  BIONIC_IOCTL_NO_SIGNEDNESS_OVERLOAD
+    #define  __PRETTY_FUNCTION__ __FUNCTION__
+    #define __has_builtin(x) 0
+    #define __has_feature(x) 0
+    #define _Nonnull
+    #define _Nullable
 
 #else
     /* Linux */
@@ -137,9 +146,10 @@
     #define __INT32_TYPE__ int
 
 #if !defined _WIN32
-    /* glibc defines */
+    /* glibc defines. We do not support __USER_NAME_PREFIX__ */
     #define __REDIRECT(name, proto, alias) name proto __asm__ (#alias)
     #define __REDIRECT_NTH(name, proto, alias) name proto __asm__ (#alias) __THROW
+    #define __REDIRECT_NTHNL(name, proto, alias) name proto __asm__ (#alias) __THROWNL
 #endif
 
     /* skip __builtin... with -E */
@@ -153,7 +163,7 @@
     #define __builtin_huge_valf() 1e50f
     #define __builtin_huge_vall() 1e5000L
 # if defined __APPLE__
-    #define __builtin_nanf(ignored_string) __nan()
+    #define __builtin_nanf(ignored_string) (0.0F/0.0F)
     /* used by floats.h to implement FLT_ROUNDS C99 macro. 1 == to nearest */
     #define __builtin_flt_rounds() 1
     /* used by _fd_def.h */
@@ -200,11 +210,18 @@
                            &~3), *(type *)(ap - ((sizeof(type)+3)&~3)))
 
 #elif defined __aarch64__
+#if defined __APPLE__
+    typedef struct {
+        void *__stack;
+    } __builtin_va_list;
+
+#else
     typedef struct {
         void *__stack, *__gr_top, *__vr_top;
         int   __gr_offs, __vr_offs;
     } __builtin_va_list;
 
+#endif
 #elif defined __riscv
     typedef char *__builtin_va_list;
     #define __va_reg_size (__riscv_xlen >> 3)
@@ -230,7 +247,7 @@
     # define __RENAME(X) __asm__(X)
     #endif
 
-    #ifdef __BOUNDS_CHECKING_ON
+    #ifdef __TCC_BCHECK__
     # define __BUILTINBC(ret,name,params) ret __builtin_##name params __RENAME("__bound_"#name);
     # define __BOUND(ret,name,params) ret name params __RENAME("__bound_"#name);
     #else
@@ -255,7 +272,9 @@
     __BOTH(int, strcmp, (const char*, const char*))
     __BOTH(int, strncmp, (const char*, const char*, __SIZE_TYPE__))
     __BOTH(char*, strcat, (char*, const char*))
+    __BOTH(char*, strncat, (char*, const char*, __SIZE_TYPE__))
     __BOTH(char*, strchr, (const char*, int))
+    __BOTH(char*, strrchr, (const char*, int))
     __BOTH(char*, strdup, (const char*))
 #if defined __ARM_EABI__
     __BOUND(void*,__aeabi_memcpy,(void*,const void*,__SIZE_TYPE__))
@@ -293,4 +312,16 @@
     #undef __MAYBE_REDIR
     #undef __RENAME
 
+    #define __BUILTIN_EXTERN(name,u) 		\
+        int __builtin_##name(u int);		\
+        int __builtin_##name##l(u long);	\
+        int __builtin_##name##ll(u long long);
+    __BUILTIN_EXTERN(ffs,)
+    __BUILTIN_EXTERN(clz, unsigned)
+    __BUILTIN_EXTERN(ctz, unsigned)
+    __BUILTIN_EXTERN(clrsb,)
+    __BUILTIN_EXTERN(popcount, unsigned)
+    __BUILTIN_EXTERN(parity, unsigned)
+    #undef __BUILTIN_EXTERN
+
     #endif /* ndef __TCC_PP__ */
diff --git a/lib/Makefile b/lib/Makefile
index 43942fc62..eba3a6b47 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -14,6 +14,7 @@ XAR = $(XTCC) -ar
 XFLAGS-unx = -B$(TOPSRC)
 XFLAGS-win = -B$(TOPSRC)/win32 -I$(TOPSRC)/include
 XFLAGS = $(XFLAGS$(XCFG)) -I$(TOP)
+BFLAGS = -bt
 XCFG = $(or $(findstring -win,$T),-unx)
 S = $(if $(findstring yes,$(SILENT)),@$(info * $@))
 
@@ -27,7 +28,8 @@ arm-libtcc1-usegcc ?= no
 ifeq "$($(T)-libtcc1-usegcc)" "yes"
  XCC = $(CC)
  XAR = $(AR)
- XFLAGS = $(CFLAGS) -fPIC -gstabs -fno-omit-frame-pointer -Wno-unused-function -Wno-unused-variable
+ XFLAGS = $(CFLAGS) -fPIC -gdwarf -fno-omit-frame-pointer -Wno-unused-function -Wno-unused-variable
+ BFLAGS = -g
 endif
 
 ifneq ($(CONFIG_backtrace),no)
@@ -42,11 +44,11 @@ $(X)BT_O += tcov.o
 
 DSO_O = dsohandle.o
 
-I386_O = libtcc1.o alloca.o alloca-bt.o $(BT_O) stdatomic.o
-X86_64_O = libtcc1.o alloca.o alloca-bt.o $(BT_O) stdatomic.o
-ARM_O = libtcc1.o armeabi.o alloca.o armflush.o fetch_and_add.o $(BT_O)
-ARM64_O = lib-arm64.o fetch_and_add.o $(BT_O)
-RISCV64_O = lib-arm64.o fetch_and_add.o $(BT_O)
+I386_O = libtcc1.o alloca.o alloca-bt.o stdatomic.o atomic.o builtin.o $(BT_O)
+X86_64_O = libtcc1.o alloca.o alloca-bt.o stdatomic.o atomic.o builtin.o $(BT_O)
+ARM_O = libtcc1.o armeabi.o alloca.o armflush.o stdatomic.o atomic.o builtin.o $(BT_O)
+ARM64_O = lib-arm64.o stdatomic.o atomic.o builtin.o $(BT_O)
+RISCV64_O = lib-arm64.o stdatomic.o atomic.o builtin.o $(BT_O)
 WIN_O = crt1.o crt1w.o wincrt1.o wincrt1w.o dllcrt1.o dllmain.o
 
 OBJ-i386 = $(I386_O) $(BCHECK_O) $(DSO_O)
@@ -55,7 +57,7 @@ OBJ-x86_64-osx = $(X86_64_O) va_list.o $(BCHECK_O)
 OBJ-i386-win32 = $(I386_O) chkstk.o $(B_O) $(WIN_O)
 OBJ-x86_64-win32 = $(X86_64_O) chkstk.o $(B_O) $(WIN_O)
 OBJ-arm64 = $(ARM64_O) $(BCHECK_O) $(DSO_O)
-OBJ-arm64-osx = $(ARM64_O) va_list.o
+OBJ-arm64-osx = $(ARM64_O) $(BCHECK_O)
 OBJ-arm = $(ARM_O) $(BCHECK_O) $(DSO_O)
 OBJ-arm-fpa = $(ARM_O) $(DSO_O)
 OBJ-arm-fpa-ld = $(ARM_O) $(DSO_O)
@@ -84,7 +86,7 @@ $(X)%.o : %.S
 $(TOP)/%.o : %.c
 	$S$(XCC) -c $< -o $@ $(XFLAGS)
 
-$(TOP)/bcheck.o : XFLAGS += -g $(if $(CONFIG_musl),-DTCC_MUSL)
+$(TOP)/bcheck.o : XFLAGS += $(BFLAGS) $(if $(CONFIG_musl),-DTCC_MUSL)
 $(TOP)/bt-exe.o : $(TOP)/tccrun.c
 
 $(X)crt1w.o : crt1.c
diff --git a/lib/armeabi.c b/lib/armeabi.c
index 1bccbd3b4..6ade65ef1 100644
--- a/lib/armeabi.c
+++ b/lib/armeabi.c
@@ -137,6 +137,11 @@ void __aeabi_ ## name(double_unsigned_struct val)                            \
     int exp, high_shift, sign;                                               \
     double_unsigned_struct ret;                                              \
                                                                              \
+    if ((val.high & ~0x80000000) == 0 && val.low == 0) {                     \
+        ret.low = ret.high = 0;                                              \
+        goto _ret_;                                                          \
+    }                                                                        \
+                                                                             \
     /* compute sign */                                                       \
     sign = val.high >> 31;                                                   \
                                                                              \
@@ -190,6 +195,7 @@ void __aeabi_ ## name(double_unsigned_struct val)                            \
             ret.low++;                                                       \
     }                                                                        \
                                                                              \
+_ret_:                                                                       \
     double_unsigned_struct_return(ret);                                      \
 }
 
@@ -313,7 +319,7 @@ void __aeabi_ ## name(unsigned long long v)                             \
             }                                                           \
         } else {                                                        \
             ret.high = ret.low = 0;                                     \
-            double_unsigned_struct_return(ret);                         \
+            goto _ret_;                                                 \
         }                                                               \
     }                                                                   \
                                                                         \
@@ -323,6 +329,7 @@ void __aeabi_ ## name(unsigned long long v)                             \
     /* fill sign bit */                                                 \
     ret.high |= sign << 31;                                             \
                                                                         \
+_ret_:                                                                  \
     double_unsigned_struct_return(ret);                                 \
 }
 
diff --git a/lib/atomic.S b/lib/atomic.S
new file mode 100644
index 000000000..29fdbee14
--- /dev/null
+++ b/lib/atomic.S
@@ -0,0 +1,858 @@
+/* ---------------------------------------------- */
+/* This file implements for arm/arm64/riscv:
+ * __atomic_compare_exchange_1
+ * __atomic_compare_exchange_2
+ * __atomic_compare_exchange_4
+ * __atomic_compare_exchange_8
+ */
+
+#ifdef __leading_underscore
+# define _(s) _##s
+#else
+# define _(s) s
+#endif
+
+#if defined __i386__
+        .text
+        .align  2
+
+        .global _(__atomic_test_and_set)
+        .type   _(__atomic_test_and_set), %function
+_(__atomic_test_and_set):
+        movl    4(%esp), %edx
+        movl    $1, %eax
+        xchgb   (%edx), %al
+        ret
+	.size   _(__atomic_test_and_set), .-_(__atomic_test_and_set)
+
+        .global _(__atomic_clear)
+        .type   _(__atomic_clear), %function
+_(__atomic_clear):
+        movl    4(%esp), %edx
+        xorl    %eax, %eax
+        xchgb   (%edx), %al
+        ret
+	.size   _(__atomic_clear), .-_(__atomic_clear)
+
+#elif defined __x86_64__
+        .text
+        .align  2
+
+        .global _(__atomic_test_and_set)
+        .type   _(__atomic_test_and_set), %function
+_(__atomic_test_and_set):
+        movl    $1, %eax
+        xchgb   (%rdi), %al
+        ret
+	.size   _(__atomic_test_and_set), .-_(__atomic_test_and_set)
+
+        .global _(__atomic_clear)
+        .type   _(__atomic_clear), %function
+_(__atomic_clear):
+        xorl    %eax, %eax
+        xchgb   (%rdi), %al
+        ret
+	.size   _(__atomic_clear), .-_(__atomic_clear)
+
+#elif defined __arm__
+
+#ifndef __TINYC__
+	.arch armv6k
+	.syntax unified
+#endif
+        .text
+        .align  2
+
+        .global _(fetch_and_add_arm)
+        .type   _(fetch_and_add_arm), %function
+_(fetch_and_add_arm):
+        mcr     p15, #0, r0, c7, c10, #5
+.L0:
+        ldrex   r3, [r0]
+        add     r3, r3, r1
+        strex   r2, r3, [r0]
+        cmp     r2, #0
+        bne     .L0
+        mcr     p15, #0, r0, c7, c10, #5
+        bx      lr
+        .size   _(fetch_and_add_arm), .-_(fetch_and_add_arm)
+
+        .global _(__atomic_test_and_set)
+        .type   _(__atomic_test_and_set), %function
+_(__atomic_test_and_set):
+#ifdef __TINYC__
+	.int	0xe92d4030
+	.int	0xee070fba
+	.int	0xe5d03000
+	.int	0xe24dd014
+	.int	0xe1a05000
+	.int	0xe2533000
+	.int	0xe1a04001
+	.int	0x13a03001
+	.int	0xee070fba
+	.int	0xe5cd300f
+	.int	0xe3a03001
+	.int	0xe1a02003
+	.int	0xe28d100f
+	.int	0xe1a00005
+	.int	0xe58d4004
+	.int	0xe58d4000
+	.int	0xeb000009
+	.int	0xe3500000
+	.int	0x0afffff6
+	.int	0xe5dd000f
+	.int	0xe28dd014
+	.int	0xe8bd8030
+#else
+        push    {r4, r5, lr}
+        mcr     p15, 0, r0, c7, c10, 5
+        ldrb    r3, [r0]
+        sub     sp, sp, #20
+        mov     r5, r0
+        subs    r3, r3, #0
+        mov     r4, r1
+        movne   r3, #1
+        mcr     p15, 0, r0, c7, c10, 5
+        strb    r3, [sp, #15]
+.L20:
+        mov     r3, #1
+        mov     r2, r3
+        add     r1, sp, #15
+        mov     r0, r5
+        str     r4, [sp, #4]
+        str     r4, [sp]
+        bl      __atomic_compare_exchange_1
+        cmp     r0, #0
+        beq     .L20
+        ldrb    r0, [sp, #15]
+        add     sp, sp, #20
+        pop     {r4, r5, pc}
+#endif
+	.size   _(__atomic_test_and_set), .-_(__atomic_test_and_set)
+
+        .global _(__atomic_clear)
+        .type   _(__atomic_clear), %function
+_(__atomic_clear):
+#ifdef __TINYC__
+	.int	0xe3a03000
+	.int	0xee070fba
+	.int	0xe5c03000
+	.int	0xee070fba
+	.int	0xe12fff1e
+#else
+         mov     r3, #0
+         mcr     p15, 0, r0, c7, c10, 5
+         strb    r3, [r0]
+         mcr     p15, 0, r0, c7, c10, 5
+         bx      lr
+#endif
+	.size   _(__atomic_clear), .-_(__atomic_clear)
+
+        .global _(__atomic_compare_exchange_1)
+        .type   _(__atomic_compare_exchange_1), %function
+_(__atomic_compare_exchange_1):
+#ifdef __TINYC__
+	.int	0xe52de004
+	.int	0xe5d13000
+	.int	0xf57ff05b
+	.int	0xe1d0cf9f
+	.int	0xe15c0003
+	.int	0x1a000002
+	.int	0xe1c0ef92
+	.int	0xe35e0000
+	.int	0x1afffff9
+	.int	0x03a00001
+	.int	0x13a00000
+	.int	0xf57ff05b
+	.int	0x15c1c000
+	.int	0xe49df004
+#else
+        str     lr, [sp, #-4]!
+        ldrb    r3, [r1]
+        mcr     p15, 0, r0, c7, c10, 5
+.L1:
+        ldrexb  ip, [r0]
+        cmp     ip, r3
+        bne     .L2
+        strexb  lr, r2, [r0]
+        cmp     lr, #0
+        bne     .L1
+.L2:
+        mcr     p15, 0, r0, c7, c10, 5
+        moveq   r0, #1
+        movne   r0, #0
+        strbne  ip, [r1]
+        ldr     pc, [sp], #4
+#endif
+	.size   _(__atomic_compare_exchange_1), .-_(__atomic_compare_exchange_1)
+
+        .global _(__atomic_compare_exchange_2)
+        .type   _(__atomic_compare_exchange_2), %function
+_(__atomic_compare_exchange_2):
+#ifdef __TINYC__
+	.int	0xe52de004
+	.int	0xe1d130b0
+	.int	0xf57ff05b
+	.int	0xe1f0cf9f
+	.int	0xe15c0003
+	.int	0x1a000002
+	.int	0xe1e0ef92
+	.int	0xe35e0000
+	.int	0x1afffff9
+	.int	0x03a00001
+	.int	0x13a00000
+	.int	0xf57ff05b
+	.int	0x11c1c0b0
+	.int	0xe49df004
+#else
+        str     lr, [sp, #-4]!
+        ldrh    r3, [r1]
+        mcr     p15, 0, r0, c7, c10, 5
+.L3:
+        ldrexh  ip, [r0]
+        cmp     ip, r3
+        bne     .L4
+        strexh  lr, r2, [r0]
+        cmp     lr, #0
+        bne     .L3
+.L4:
+        mcr     p15, 0, r0, c7, c10, 5
+        moveq   r0, #1
+        movne   r0, #0
+        strhne  ip, [r1]
+	ldr     pc, [sp], #4
+#endif
+	.size   _(__atomic_compare_exchange_2), .-_(__atomic_compare_exchange_2)
+
+        .global _(__atomic_compare_exchange_4)
+        .type   _(__atomic_compare_exchange_4), %function
+_(__atomic_compare_exchange_4):
+#ifdef __TINYC__
+	.int	0xe52de004
+	.int	0xe5913000
+	.int	0xf57ff05b
+	.int	0xe190cf9f
+	.int	0xe15c0003
+	.int	0x1a000002
+	.int	0xe180ef92
+	.int	0xe35e0000
+	.int	0x1afffff9
+	.int	0x03a00001
+	.int	0x13a00000
+	.int	0xf57ff05b
+	.int	0x1581c000
+	.int	0xe49df004
+#else
+        str     lr, [sp, #-4]!
+        ldr     r3, [r1]
+        mcr     p15, 0, r0, c7, c10, 5
+.L5:
+        ldrex   ip, [r0]
+        cmp     ip, r3
+        bne     .L6
+        strex   lr, r2, [r0]
+        cmp     lr, #0
+        bne     .L5
+.L6:
+        mcr     p15, 0, r0, c7, c10, 5
+        moveq   r0, #1
+        movne   r0, #0
+        strne   ip, [r1]
+        ldr     pc, [sp], #4
+#endif
+	.size   _(__atomic_compare_exchange_4), .-_(__atomic_compare_exchange_4)
+
+/* ---------------------------------------------- */
+#elif defined __aarch64__
+
+        .text
+        .align  2
+
+        .global _(fetch_and_add_arm64)
+        .type   _(fetch_and_add_arm64), %function
+_(fetch_and_add_arm64):
+#ifdef __TINYC__
+        .int 0x885f7c02
+        .int 0x0b010042
+        .int 0x8803fc02
+        .int 0x35ffffa3
+        .int 0xd5033bbf
+        .int 0xd65f03c0
+#else
+        ldxr    w2, [x0]
+        add     w2, w2, w1
+        stlxr   w3, w2, [x0]
+        cbnz    w3, _(fetch_and_add_arm64)
+        dmb     ish
+        ret
+#endif
+        .size   _(fetch_and_add_arm64), .-_(fetch_and_add_arm64)
+
+        .global _(__atomic_test_and_set)
+        .type   _(__atomic_test_and_set), %function
+_(__atomic_test_and_set):
+#ifdef __TINYC__
+	.int	0xa9bf7bfd
+	.int	0xaa0003e1
+	.int	0x52800020
+	.int	0x910003fd
+	.int	0x2a0003f0
+	.int	0x085ffc20
+	.int	0x0811fc30
+	.int	0x35ffffd1
+	.int	0xa8c17bfd
+	.int	0xd65f03c0
+#else
+         stp     x29, x30, [sp, -16]!
+         mov     x1, x0
+         mov     w0, 1
+         mov     x29, sp
+         mov     w16, w0
+.L20:
+         ldaxrb  w0, [x1]
+         stlxrb  w17, w16, [x1]
+         cbnz    w17, .L20
+         ldp     x29, x30, [sp], 16
+	 ret
+#endif
+	.size   _(__atomic_test_and_set), .-_(__atomic_test_and_set)
+
+        .global _(__atomic_clear)
+        .type   _(__atomic_clear), %function
+_(__atomic_clear):
+#ifdef __TINYC__
+	.int	0x089ffc1f
+	.int	0xd65f03c0
+#else
+         stlrb   wzr, [x0]
+        ret
+#endif
+	.size   _(__atomic_clear), .-_(__atomic_clear)
+
+        .global _(__atomic_compare_exchange_1)
+        .type   _(__atomic_compare_exchange_1), %function
+_(__atomic_compare_exchange_1):
+#ifdef __TINYC__
+	.int	0xa9be7bfd
+	.int	0x910003fd
+	.int	0xa90153f3
+	.int	0xaa0103f3
+	.int	0x12001c41
+	.int	0xaa0003e2
+	.int	0x39400274
+	.int	0x2a1403e0
+	.int	0x53001c10
+	.int	0x085ffc40
+	.int	0x6b10001f
+	.int	0x54000061
+	.int	0x0811fc41
+	.int	0x35ffff91
+	.int	0x6b34001f
+	.int	0x1a9f17e1
+	.int	0x54000040
+	.int	0x39000260
+	.int	0x2a0103e0
+	.int	0xa94153f3
+	.int	0xa8c27bfd
+	.int	0xd65f03c0
+#else
+        stp     x29, x30, [sp, -32]!
+        mov     x29, sp
+        stp     x19, x20, [sp, 16]
+        mov     x19, x1
+        and     w1, w2, 255
+        mov     x2, x0
+        ldrb    w20, [x19]
+        mov     w0, w20
+	uxtb    w16, w0
+.L1:
+	ldaxrb  w0, [x2]
+	cmp     w0, w16
+	b.ne    .L2
+	stlxrb  w17, w1, [x2]
+	cbnz    w17, .L1
+.L2:
+        cmp     w0, w20, uxtb
+        cset    w1, eq
+        beq     .L3
+        strb    w0, [x19]
+.L3:
+        mov     w0, w1
+        ldp     x19, x20, [sp, 16]
+        ldp     x29, x30, [sp], 32
+        ret
+#endif
+        .size   _(__atomic_compare_exchange_1), .-_(__atomic_compare_exchange_1)
+
+        .global _(__atomic_compare_exchange_2)
+        .type   _(__atomic_compare_exchange_2), %function
+_(__atomic_compare_exchange_2):
+#ifdef __TINYC__
+	.int	0xa9be7bfd
+	.int	0x910003fd
+	.int	0xa90153f3
+	.int	0xaa0103f3
+	.int	0x12003c41
+	.int	0xaa0003e2
+	.int	0x79400274
+	.int	0x2a1403e0
+	.int	0x53003c10
+	.int	0x485ffc40
+	.int	0x6b10001f
+	.int	0x54000061
+	.int	0x4811fc41
+	.int	0x35ffff91
+	.int	0x6b34201f
+	.int	0x1a9f17e1
+	.int	0x54000040
+	.int	0x79000260
+	.int	0x2a0103e0
+	.int	0xa94153f3
+	.int	0xa8c27bfd
+	.int	0xd65f03c0
+#else
+        stp     x29, x30, [sp, -32]!
+        mov     x29, sp
+        stp     x19, x20, [sp, 16]
+        mov     x19, x1
+        and     w1, w2, 65535
+        mov     x2, x0
+        ldrh    w20, [x19]
+        mov     w0, w20
+	uxth    w16, w0
+.L4:
+	ldaxrh  w0, [x2]
+	cmp     w0, w16
+	b.ne    .L5
+	stlxrh  w17, w1, [x2]
+	cbnz    w17, .L4
+.L5:
+        cmp     w0, w20, uxth
+        cset    w1, eq
+        beq     .L6
+        strh    w0, [x19]
+.L6:
+        mov     w0, w1
+        ldp     x19, x20, [sp, 16]
+        ldp     x29, x30, [sp], 32
+        ret
+#endif
+        .size   _(__atomic_compare_exchange_2), .-_(__atomic_compare_exchange_2)
+
+        .global _(__atomic_compare_exchange_4)
+        .type   _(__atomic_compare_exchange_4), %function
+_(__atomic_compare_exchange_4):
+#ifdef __TINYC__
+	.int	0xa9be7bfd
+	.int	0x910003fd
+	.int	0xa90153f3
+	.int	0xaa0103f3
+	.int	0x2a0203e1
+	.int	0xaa0003e2
+	.int	0xb9400274
+	.int	0x2a1403e0
+	.int	0x2a0003f0
+	.int	0x885ffc40
+	.int	0x6b10001f
+	.int	0x54000061
+	.int	0x8811fc41
+	.int	0x35ffff91
+	.int	0x6b14001f
+	.int	0x1a9f17e1
+	.int	0x54000040
+	.int	0xb9000260
+	.int	0x2a0103e0
+	.int	0xa94153f3
+	.int	0xa8c27bfd
+	.int	0xd65f03c0
+#else
+        stp     x29, x30, [sp, -32]!
+        mov     x29, sp
+        stp     x19, x20, [sp, 16]
+        mov     x19, x1
+        mov     w1, w2
+        mov     x2, x0
+        ldr     w20, [x19]
+        mov     w0, w20
+	mov     w16, w0
+.L7:
+	ldaxr   w0, [x2]
+	cmp     w0, w16
+	b.ne    .L8
+	stlxr   w17, w1, [x2]
+	cbnz    w17, .L7
+.L8:
+        cmp     w0, w20
+        cset    w1, eq
+        beq     .L9
+        str     w0, [x19]
+.L9:
+        mov     w0, w1
+        ldp     x19, x20, [sp, 16]
+        ldp     x29, x30, [sp], 32
+        ret
+#endif
+        .size   _(__atomic_compare_exchange_4), .-_(__atomic_compare_exchange_4)
+
+        .global _(__atomic_compare_exchange_8)
+        .type   _(__atomic_compare_exchange_8), %function
+_(__atomic_compare_exchange_8):
+#ifdef __TINYC__
+	.int	0xa9be7bfd
+	.int	0x910003fd
+	.int	0xa90153f3
+	.int	0xaa0103f3
+	.int	0xaa0203e1
+	.int	0xaa0003e2
+	.int	0xf9400274
+	.int	0xaa1403e0
+	.int	0xaa0003f0
+	.int	0xc85ffc40
+	.int	0xeb10001f
+	.int	0x54000061
+	.int	0xc811fc41
+	.int	0x35ffff91
+	.int	0xeb14001f
+	.int	0x1a9f17e1
+	.int	0x54000040
+	.int	0xf9000260
+	.int	0x2a0103e0
+	.int	0xa94153f3
+	.int	0xa8c27bfd
+	.int	0xd65f03c0
+#else
+        stp     x29, x30, [sp, -32]!
+        mov     x29, sp
+        stp     x19, x20, [sp, 16]
+        mov     x19, x1
+        mov     x1, x2
+        mov     x2, x0
+        ldr     x20, [x19]
+        mov     x0, x20
+	mov     x16, x0
+.L10:
+	ldaxr   x0, [x2]
+	cmp     x0, x16
+	b.ne    .L11
+	stlxr   w17, x1, [x2]
+	cbnz    w17, .L10
+.L11:
+        cmp     x0, x20
+        cset    w1, eq
+        beq     .L12
+        str     x0, [x19]
+.L12:
+        mov     w0, w1
+        ldp     x19, x20, [sp, 16]
+        ldp     x29, x30, [sp], 32
+        ret
+#endif
+        .size   _(__atomic_compare_exchange_8), .-_(__atomic_compare_exchange_8)
+
+/* ---------------------------------------------- */
+#elif defined __riscv
+
+        .text
+        .align  2
+
+        .global _(fetch_and_add_riscv64)
+        .type   _(fetch_and_add_riscv64), %function
+_(fetch_and_add_riscv64):
+#ifdef __TINYC__
+        .int   0x0f50000f
+        .int   0x004b5202f
+        .short 0x8082
+#else
+        fence iorw,ow
+        amoadd.w.aq zero,a1,0(a0)
+        ret
+#endif
+        .size   _(fetch_and_add_riscv64), .-_(fetch_and_add_riscv64)
+
+        .global _(__atomic_test_and_set)
+        .type   _(__atomic_test_and_set), %function
+_(__atomic_test_and_set):
+#ifdef __TINYC__
+	.int	0x00357793
+	.int	0x0037979b
+	.short	0x4685
+	.short	0x9971
+	.int	0x00f696bb
+	.int	0x0f50000f
+	.int	0x44d5272f
+	.int	0x00f7553b
+	.int	0x0ff57513
+	.short	0x8082
+#else
+        andi    a5,a0,3
+        slliw   a5,a5,3
+        li      a3,1
+        andi    a0,a0,-4
+        sllw    a3,a3,a5
+        fence iorw,ow; amoor.w.aq a4,a3,0(a0)
+        srlw    a0,a4,a5
+        andi    a0,a0,0xff
+        ret
+#endif
+	.size   _(__atomic_test_and_set), .-_(__atomic_test_and_set)
+
+        .global _(__atomic_clear)
+        .type   _(__atomic_clear), %function
+_(__atomic_clear):
+#ifdef __TINYC__
+	.int	0x0ff0000f
+	.int	0x00050023
+	.int	0x0ff0000f
+	.short	0x8082
+#else
+        fence   iorw,iorw
+        sb      zero,0(a0)
+        fence   iorw,iorw
+        ret
+#endif
+	.size   _(__atomic_clear), .-_(__atomic_clear)
+
+        .global _(__atomic_compare_exchange_1)
+        .type   _(__atomic_compare_exchange_1), %function
+_(__atomic_compare_exchange_1):
+#ifdef __TINYC__
+	.short	0x1141
+	.short	0x86ba
+	.short	0x873e
+	.short	0xe406
+	.int	0x0ff0000f
+	.int	0x0005c803
+	.int	0xff857893
+	.int	0x0008b783
+	.short	0x891d
+	.short	0x050e
+	.int	0x0ff00693
+	.int	0x00a696b3
+	.int	0x00a81833
+	.int	0x00a61633
+	.int	0xfff6c713
+	.short	0x8f7d
+	.int	0x00f6f333
+	.short	0x8f51
+	.int	0x03031263
+	.int	0x1008b32f
+	.int	0x00f31663
+	.int	0x18e8be2f
+	.int	0xfe0e1ae3
+	.int	0x40f30733
+	.short	0x879a
+	.short	0xff69
+	.int	0x0ff0000f
+	.short	0x4505
+	.short	0xa801
+	.int	0x00a7d7b3
+	.int	0x00f58023
+	.int	0x0ff0000f
+	.short	0x4501
+	.short	0x60a2
+	.short	0x0141
+	.short	0x8082
+#else
+        addi    sp,sp,-16
+        mv      a3,a4
+        mv      a4,a5
+        sd      ra,8(sp)
+	fence
+	lbu     a6,0(a1)
+	andi    a7,a0,-8
+	ld      a5,0(a7)
+	andi    a0,a0,7
+	slli    a0,a0,0x3
+	li      a3,255
+	sll     a3,a3,a0
+	sll     a6,a6,a0
+	sll     a2,a2,a0
+.L1:
+	not     a4,a3
+	and     a4,a4,a5
+	and     t1,a3,a5
+	or      a4,a4,a2
+	bne     t1,a6,.L4
+.L2:
+	lr.d    t1,(a7)
+	bne     t1,a5,.L3
+	sc.d    t3,a4,(a7)
+	bnez    t3,.L2
+.L3:
+	sub     a4,t1,a5
+	mv      a5,t1
+	bnez    a4,.L1
+	fence
+	li      a0,1
+	j	.L5
+.L4:
+	srl     a5,a5,a0
+	sb      a5,0(a1)
+	fence
+	li      a0,0
+.L5:
+        ld      ra,8(sp)
+        addi    sp,sp,16
+        jr      ra
+#endif
+        .size   _(__atomic_compare_exchange_1), .-_(__atomic_compare_exchange_1)
+
+        .global _(__atomic_compare_exchange_2)
+        .type   _(__atomic_compare_exchange_2), %function
+_(__atomic_compare_exchange_2):
+#ifdef __TINYC__
+	.short	0x1141
+	.short	0x86ba
+	.short	0x873e
+	.short	0xe406
+	.int	0x0ff0000f
+	.int	0x0005d803
+	.int	0xff857893
+	.short	0x67c1
+	.short	0x891d
+	.int	0x0008b703
+	.short	0x050e
+	.short	0x17fd
+	.int	0x00a797b3
+	.int	0x00a81833
+	.int	0x00a61633
+	.int	0xfff7c693
+	.short	0x8ef9
+	.int	0x00e7f333
+	.short	0x8ed1
+	.int	0x03031263
+	.int	0x1008b32f
+	.int	0x00e31663
+	.int	0x18d8be2f
+	.int	0xfe0e1ae3
+	.int	0x40e306b3
+	.short	0x871a
+	.short	0xfee9
+	.int	0x0ff0000f
+	.short	0x4505
+	.short	0xa801
+	.int	0x00a75733
+	.int	0x00e59023
+	.int	0x0ff0000f
+	.short	0x4501
+	.short	0x60a2
+	.short	0x0141
+	.short	0x8082
+#else
+        addi    sp,sp,-16
+        mv      a3,a4
+        mv      a4,a5
+        sd      ra,8(sp)
+	fence
+	lhu     a6,0(a1)
+	andi    a7,a0,-8
+	lui     a5,0x10
+	andi    a0,a0,7
+	ld      a4,0(a7)
+	slli    a0,a0,0x3
+	addi    a5,a5,-1
+	sll     a5,a5,a0
+	sll     a6,a6,a0
+	sll     a2,a2,a0
+.L6:
+	not     a3,a5
+	and     a3,a3,a4
+	and     t1,a5,a4
+	or      a3,a3,a2
+	bne     t1,a6,.L9
+.L7:
+	lr.d    t1,(a7)
+	bne     t1,a4,.L8
+	sc.d    t3,a3,(a7)
+	bnez    t3,.L7
+.L8:
+	sub     a3,t1,a4
+	mv      a4,t1
+	bnez    a3,.L6
+	fence
+	li      a0,1
+	j	.L10
+.L9:
+	srl     a4,a4,a0
+	sh      a4,0(a1)
+	fence
+	li      a0,0
+.L10:
+        ld      ra,8(sp)
+        addi    sp,sp,16
+        jr      ra
+#endif
+        .size   _(__atomic_compare_exchange_2), .-_(__atomic_compare_exchange_2)
+
+        .global _(__atomic_compare_exchange_4)
+        .type   _(__atomic_compare_exchange_4), %function
+_(__atomic_compare_exchange_4):
+#ifdef __TINYC__
+        .short 0x419c
+        .int   0x0f50000f
+        .int   0x1405272f
+        .int   0x00f71663
+        .int   0x1cc5282f
+        .int   0xfe081ae3
+        .int   0x40f707bb
+        .int   0x0017b513
+        .short 0xc391
+        .short 0xc198
+        .short 0x8905
+        .short 0x8082
+#else
+	lw      a5,0(a1)
+	fence	iorw,ow;
+.L11:
+	lr.w.aq	a4,0(a0)
+	bne	a4,a5,.L12
+	sc.w.aq	a6,a2,0(a0)
+	bnez	a6,.L11
+.L12:
+	subw    a5,a4,a5
+	seqz    a0,a5
+	beq     a5,zero,.L13
+	sw      a4,0(a1)
+.L13:
+	andi    a0,a0,1
+        ret
+#endif
+        .size   _(__atomic_compare_exchange_4), .-_(__atomic_compare_exchange_4)
+
+        .global _(__atomic_compare_exchange_8)
+        .type   _(__atomic_compare_exchange_8), %function
+_(__atomic_compare_exchange_8):
+#ifdef __TINYC__
+        .short 0x619c
+        .int   0x0f50000f
+        .int   0x1405372f
+        .int   0x00f71563
+        .int   0x1cc536af
+        .short 0xfaf5
+        .int   0x40f707b3
+        .int   0x0017b513
+        .short 0xc391
+        .short 0xe198
+        .short 0x8905
+        .short 0x8082
+#else
+	ld      a5,0(a1)
+	fence	iorw,ow;
+.L14:
+	lr.d.aq	a4,0(a0)
+	bne	a4,a5,.L15
+	sc.d.aq	a3,a2,0(a0)
+	bnez	a3,.L14
+.L15:
+	sub	a5,a4,a5
+	seqz    a0,a5
+	beq     a5,zero,.L16
+	sd      a4,0(a1)
+.L16:
+	andi    a0,a0,1
+        ret
+#endif
+        .size   _(__atomic_compare_exchange_8), .-_(__atomic_compare_exchange_8)
+
+/* ---------------------------------------------- */
+#endif
diff --git a/lib/bcheck.c b/lib/bcheck.c
index 94fec6f55..1e374f164 100644
--- a/lib/bcheck.c
+++ b/lib/bcheck.c
@@ -41,7 +41,7 @@
 #define BOUND_STATISTIC         (1)
 
 #if BOUND_DEBUG
- #define dprintf(a...)         if (print_calls) fprintf(a)
+ #define dprintf(a...)         if (print_calls) { bounds_loc(a); }
 #else
  #define dprintf(a...)
 #endif
@@ -161,7 +161,7 @@ static pthread_spinlock_t bounds_spin;
 #define HAVE_TLS_FUNC          (1)
 #define HAVE_TLS_VAR           (0)
 #endif
-#ifdef TCC_MUSL
+#if defined TCC_MUSL || defined __ANDROID__
 # undef HAVE_CTYPE
 #endif
 #endif
@@ -225,7 +225,7 @@ typedef struct alloca_list_struct {
 #define BOUND_GET_TID(id)	id = GetCurrentThreadId()
 #elif defined(__OpenBSD__)
 #define BOUND_TID_TYPE		pid_t
-#define BOUND_GET_TID(id)	id = syscall (SYS_getthrid)
+#define BOUND_GET_TID(id)	id = getthrid()
 #elif defined(__FreeBSD__)
 #define BOUND_TID_TYPE		pid_t
 #define BOUND_GET_TID(id)	syscall (SYS_thr_self, &id)
@@ -257,6 +257,8 @@ void splay_printtree(Tree * t, int d);
 
 /* external interface */
 void __bounds_checking (int no_check);
+void __bound_checking_lock (void);
+void __bound_checking_unlock (void);
 void __bound_never_fatal (int no_check);
 DLL_EXPORT void * __bound_ptr_add(void *p, size_t offset);
 DLL_EXPORT void * __bound_ptr_indir1(void *p, size_t offset);
@@ -270,6 +272,7 @@ DLL_EXPORT void FASTCALL __bound_local_delete(void *p1);
 void __bound_init(size_t *, int);
 void __bound_main_arg(int argc, char **argv, char **envp);
 void __bound_exit(void);
+void __bound_exit_dll(size_t *);
 #if !defined(_WIN32)
 void *__bound_mmap (void *start, size_t size, int prot, int flags, int fd,
                     off_t offset);
@@ -289,7 +292,9 @@ DLL_EXPORT char *__bound_strncpy(char *dst, const char *src, size_t n);
 DLL_EXPORT int __bound_strcmp(const char *s1, const char *s2);
 DLL_EXPORT int __bound_strncmp(const char *s1, const char *s2, size_t n);
 DLL_EXPORT char *__bound_strcat(char *dest, const char *src);
+DLL_EXPORT char *__bound_strncat(char *dest, const char *src, size_t n);
 DLL_EXPORT char *__bound_strchr(const char *string, int ch);
+DLL_EXPORT char *__bound_strrchr(const char *string, int ch);
 DLL_EXPORT char *__bound_strdup(const char *s);
 
 #if defined(__arm__) && defined(__ARM_EABI__)
@@ -421,7 +426,9 @@ static unsigned long long bound_strncpy_count;
 static unsigned long long bound_strcmp_count;
 static unsigned long long bound_strncmp_count;
 static unsigned long long bound_strcat_count;
+static unsigned long long bound_strncat_count;
 static unsigned long long bound_strchr_count;
+static unsigned long long bound_strrchr_count;
 static unsigned long long bound_strdup_count;
 static unsigned long long bound_not_found;
 #define INCR_COUNT(x)          ++x
@@ -442,7 +449,11 @@ int tcc_backtrace(const char *fmt, ...);
 
 /* print a bound error message */
 #define bound_warning(...) \
-    tcc_backtrace("^bcheck.c^BCHECK: " __VA_ARGS__)
+    do {                                                 \
+        WAIT_SEM ();                                     \
+        tcc_backtrace("^bcheck.c^BCHECK: " __VA_ARGS__); \
+        POST_SEM ();                                     \
+    } while (0)
 
 #define bound_error(...)            \
     do {                            \
@@ -451,6 +462,13 @@ int tcc_backtrace(const char *fmt, ...);
             exit(255);              \
     } while (0)
 
+#define bounds_loc(fp, ...) \
+    do {                            \
+        WAIT_SEM (); \
+        tcc_backtrace("^bcheck.c^\001" __VA_ARGS__); \
+        POST_SEM (); \
+    } while (0)
+
 static void bound_alloc_error(const char *s)
 {
     fprintf(stderr,"FATAL: %s\n",s);
@@ -495,6 +513,16 @@ void __bounds_checking (int no_check)
 #endif
 }
 
+void __bound_checking_lock(void)
+{
+    WAIT_SEM ();
+}
+
+void __bound_checking_unlock(void)
+{
+    POST_SEM ();
+}
+
 /* enable/disable checking. This can be used in signal handlers. */
 void __bound_never_fatal (int neverfatal)
 {
@@ -601,7 +629,8 @@ BOUND_PTR_INDIR(8)
 BOUND_PTR_INDIR(12)
 BOUND_PTR_INDIR(16)
 
-#if defined(__GNUC__) && (__GNUC__ >= 6)
+/* Needed when using ...libtcc1-usegcc=yes in lib/Makefile */
+#if (defined(__GNUC__) && (__GNUC__ >= 6)) || defined(__clang__)
 /*
  * At least gcc 6.2 complains when __builtin_frame_address is used with
  * nonzero argument.
@@ -906,7 +935,7 @@ void __bound_siglongjmp(jmp_buf env, int val)
 }
 #endif
 
-#if defined(__GNUC__) && (__GNUC__ >= 6)
+#if (defined(__GNUC__) && (__GNUC__ >= 6)) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
 
@@ -1157,7 +1186,8 @@ void __attribute__((destructor)) __bound_exit(void)
 
     if (inited) {
 #if !defined(_WIN32) && !defined(__APPLE__) && !defined TCC_MUSL && \
-    !defined(__OpenBSD__) && !defined(__FreeBSD__) && !defined(__NetBSD__)
+    !defined(__OpenBSD__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
+    !defined(__ANDROID__)
         if (print_heap) {
             extern void __libc_freeres (void);
             __libc_freeres ();
@@ -1241,7 +1271,9 @@ void __attribute__((destructor)) __bound_exit(void)
             fprintf (stderr, "bound_strcmp_count       %llu\n", bound_strcmp_count);
             fprintf (stderr, "bound_strncmp_count      %llu\n", bound_strncmp_count);
             fprintf (stderr, "bound_strcat_count       %llu\n", bound_strcat_count);
+            fprintf (stderr, "bound_strncat_count      %llu\n", bound_strncat_count);
             fprintf (stderr, "bound_strchr_count       %llu\n", bound_strchr_count);
+            fprintf (stderr, "bound_strrchr_count      %llu\n", bound_strrchr_count);
             fprintf (stderr, "bound_strdup_count       %llu\n", bound_strdup_count);
             fprintf (stderr, "bound_not_found          %llu\n", bound_not_found);
 #endif
@@ -1255,6 +1287,27 @@ void __attribute__((destructor)) __bound_exit(void)
     }
 }
 
+void __bound_exit_dll(size_t *p)
+{
+    dprintf(stderr, "%s, %s()\n", __FILE__, __FUNCTION__);
+
+    if (p) {
+        WAIT_SEM ();
+	while (p[0] != 0) {
+	    tree = splay_delete(p[0], tree);
+#if BOUND_DEBUG
+            if (print_calls) {
+                dprintf(stderr, "%s, %s(): remove static var %p 0x%lx\n",
+                        __FILE__, __FUNCTION__,
+                        (void *) p[0], (unsigned long) p[1]);
+            }
+#endif
+	    p += 2;
+	}
+        POST_SEM ();
+    }
+}
+
 #if HAVE_PTHREAD_CREATE
 typedef struct {
     void *(*start_routine) (void *);
@@ -1901,6 +1954,24 @@ char *__bound_strcat(char *dest, const char *src)
     return strcat(r, s);
 }
 
+char *__bound_strncat(char *dest, const char *src, size_t n)
+{
+    char *r = dest;
+    const char *s = src;
+    size_t len = n;
+
+    dprintf(stderr, "%s, %s(): %p, %p, 0x%lx\n",
+            __FILE__, __FUNCTION__, dest, src, (unsigned long)n);
+    INCR_COUNT(bound_strncat_count);
+    while (*dest++);
+    while (len-- && *src++);
+    __bound_check(r, (dest - r) + (src - s) - 1, "strncat dest");
+    __bound_check(s, src - s, "strncat src");
+    if (check_overlap(r, (dest - r) + (src - s) - 1, s, src - s, "strncat"))
+        return dest;
+    return strncat(r, s, n);
+}
+
 char *__bound_strchr(const char *s, int c)
 {
     const unsigned char *str = (const unsigned char *) s;
@@ -1918,6 +1989,24 @@ char *__bound_strchr(const char *s, int c)
     return *str == ch ? (char *) str : NULL;
 }
 
+char *__bound_strrchr(const char *s, int c)
+{
+    const unsigned char *str = (const unsigned char *) s;
+    unsigned char ch = c;
+
+    dprintf(stderr, "%s, %s(): %p, %d\n",
+            __FILE__, __FUNCTION__, s, ch);
+    INCR_COUNT(bound_strrchr_count);
+    while (*str++);
+    __bound_check(s, (const char *)str - s, "strrchr");
+    while (str != (const unsigned char *)s) {
+        if (*--str == ch)
+            break;
+    }
+    __bound_check(s, (const char *)str - s, "strrchr");
+    return *str == ch ? (char *) str : NULL;
+}
+
 char *__bound_strdup(const char *s)
 {
     const char *p = s;
diff --git a/lib/bt-dll.c b/lib/bt-dll.c
index 3389bd721..7c62cefad 100644
--- a/lib/bt-dll.c
+++ b/lib/bt-dll.c
@@ -6,6 +6,7 @@
 
 #define REDIR_ALL \
   REDIR(__bt_init) \
+  REDIR(__bt_exit) \
   REDIR(tcc_backtrace) \
   \
   REDIR(__bound_ptr_add) \
diff --git a/lib/bt-exe.c b/lib/bt-exe.c
index f0e494d4b..3a2d02e49 100644
--- a/lib/bt-exe.c
+++ b/lib/bt-exe.c
@@ -3,9 +3,13 @@
    from tccrun.c into executables. */
 
 #define CONFIG_TCC_BACKTRACE_ONLY
+#define ONE_SOURCE 1
+#define pstrcpy tcc_pstrcpy
 #include "../tccrun.c"
 
 int (*__rt_error)(void*, void*, const char *, va_list);
+__attribute__((weak)) void __bound_checking_lock(void);
+__attribute__((weak)) void __bound_checking_unlock(void);
 
 #ifndef _WIN32
 # define __declspec(n)
@@ -18,6 +22,12 @@ void __bt_init(rt_context *p, int num_callers)
     __attribute__((weak)) void __bound_init(void*, int);
     struct rt_context *rc = &g_rtctxt;
     //fprintf(stderr, "__bt_init %d %p %p\n", num_callers, p->stab_sym, p->bounds_start), fflush(stderr);
+    /* call __bound_init here due to redirection of sigaction */
+    /* needed to add global symbols */
+    if (p->bounds_start) {
+	__bound_init(p->bounds_start, -1);
+        __bound_checking_lock();
+    }
     if (num_callers) {
         memcpy(rc, p, offsetof(rt_context, next));
         rc->num_callers = num_callers - 1;
@@ -27,10 +37,33 @@ void __bt_init(rt_context *p, int num_callers)
     } else {
         p->next = rc->next, rc->next = p;
     }
+    if (p->bounds_start)
+        __bound_checking_unlock();
+}
+
+__declspec(dllexport)
+void __bt_exit(rt_context *p)
+{
+    __attribute__((weak)) void __bound_exit_dll(void*);
+    struct rt_context *rc = &g_rtctxt;
+
+    if (p->bounds_start) {
+	__bound_exit_dll(p->bounds_start);
+        __bound_checking_lock();
+    }
+    while (rc) {
+        if (rc->next == p) {
+	    rc->next = rc->next->next;
+	    break;
+	}
+	rc = rc->next;
+    }
+    if (p->bounds_start)
+        __bound_checking_unlock();
 }
 
 /* copy a string and truncate it. */
-static char *pstrcpy(char *buf, size_t buf_size, const char *s)
+ST_FUNC char *pstrcpy(char *buf, size_t buf_size, const char *s)
 {
     int l = strlen(s);
     if (l >= buf_size)
diff --git a/lib/bt-log.c b/lib/bt-log.c
index d767f08a8..bff9a7948 100644
--- a/lib/bt-log.c
+++ b/lib/bt-log.c
@@ -13,6 +13,12 @@ int (*__rt_error)(void*, void*, const char *, va_list);
 # define DLL_EXPORT
 #endif
 
+/* Needed when using ...libtcc1-usegcc=yes in lib/Makefile */
+#if (defined(__GNUC__) && (__GNUC__ >= 6)) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wframe-address"
+#endif
+
 DLL_EXPORT int tcc_backtrace(const char *fmt, ...)
 {
     va_list ap;
@@ -25,13 +31,19 @@ DLL_EXPORT int tcc_backtrace(const char *fmt, ...)
         ret = __rt_error(fp, ip, fmt, ap);
         va_end(ap);
     } else {
-        const char *p;
+        const char *p, *nl = "\n";
         if (fmt[0] == '^' && (p = strchr(fmt + 1, fmt[0])))
             fmt = p + 1;
+        if (fmt[0] == '\001')
+            ++fmt, nl = "";
         va_start(ap, fmt);
         ret = vfprintf(stderr, fmt, ap);
         va_end(ap);
-        fprintf(stderr, "\n"), fflush(stderr);
+        fprintf(stderr, nl), fflush(stderr);
     }
     return ret;
 }
+
+#if (defined(__GNUC__) && (__GNUC__ >= 6)) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/lib/builtin.c b/lib/builtin.c
new file mode 100644
index 000000000..e40a00339
--- /dev/null
+++ b/lib/builtin.c
@@ -0,0 +1,164 @@
+/* uses alias to allow building with gcc/clang */
+#ifdef __TINYC__
+#define	BUILTIN(x)	__builtin_##x
+#define	BUILTINN(x)	"__builtin_" # x
+#else
+#define	BUILTIN(x)	__tcc_builtin_##x
+#define	BUILTINN(x)	"__tcc_builtin_" # x
+#endif
+
+/* ---------------------------------------------- */
+/* This file implements:
+ * __builtin_ffs
+ * __builtin_clz
+ * __builtin_ctz
+ * __builtin_clrsb
+ * __builtin_popcount
+ * __builtin_parity
+ * for int, long and long long
+ */
+
+static const unsigned char table_1_32[] = {
+     0,  1, 28,  2, 29, 14, 24,  3, 30, 22, 20, 15, 25, 17,  4,  8, 
+    31, 27, 13, 23, 21, 19, 16,  7, 26, 12, 18,  6, 11,  5, 10,  9
+};
+static const unsigned char table_2_32[32] = {
+    31, 22, 30, 21, 18, 10, 29,  2, 20, 17, 15, 13,  9,  6, 28,  1,
+    23, 19, 11,  3, 16, 14,  7, 24, 12,  4,  8, 25,  5, 26, 27,  0
+};
+static const unsigned char table_1_64[] = {
+     0,  1,  2, 53,  3,  7, 54, 27,  4, 38, 41,  8, 34, 55, 48, 28,
+    62,  5, 39, 46, 44, 42, 22,  9, 24, 35, 59, 56, 49, 18, 29, 11,
+    63, 52,  6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
+    51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
+};
+static const unsigned char table_2_64[] = {
+    63, 16, 62,  7, 15, 36, 61,  3,  6, 14, 22, 26, 35, 47, 60,  2,
+     9,  5, 28, 11, 13, 21, 42, 19, 25, 31, 34, 40, 46, 52, 59,  1,
+    17,  8, 37,  4, 23, 27, 48, 10, 29, 12, 43, 20, 32, 41, 53, 18,
+    38, 24, 49, 30, 44, 33, 54, 39, 50, 45, 55, 51, 56, 57, 58,  0
+};
+
+#define FFSI(x) \
+    return table_1_32[((x & -x) * 0x077cb531u) >> 27] + (x != 0);
+#define FFSL(x) \
+    return table_1_64[((x & -x) * 0x022fdd63cc95386dull) >> 58] + (x != 0);
+#define CTZI(x) \
+    return table_1_32[((x & -x) * 0x077cb531u) >> 27];
+#define CTZL(x) \
+    return table_1_64[((x & -x) * 0x022fdd63cc95386dull) >> 58];
+#define CLZI(x)   \
+    x |= x >> 1;  \
+    x |= x >> 2;  \
+    x |= x >> 4;  \
+    x |= x >> 8;  \
+    x |= x >> 16; \
+    return table_2_32[(x * 0x07c4acddu) >> 27];
+#define CLZL(x)   \
+    x |= x >> 1;  \
+    x |= x >> 2;  \
+    x |= x >> 4;  \
+    x |= x >> 8;  \
+    x |= x >> 16; \
+    x |= x >> 32; \
+    return table_2_64[x * 0x03f79d71b4cb0a89ull >> 58];
+#define POPCOUNTI(x, m)                                                   \
+    x = x - ((x >> 1) & 0x55555555);                                      \
+    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);                       \
+    x = (x + (x >> 4)) & 0xf0f0f0f;                                       \
+    return ((x * 0x01010101) >> 24) & m; 
+#define POPCOUNTL(x, m)                                                   \
+    x = x - ((x >> 1) & 0x5555555555555555ull);                           \
+    x = (x & 0x3333333333333333ull) + ((x >> 2) & 0x3333333333333333ull); \
+    x = (x + (x >> 4)) & 0xf0f0f0f0f0f0f0full;                            \
+    return ((x * 0x0101010101010101ull) >> 56) & m;
+
+/* Returns one plus the index of the least significant 1-bit of x,
+   or if x is zero, returns zero. */
+int BUILTIN(ffs) (int x) { FFSI(x) }
+int BUILTIN(ffsll) (long long x) { FFSL(x) }
+#if __SIZEOF_LONG__ == 4
+int BUILTIN(ffsl) (long x) __attribute__((alias(BUILTINN(ffs))));
+#else
+int BUILTIN(ffsl) (long x) __attribute__((alias(BUILTINN(ffsll))));
+#endif
+
+/* Returns the number of leading 0-bits in x, starting at the most significant
+   bit position. If x is 0, the result is undefined.  */
+int BUILTIN(clz) (unsigned int x) { CLZI(x) }
+int BUILTIN(clzll) (unsigned long long x) { CLZL(x) }
+#if __SIZEOF_LONG__ == 4
+int BUILTIN(clzl) (unsigned long x) __attribute__((alias(BUILTINN(clz))));
+#else
+int BUILTIN(clzl) (unsigned long x) __attribute__((alias(BUILTINN(clzll))));
+#endif
+
+/* Returns the number of trailing 0-bits in x, starting at the least
+   significant bit position. If x is 0, the result is undefined. */
+int BUILTIN(ctz) (unsigned int x) { CTZI(x) }
+int BUILTIN(ctzll) (unsigned long long x) { CTZL(x) }
+#if __SIZEOF_LONG__ == 4
+int BUILTIN(ctzl) (unsigned long x) __attribute__((alias(BUILTINN(ctz))));
+#else
+int BUILTIN(ctzl) (unsigned long x) __attribute__((alias(BUILTINN(ctzll))));
+#endif
+
+/* Returns the number of leading redundant sign bits in x, i.e. the number
+   of bits following the most significant bit that are identical to it.
+   There are no special cases for 0 or other values. */
+int BUILTIN(clrsb) (int x) { if (x < 0) x = ~x; x <<= 1; CLZI(x) }
+int BUILTIN(clrsbll) (long long x) { if (x < 0) x = ~x; x <<= 1; CLZL(x) }
+#if __SIZEOF_LONG__ == 4
+int BUILTIN(clrsbl) (long x) __attribute__((alias(BUILTINN(clrsb))));
+#else
+int BUILTIN(clrsbl) (long x) __attribute__((alias(BUILTINN(clrsbll))));
+#endif
+
+/* Returns the number of 1-bits in x.*/
+int BUILTIN(popcount) (unsigned int x) { POPCOUNTI(x, 0x3f) }
+int BUILTIN(popcountll) (unsigned long long x) { POPCOUNTL(x, 0x7f) }
+#if __SIZEOF_LONG__ == 4
+int BUILTIN(popcountl) (unsigned long x) __attribute__((alias(BUILTINN(popcount))));
+#else
+int BUILTIN(popcountl ) (unsigned long x) __attribute__((alias(BUILTINN(popcountll))));
+#endif
+
+/* Returns the parity of x, i.e. the number of 1-bits in x modulo 2. */
+int BUILTIN(parity) (unsigned int x) { POPCOUNTI(x, 0x01) }
+int BUILTIN(parityll) (unsigned long long x) { POPCOUNTL(x, 0x01) }
+#if __SIZEOF_LONG__ == 4
+int BUILTIN(parityl) (unsigned long x) __attribute__((alias(BUILTINN(parity))));
+#else
+int BUILTIN(parityl) (unsigned long x) __attribute__((alias(BUILTINN(parityll))));
+#endif
+
+#ifndef __TINYC__
+#if defined(__GNUC__) && (__GNUC__ >= 6)
+/* gcc overrides alias from __builtin_ffs... to ffs.. so use assembly code */
+__asm__(".globl  __builtin_ffs");
+__asm__(".set __builtin_ffs,__tcc_builtin_ffs");
+__asm__(".globl  __builtin_ffsl");
+__asm__(".set __builtin_ffsl,__tcc_builtin_ffsl");
+__asm__(".globl  __builtin_ffsll");
+__asm__(".set __builtin_ffsll,__tcc_builtin_ffsll");
+#else
+int __builtin_ffs(int x) __attribute__((alias("__tcc_builtin_ffs")));
+int __builtin_ffsl(long x) __attribute__((alias("__tcc_builtin_ffsl")));
+int __builtin_ffsll(long long x) __attribute__((alias("__tcc_builtin_ffsll")));
+#endif
+int __builtin_clz(unsigned int x) __attribute__((alias("__tcc_builtin_clz")));
+int __builtin_clzl(unsigned long x) __attribute__((alias("__tcc_builtin_clzl")));
+int __builtin_clzll(unsigned long long x) __attribute__((alias("__tcc_builtin_clzll")));
+int __builtin_ctz(unsigned int x) __attribute__((alias("__tcc_builtin_ctz")));
+int __builtin_ctzl(unsigned long x) __attribute__((alias("__tcc_builtin_ctzl")));
+int __builtin_ctzll(unsigned long long x) __attribute__((alias("__tcc_builtin_ctzll")));
+int __builtin_clrsb(int x) __attribute__((alias("__tcc_builtin_clrsb")));
+int __builtin_clrsbl(long x) __attribute__((alias("__tcc_builtin_clrsbl")));
+int __builtin_clrsbll(long long x) __attribute__((alias("__tcc_builtin_clrsbll")));
+int __builtin_popcount(unsigned int x) __attribute__((alias("__tcc_builtin_popcount")));
+int __builtin_popcountl(unsigned long x) __attribute__((alias("__tcc_builtin_popcountl")));
+int __builtin_popcountll(unsigned long long x) __attribute__((alias("__tcc_builtin_popcountll")));
+int __builtin_parity(unsigned int x) __attribute__((alias("__tcc_builtin_parity")));
+int __builtin_parityl(unsigned long x) __attribute__((alias("__tcc_builtin_parityl")));
+int __builtin_parityll(unsigned long long x) __attribute__((alias("__tcc_builtin_parityll")));
+#endif
diff --git a/lib/fetch_and_add.S b/lib/fetch_and_add.S
deleted file mode 100644
index ec96a03c8..000000000
--- a/lib/fetch_and_add.S
+++ /dev/null
@@ -1,67 +0,0 @@
-/* ---------------------------------------------- */
-#if defined __arm__
-
-        .text
-        .align  2
-        .global fetch_and_add_arm
-        .type   fetch_and_add_arm, %function
-fetch_and_add_arm:
-        mcr     p15, #0, r0, c7, c10, #5
-.L0:
-        ldrex   r3, [r0]
-        add     r3, r3, r1
-        strex   r2, r3, [r0]
-        cmp     r2, #0
-        bne     .L0
-        mcr     p15, #0, r0, c7, c10, #5
-        bx      lr
-	.size   fetch_and_add_arm, .-fetch_and_add_arm
-
-/* ---------------------------------------------- */
-#elif defined __aarch64__
-
-        .text
-        .align  2
-        .global fetch_and_add_arm64
-        .type   fetch_and_add_arm64, %function
-fetch_and_add_arm64:
-#ifdef __TINYC__
-        .int 0x885f7c02
-        .int 0x0b010042
-        .int 0x8803fc02
-        .int 0x35ffffa3
-        .int 0xd5033bbf
-        .int 0xd65f03c0
-#else
-        ldxr    w2, [x0]
-        add     w2, w2, w1
-        stlxr   w3, w2, [x0]
-        cbnz    w3, fetch_and_add_arm64
-        dmb     ish
-        ret
-#endif
-
-        .size   fetch_and_add_arm64, .-fetch_and_add_arm64
-
-/* ---------------------------------------------- */
-#elif defined __riscv
-
-        .text
-        .align  2
-        .global fetch_and_add_riscv64
-        .type   fetch_and_add_riscv64, %function
-fetch_and_add_riscv64:
-#ifdef __TINYC__
-        .int   0x0f50000f
-        .int   0x004b5202f
-        .short 0x8082
-#else
-        fence iorw,ow
-        amoadd.w.aq zero,a1,0(a0)
-        ret
-#endif
-
-        .size   fetch_and_add_riscv64, .-fetch_and_add_riscv64
-
-/* ---------------------------------------------- */
-#endif
diff --git a/lib/lib-arm64.c b/lib/lib-arm64.c
index 33df5092b..226827e99 100644
--- a/lib/lib-arm64.c
+++ b/lib/lib-arm64.c
@@ -24,7 +24,7 @@ void *memcpy(void*,void*,__SIZE_TYPE__);
 #include <string.h>
 #endif
 
-#ifndef __riscv
+#if !defined __riscv && !defined __APPLE__
 void __clear_cache(void *beg, void *end)
 {
     __arm64_clear_cache(beg, end);
diff --git a/lib/stdatomic.c b/lib/stdatomic.c
index eea708553..bd8c0ce7f 100644
--- a/lib/stdatomic.c
+++ b/lib/stdatomic.c
@@ -5,6 +5,7 @@
 #define uint32_t unsigned int
 #define uint64_t unsigned long long
 #define bool _Bool
+#define false 0
 #define true 1
 #define __ATOMIC_RELAXED 0
 #define __ATOMIC_CONSUME 1
@@ -12,15 +13,17 @@
 #define __ATOMIC_RELEASE 3
 #define __ATOMIC_ACQ_REL 4
 #define __ATOMIC_SEQ_CST 5
+typedef __SIZE_TYPE__ size_t;
 
-#define ATOMIC_X86_COMPARE_EXCHANGE(TYPE, MODE, SUFFIX) \
+#if defined __i386__ || defined __x86_64__
+#define ATOMIC_COMPARE_EXCHANGE(TYPE, MODE, SUFFIX) \
     bool __atomic_compare_exchange_##MODE \
         (volatile void *atom, void *ref, TYPE xchg, \
          bool weak, int success_memorder, int failure_memorder) \
     { \
         TYPE rv; \
         TYPE cmp = *(TYPE *)ref; \
-        asm volatile( \
+        __asm__ volatile( \
             "lock cmpxchg" SUFFIX " %2,%1\n" \
             : "=a" (rv), "+m" (*(TYPE *)atom) \
             : "q" (xchg), "0" (cmp) \
@@ -29,96 +32,135 @@
         *(TYPE *)ref = rv; \
         return (rv == cmp); \
     }
+#else
+#define ATOMIC_COMPARE_EXCHANGE(TYPE, MODE, SUFFIX) \
+    extern bool __atomic_compare_exchange_##MODE \
+        (volatile void *atom, void *ref, TYPE xchg, \
+         bool weak, int success_memorder, int failure_memorder);
+#endif
 
-#define ATOMIC_X86_LOAD(TYPE, MODE) \
+#define ATOMIC_LOAD(TYPE, MODE) \
     TYPE __atomic_load_##MODE(const volatile void *atom, int memorder) \
     { \
         return *(volatile TYPE *)atom; \
     }
 
-#define ATOMIC_X86_STORE(TYPE, MODE) \
+#define ATOMIC_STORE(TYPE, MODE) \
     void __atomic_store_##MODE(volatile void *atom, TYPE value, int memorder) \
     { \
         *(volatile TYPE *)atom = value; \
     }
 
-/* Some tcc targets set __GNUC__ */
-#if defined(__GNUC__) && !defined(__TINYC__)
-#define	ATOMIC_LOAD(t,a,b,c)              t b; __atomic_load((t *)a, (t *)&b, c)
-#define COMPARE_EXCHANGE(t,a,b,c,d,e,f)   __atomic_compare_exchange((t *)a,b,&c,d,e,f)
-#else
-#define ATOMIC_LOAD(t,a,b,c)              t b = __atomic_load((t *)a, c)
-#define COMPARE_EXCHANGE(t,a,b,c,d,e,f)   __atomic_compare_exchange((t *)a,b,c,d,e,f)
-#endif
-
-#define ATOMIC_GEN_OP(TYPE, MODE, NAME, OP) \
+#define ATOMIC_GEN_OP(TYPE, MODE, NAME, OP, RET) \
     TYPE __atomic_##NAME##_##MODE(volatile void *atom, TYPE value, int memorder) \
     { \
-        TYPE xchg; \
-        ATOMIC_LOAD(TYPE, atom, cmp, __ATOMIC_RELAXED); \
+        TYPE xchg, cmp; \
+        __atomic_load((TYPE *)atom, (TYPE *)&cmp, __ATOMIC_RELAXED); \
         do { \
             xchg = (OP); \
-        } while (!COMPARE_EXCHANGE(TYPE, atom, &cmp, xchg, true, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)); \
-        return cmp; \
+        } while (!__atomic_compare_exchange((TYPE *)atom, &cmp, &xchg, true, \
+                                            __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)); \
+        return RET; \
     }
 
 #define ATOMIC_EXCHANGE(TYPE, MODE) \
-    ATOMIC_GEN_OP(TYPE, MODE, exchange, value)
+    ATOMIC_GEN_OP(TYPE, MODE, exchange, value, cmp)
+#define ATOMIC_ADD_FETCH(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, add_fetch, (cmp + value), xchg)
+#define ATOMIC_SUB_FETCH(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, sub_fetch, (cmp - value), xchg)
+#define ATOMIC_AND_FETCH(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, and_fetch, (cmp & value), xchg)
+#define ATOMIC_OR_FETCH(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, or_fetch, (cmp | value), xchg)
+#define ATOMIC_XOR_FETCH(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, xor_fetch, (cmp ^ value), xchg)
+#define ATOMIC_NAND_FETCH(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, nand_fetch, ~(cmp & value), xchg)
 #define ATOMIC_FETCH_ADD(TYPE, MODE) \
-    ATOMIC_GEN_OP(TYPE, MODE, fetch_add, (cmp + value))
+    ATOMIC_GEN_OP(TYPE, MODE, fetch_add, (cmp + value), cmp)
 #define ATOMIC_FETCH_SUB(TYPE, MODE) \
-    ATOMIC_GEN_OP(TYPE, MODE, fetch_sub, (cmp - value))
+    ATOMIC_GEN_OP(TYPE, MODE, fetch_sub, (cmp - value), cmp)
 #define ATOMIC_FETCH_AND(TYPE, MODE) \
-    ATOMIC_GEN_OP(TYPE, MODE, fetch_and, (cmp & value))
+    ATOMIC_GEN_OP(TYPE, MODE, fetch_and, (cmp & value), cmp)
 #define ATOMIC_FETCH_OR(TYPE, MODE) \
-    ATOMIC_GEN_OP(TYPE, MODE, fetch_or, (cmp | value))
+    ATOMIC_GEN_OP(TYPE, MODE, fetch_or, (cmp | value), cmp)
 #define ATOMIC_FETCH_XOR(TYPE, MODE) \
-    ATOMIC_GEN_OP(TYPE, MODE, fetch_xor, (cmp ^ value))
-
-ATOMIC_X86_STORE(uint8_t, 1)
-ATOMIC_X86_STORE(uint16_t, 2)
-ATOMIC_X86_STORE(uint32_t, 4)
-
-ATOMIC_X86_LOAD(uint8_t, 1)
-ATOMIC_X86_LOAD(uint16_t, 2)
-ATOMIC_X86_LOAD(uint32_t, 4)
-
-ATOMIC_X86_COMPARE_EXCHANGE(uint8_t, 1, "b")
-ATOMIC_X86_COMPARE_EXCHANGE(uint16_t, 2, "w")
-ATOMIC_X86_COMPARE_EXCHANGE(uint32_t, 4, "l")
-
-ATOMIC_EXCHANGE(uint8_t, 1)
-ATOMIC_EXCHANGE(uint16_t, 2)
-ATOMIC_EXCHANGE(uint32_t, 4)
-
-ATOMIC_FETCH_ADD(uint8_t, 1)
-ATOMIC_FETCH_ADD(uint16_t, 2)
-ATOMIC_FETCH_ADD(uint32_t, 4)
-
-ATOMIC_FETCH_SUB(uint8_t, 1)
-ATOMIC_FETCH_SUB(uint16_t, 2)
-ATOMIC_FETCH_SUB(uint32_t, 4)
-
-ATOMIC_FETCH_AND(uint8_t, 1)
-ATOMIC_FETCH_AND(uint16_t, 2)
-ATOMIC_FETCH_AND(uint32_t, 4)
+    ATOMIC_GEN_OP(TYPE, MODE, fetch_xor, (cmp ^ value), cmp)
+#define ATOMIC_FETCH_NAND(TYPE, MODE) \
+    ATOMIC_GEN_OP(TYPE, MODE, fetch_nand, ~(cmp & value), cmp)
+
+#define ATOMIC_GEN(TYPE, SIZE, SUFFIX) \
+    ATOMIC_STORE(TYPE, SIZE) \
+    ATOMIC_LOAD(TYPE, SIZE) \
+    ATOMIC_COMPARE_EXCHANGE(TYPE, SIZE, SUFFIX) \
+    ATOMIC_EXCHANGE(TYPE, SIZE) \
+    ATOMIC_ADD_FETCH(TYPE, SIZE) \
+    ATOMIC_SUB_FETCH(TYPE, SIZE) \
+    ATOMIC_AND_FETCH(TYPE, SIZE) \
+    ATOMIC_OR_FETCH(TYPE, SIZE) \
+    ATOMIC_XOR_FETCH(TYPE, SIZE) \
+    ATOMIC_NAND_FETCH(TYPE, SIZE) \
+    ATOMIC_FETCH_ADD(TYPE, SIZE) \
+    ATOMIC_FETCH_SUB(TYPE, SIZE) \
+    ATOMIC_FETCH_AND(TYPE, SIZE) \
+    ATOMIC_FETCH_OR(TYPE, SIZE) \
+    ATOMIC_FETCH_XOR(TYPE, SIZE) \
+    ATOMIC_FETCH_NAND(TYPE, SIZE)
+
+ATOMIC_GEN(uint8_t, 1, "b")
+ATOMIC_GEN(uint16_t, 2, "w")
+ATOMIC_GEN(uint32_t, 4, "l")
+#if defined __x86_64__ || defined __aarch64__ || defined __riscv
+ATOMIC_GEN(uint64_t, 8, "q")
+#endif
 
-ATOMIC_FETCH_OR(uint8_t, 1)
-ATOMIC_FETCH_OR(uint16_t, 2)
-ATOMIC_FETCH_OR(uint32_t, 4)
+/* uses alias to allow building with gcc/clang */
+#ifdef __TINYC__
+#define ATOMIC(x)      __atomic_##x
+#else
+#define ATOMIC(x)      __tcc_atomic_##x
+#endif
 
-ATOMIC_FETCH_XOR(uint8_t, 1)
-ATOMIC_FETCH_XOR(uint16_t, 2)
-ATOMIC_FETCH_XOR(uint32_t, 4)
+void ATOMIC(signal_fence) (int memorder)
+{
+}
+
+void ATOMIC(thread_fence) (int memorder)
+{
+#if defined __i386__
+        __asm__ volatile("lock orl $0, (%esp)");
+#elif defined __x86_64__
+        __asm__ volatile("lock orq $0, (%rsp)");
+#elif defined __arm__
+        __asm__ volatile(".int 0xee070fba"); // mcr p15, 0, r0, c7, c10, 5
+#elif defined __aarch64__
+        __asm__ volatile(".int 0xd5033bbf"); // dmb ish
+#elif defined __riscv
+        __asm__ volatile(".int 0x0ff0000f"); // fence iorw,iorw
+#endif
+}
+
+bool ATOMIC(is_lock_free) (unsigned long size, const volatile void *ptr)
+{
+    bool ret;
+
+    switch (size) {
+    case 1: ret = true; break;
+    case 2: ret = true; break;
+    case 4: ret = true; break;
+#if defined __x86_64__ || defined __aarch64__ || defined __riscv
+    case 8: ret = true; break;
+#else
+    case 8: ret = false; break;
+#endif
+    default: ret = false; break;
+    }
+    return ret;
+}
 
-#if defined __x86_64__
-ATOMIC_X86_STORE(uint64_t, 8)
-ATOMIC_X86_LOAD(uint64_t, 8)
-ATOMIC_X86_COMPARE_EXCHANGE(uint64_t, 8, "q")
-ATOMIC_EXCHANGE(uint64_t, 8)
-ATOMIC_FETCH_ADD(uint64_t, 8)
-ATOMIC_FETCH_SUB(uint64_t, 8)
-ATOMIC_FETCH_AND(uint64_t, 8)
-ATOMIC_FETCH_OR(uint64_t, 8)
-ATOMIC_FETCH_XOR(uint64_t, 8)
+#ifndef __TINYC__
+void __atomic_signal_fence(int memorder) __attribute__((alias("__tcc_atomic_signal_fence")));
+void __atomic_thread_fence(int memorder) __attribute__((alias("__tcc_atomic_thread_fence")));
+bool __atomic_is_lock_free(unsigned long size, const volatile void *ptr) __attribute__((alias("__tcc_atomic_is_lock_free")));
 #endif
diff --git a/lib/tcov.c b/lib/tcov.c
index e5b9f2253..af09a734f 100644
--- a/lib/tcov.c
+++ b/lib/tcov.c
@@ -234,7 +234,7 @@ static void merge_test_coverage (tcov_file *file, FILE *fp,
 	size_t len = strlen (file->filename);
 
 	while (fgets(str, sizeof(str), fp) &&
-	       (p = strstr(str, "0:File:")) == NULL);
+	       (p = strstr(str, "0:File:")) == NULL) {}
         if ((p = strstr(str, "0:File:")) == NULL ||
 	    strncmp (p + strlen("0:File:"), file->filename, len) != 0 ||
 	    p[strlen("0:File:") + len] != ' ')
@@ -340,9 +340,9 @@ void __store_test_coverage (unsigned char * p)
         for (i = 0; i < nfile->n_func; i++) {
 	    func = &nfile->func[i];
 	
-	    while (curline < func->first_line)
-		if (fgets(str, sizeof(str), src))
-		    fprintf (fp, "        -:%5u:%s", curline++, str);
+	    while (curline < func->first_line &&
+		   fgets(str, sizeof(str), src))
+		fprintf (fp, "        -:%5u:%s", curline++, str);
 	    blocks = 0;
 	    blocks_run = 0;
 	    for (j = 0; j < func->n_line; j++) {
@@ -390,9 +390,9 @@ void __store_test_coverage (unsigned char * p)
 		if (same_line)
 		     lline++;
 
-	        while (curline < fline)
-		    if (fgets(str, sizeof(str), src))
-		         fprintf (fp, "        -:%5u:%s", curline++, str);
+	        while (curline < fline &&
+		       fgets(str, sizeof(str), src))
+		     fprintf (fp, "        -:%5u:%s", curline++, str);
 		while (curline < lline &&
 		       fgets(str, sizeof(str), src)) {
 		    if (count == 0)
diff --git a/libtcc.c b/libtcc.c
index 1feb74103..71b8d36a6 100644
--- a/libtcc.c
+++ b/libtcc.c
@@ -21,6 +21,7 @@
 #if !defined ONE_SOURCE || ONE_SOURCE
 #include "tccpp.c"
 #include "tccgen.c"
+#include "tccdbg.c"
 #include "tccasm.c"
 #include "tccelf.c"
 #include "tccrun.c"
@@ -67,10 +68,9 @@
 /* XXX: get rid of this ASAP (or maybe not) */
 ST_DATA struct TCCState *tcc_state;
 TCC_SEM(static tcc_compile_sem);
-
-#ifdef MEM_DEBUG
-static int nb_states;
-#endif
+/* an array of pointers to memory to be free'd after errors */
+ST_DATA void** stk_data;
+ST_DATA int nb_stk_data;
 
 /********************************************************/
 #ifdef _WIN32
@@ -249,6 +249,12 @@ ST_FUNC char *tcc_load_text(int fd)
 #undef malloc
 #undef realloc
 
+void mem_error(const char *msg)
+{
+    fprintf(stderr, "%s\n", msg);
+    exit (1);
+}
+
 #ifndef MEM_DEBUG
 
 PUB_FUNC void tcc_free(void *ptr)
@@ -259,9 +265,9 @@ PUB_FUNC void tcc_free(void *ptr)
 PUB_FUNC void *tcc_malloc(unsigned long size)
 {
     void *ptr;
-    ptr = malloc(size);
-    if (!ptr && size)
-        _tcc_error("memory full (malloc)");
+    ptr = malloc(size ? size : 1);
+    if (!ptr)
+        mem_error("memory full (malloc)");
     return ptr;
 }
 
@@ -277,9 +283,15 @@ PUB_FUNC void *tcc_mallocz(unsigned long size)
 PUB_FUNC void *tcc_realloc(void *ptr, unsigned long size)
 {
     void *ptr1;
-    ptr1 = realloc(ptr, size);
-    if (!ptr1 && size)
-        _tcc_error("memory full (realloc)");
+    if (size == 0) {
+	free(ptr);
+	ptr1 = NULL;
+    }
+    else {
+        ptr1 = realloc(ptr, size);
+        if (!ptr1)
+            mem_error("memory full (realloc)");
+    }
     return ptr1;
 }
 
@@ -317,9 +329,11 @@ struct mem_debug_header {
 
 typedef struct mem_debug_header mem_debug_header_t;
 
+TCC_SEM(static mem_sem);
 static mem_debug_header_t *mem_debug_chain;
 static unsigned mem_cur_size;
 static unsigned mem_max_size;
+static int nb_states;
 
 static mem_debug_header_t *malloc_check(void *ptr, const char *msg)
 {
@@ -344,7 +358,7 @@ PUB_FUNC void *tcc_malloc_debug(unsigned long size, const char *file, int line)
 
     header = malloc(sizeof(mem_debug_header_t) + size);
     if (!header)
-        _tcc_error("memory full (malloc)");
+        mem_error("memory full (malloc)");
 
     header->magic1 = MEM_DEBUG_MAGIC1;
     header->magic2 = MEM_DEBUG_MAGIC2;
@@ -355,15 +369,16 @@ PUB_FUNC void *tcc_malloc_debug(unsigned long size, const char *file, int line)
     strncpy(header->file_name, file + (ofs > 0 ? ofs : 0), MEM_DEBUG_FILE_LEN);
     header->file_name[MEM_DEBUG_FILE_LEN] = 0;
 
+    WAIT_SEM(&mem_sem);
     header->next = mem_debug_chain;
     header->prev = NULL;
     if (header->next)
         header->next->prev = header;
     mem_debug_chain = header;
-
     mem_cur_size += size;
     if (mem_cur_size > mem_max_size)
         mem_max_size = mem_cur_size;
+    POST_SEM(&mem_sem);
 
     return MEM_USER_PTR(header);
 }
@@ -374,6 +389,8 @@ PUB_FUNC void tcc_free_debug(void *ptr)
     if (!ptr)
         return;
     header = malloc_check(ptr, "tcc_free");
+
+    WAIT_SEM(&mem_sem);
     mem_cur_size -= header->size;
     header->size = (unsigned)-1;
     if (header->next)
@@ -382,6 +399,7 @@ PUB_FUNC void tcc_free_debug(void *ptr)
         header->prev->next = header->next;
     if (header == mem_debug_chain)
         mem_debug_chain = header->next;
+    POST_SEM(&mem_sem);
     free(header);
 }
 
@@ -400,11 +418,13 @@ PUB_FUNC void *tcc_realloc_debug(void *ptr, unsigned long size, const char *file
     if (!ptr)
         return tcc_malloc_debug(size, file, line);
     header = malloc_check(ptr, "tcc_realloc");
+
+    WAIT_SEM(&mem_sem);
     mem_cur_size -= header->size;
     mem_debug_chain_update = (header == mem_debug_chain);
     header = realloc(header, sizeof(mem_debug_header_t) + size);
     if (!header)
-        _tcc_error("memory full (realloc)");
+        mem_error("memory full (realloc)");
     header->size = size;
     write32le(MEM_DEBUG_CHECK3(header), MEM_DEBUG_MAGIC3);
     if (header->next)
@@ -416,6 +436,8 @@ PUB_FUNC void *tcc_realloc_debug(void *ptr, unsigned long size, const char *file
     mem_cur_size += size;
     if (mem_cur_size > mem_max_size)
         mem_max_size = mem_cur_size;
+    POST_SEM(&mem_sem);
+
     return MEM_USER_PTR(header);
 }
 
@@ -427,10 +449,13 @@ PUB_FUNC char *tcc_strdup_debug(const char *str, const char *file, int line)
     return ptr;
 }
 
-PUB_FUNC void tcc_memcheck(void)
+PUB_FUNC void tcc_memcheck(int d)
 {
-    if (mem_cur_size) {
+    WAIT_SEM(&mem_sem);
+    nb_states += d;
+    if (0 == nb_states && mem_cur_size) {
         mem_debug_header_t *header = mem_debug_chain;
+        fflush(stdout);
         fprintf(stderr, "MEM_DEBUG: mem_leak= %d bytes, mem_max_size= %d bytes\n",
             mem_cur_size, mem_max_size);
         while (header) {
@@ -438,13 +463,37 @@ PUB_FUNC void tcc_memcheck(void)
                 header->file_name, header->line_num, header->size);
             header = header->next;
         }
+        fflush(stderr);
+        mem_cur_size = 0;
+        mem_debug_chain = NULL;
 #if MEM_DEBUG-0 == 2
         exit(2);
 #endif
     }
+    POST_SEM(&mem_sem);
 }
+
 #endif /* MEM_DEBUG */
 
+#ifdef _WIN32
+# define realpath(file, buf) _fullpath(buf, file, 260)
+#endif
+
+/* for #pragma once */
+ST_FUNC int normalized_PATHCMP(const char *f1, const char *f2)
+{
+    char *p1, *p2;
+    int ret = 1;
+    if (!!(p1 = realpath(f1, NULL))) {
+        if (!!(p2 = realpath(f2, NULL))) {
+            ret = PATHCMP(p1, p2);
+            free(p2); /* using original free */
+        }
+        free(p1);
+    }
+    return ret;
+}
+
 #define free(p) use_tcc_free(p)
 #define malloc(s) use_tcc_malloc(s)
 #define realloc(p, s) use_tcc_realloc(p, s)
@@ -495,6 +544,8 @@ static void tcc_split_path(TCCState *s, void *p_ary, int *p_nb_ary, const char *
                 c = p[1], p += 2;
                 if (c == 'B')
                     cstr_cat(&str, s->tcc_lib_path, -1);
+                if (c == 'R')
+                    cstr_cat(&str, CONFIG_SYSROOT, -1);
                 if (c == 'f' && file) {
                     /* substitute current file's dir */
                     const char *f = file->true_filename;
@@ -534,12 +585,6 @@ static void error1(int mode, const char *fmt, va_list ap)
     TCCState *s1 = tcc_state;
     CString cs;
 
-    cstr_new(&cs);
-
-    if (s1 == NULL)
-        /* can happen only if called from tcc_malloc(): 'out of memory' */
-        goto no_file;
-
     tcc_exit_state(s1);
 
     if (mode == ERROR_WARN) {
@@ -560,6 +605,7 @@ static void error1(int mode, const char *fmt, va_list ap)
             return;
     }
 
+    cstr_new(&cs);
     f = NULL;
     if (s1->error_set_jmp_enabled) { /* we're called while parsing a file */
         /* use upper file if inline ":asm:" or token ":paste:" */
@@ -569,14 +615,12 @@ static void error1(int mode, const char *fmt, va_list ap)
     if (f) {
         for(pf = s1->include_stack; pf < s1->include_stack_ptr; pf++)
             cstr_printf(&cs, "In file included from %s:%d:\n",
-                (*pf)->filename, (*pf)->line_num);
+                (*pf)->filename, (*pf)->line_num - 1);
         cstr_printf(&cs, "%s:%d: ",
             f->filename, f->line_num - !!(tok_flags & TOK_FLAG_BOL));
     } else if (s1->current_filename) {
         cstr_printf(&cs, "%s: ", s1->current_filename);
     }
-
-no_file:
     if (0 == cs.size)
         cstr_printf(&cs, "tcc: ");
     cstr_printf(&cs, mode == ERROR_WARN ? "warning: " : "error: ");
@@ -592,15 +636,13 @@ static void error1(int mode, const char *fmt, va_list ap)
         s1->error_func(s1->error_opaque, (char*)cs.data);
     }
     cstr_free(&cs);
-    if (s1) {
-        if (mode != ERROR_WARN)
-            s1->nb_errors++;
-        if (mode != ERROR_ERROR)
-            return;
-        if (s1->error_set_jmp_enabled)
-            longjmp(s1->error_jmp_buf, 1);
+    if (mode != ERROR_WARN)
+        s1->nb_errors++;
+    if (mode == ERROR_ERROR && s1->error_set_jmp_enabled) {
+        while (nb_stk_data)
+            tcc_free(*(void**)stk_data[--nb_stk_data]);
+        longjmp(s1->error_jmp_buf, 1);
     }
-    exit(1);
 }
 
 LIBTCCAPI void tcc_set_error_func(TCCState *s, void *error_opaque, TCCErrorFunc error_func)
@@ -620,20 +662,24 @@ LIBTCCAPI void *tcc_get_error_opaque(TCCState *s)
 }
 
 /* error without aborting current compilation */
-PUB_FUNC void _tcc_error_noabort(const char *fmt, ...)
+PUB_FUNC int _tcc_error_noabort(const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
     error1(ERROR_NOABORT, fmt, ap);
     va_end(ap);
+    return -1;
 }
 
+#undef _tcc_error
 PUB_FUNC void _tcc_error(const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
-    for (;;) error1(ERROR_ERROR, fmt, ap);
+    error1(ERROR_ERROR, fmt, ap);
+    exit(1);
 }
+#define _tcc_error use_tcc_error_noabort
 
 PUB_FUNC void _tcc_warning(const char *fmt, ...)
 {
@@ -643,6 +689,7 @@ PUB_FUNC void _tcc_warning(const char *fmt, ...)
     va_end(ap);
 }
 
+
 /********************************************************/
 /* I/O layer */
 
@@ -674,7 +721,7 @@ ST_FUNC void tcc_close(void)
     BufferedFile *bf = file;
     if (bf->fd > 0) {
         close(bf->fd);
-        total_lines += bf->line_num;
+        total_lines += bf->line_num - 1;
     }
     if (bf->true_filename != bf->filename)
         tcc_free(bf->true_filename);
@@ -730,24 +777,25 @@ static int tcc_compile(TCCState *s1, int filetype, const char *str, int fd)
             file->fd = fd;
         }
 
-        tccelf_begin_file(s1);
         preprocess_start(s1, filetype);
         tccgen_init(s1);
+
         if (s1->output_type == TCC_OUTPUT_PREPROCESS) {
             tcc_preprocess(s1);
-        } else if (filetype & (AFF_TYPE_ASM | AFF_TYPE_ASMPP)) {
-            tcc_assemble(s1, !!(filetype & AFF_TYPE_ASMPP));
         } else {
-            tccgen_compile(s1);
+            tccelf_begin_file(s1);
+            if (filetype & (AFF_TYPE_ASM | AFF_TYPE_ASMPP)) {
+                tcc_assemble(s1, !!(filetype & AFF_TYPE_ASMPP));
+            } else {
+                tccgen_compile(s1);
+            }
+            tccelf_end_file(s1);
         }
     }
     tccgen_finish(s1);
     preprocess_end(s1);
-
     s1->error_set_jmp_enabled = 0;
     tcc_exit_state(s1);
-
-    tccelf_end_file(s1);
     return s1->nb_errors != 0 ? -1 : 0;
 }
 
@@ -782,7 +830,7 @@ LIBTCCAPI TCCState *tcc_new(void)
     if (!s)
         return NULL;
 #ifdef MEM_DEBUG
-    ++nb_states;
+    tcc_memcheck(1);
 #endif
 
 #undef gnu_ext
@@ -809,13 +857,13 @@ LIBTCCAPI TCCState *tcc_new(void)
 #ifdef TCC_TARGET_ARM
     s->float_abi = ARM_FLOAT_ABI;
 #endif
-
+#ifdef CONFIG_NEW_DTAGS
+    s->enable_new_dtags = 1;
+#endif
     s->ppfp = stdout;
     /* might be used in error() before preprocess_start() */
     s->include_stack_ptr = s->include_stack;
 
-    tccelf_new(s);
-
     tcc_set_lib_path(s, CONFIG_TCCDIR);
     return s;
 }
@@ -836,30 +884,39 @@ LIBTCCAPI void tcc_delete(TCCState *s1)
     tcc_free(s1->tcc_lib_path);
     tcc_free(s1->soname);
     tcc_free(s1->rpath);
+    tcc_free(s1->elf_entryname);
     tcc_free(s1->init_symbol);
     tcc_free(s1->fini_symbol);
+    tcc_free(s1->mapfile);
     tcc_free(s1->outfile);
     tcc_free(s1->deps_outfile);
+#if defined TCC_TARGET_MACHO
+    tcc_free(s1->install_name);
+#endif
     dynarray_reset(&s1->files, &s1->nb_files);
     dynarray_reset(&s1->target_deps, &s1->nb_target_deps);
     dynarray_reset(&s1->pragma_libs, &s1->nb_pragma_libs);
     dynarray_reset(&s1->argv, &s1->argc);
     cstr_free(&s1->cmdline_defs);
     cstr_free(&s1->cmdline_incl);
+    cstr_free(&s1->linker_arg);
 #ifdef TCC_IS_NATIVE
     /* free runtime memory */
     tcc_run_free(s1);
 #endif
-
+    tcc_free(s1->dState);
     tcc_free(s1);
 #ifdef MEM_DEBUG
-    if (0 == --nb_states)
-        tcc_memcheck();
+    tcc_memcheck(-1);
 #endif
 }
 
 LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
 {
+#ifdef CONFIG_TCC_PIE
+    if (output_type == TCC_OUTPUT_EXE)
+        output_type |= TCC_OUTPUT_DYN;
+#endif
     s->output_type = output_type;
 
     if (!s->nostdinc) {
@@ -867,16 +924,24 @@ LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
         /* -isystem paths have already been handled */
         tcc_add_sysinclude_path(s, CONFIG_TCC_SYSINCLUDEPATHS);
     }
+
+    if (output_type == TCC_OUTPUT_PREPROCESS) {
+        s->do_debug = 0;
+        return 0;
+    }
+
+    tccelf_new(s);
+    if (s->do_debug) {
+        /* add debug sections */
+        tcc_debug_new(s);
+    }
 #ifdef CONFIG_TCC_BCHECK
     if (s->do_bounds_check) {
         /* if bound checking, then add corresponding sections */
         tccelf_bounds_new(s);
     }
 #endif
-    if (s->do_debug) {
-        /* add debug sections */
-        tccelf_stab_new(s);
-    }
+
     if (output_type == TCC_OUTPUT_OBJ) {
         /* always elf for objects */
         s->output_format = TCC_OUTPUT_FORMAT_ELF;
@@ -903,9 +968,9 @@ LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
 #else
     /* paths for crt objects */
     tcc_split_path(s, &s->crt_paths, &s->nb_crt_paths, CONFIG_TCC_CRTPREFIX);
+
     /* add libc crt1/crti objects */
-    if ((output_type == TCC_OUTPUT_EXE || output_type == TCC_OUTPUT_DLL) &&
-        !s->nostdlib) {
+    if (output_type != TCC_OUTPUT_MEMORY && !s->nostdlib) {
 #if TARGETOS_OpenBSD
         if (output_type != TCC_OUTPUT_DLL)
 	    tcc_add_crt(s, "crt0.o");
@@ -919,7 +984,7 @@ LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
         tcc_add_crt(s, "crti.o");
         if (s->static_link)
             tcc_add_crt(s, "crtbeginT.o");
-        else if (output_type == TCC_OUTPUT_DLL)
+        else if (output_type & TCC_OUTPUT_DYN)
             tcc_add_crt(s, "crtbeginS.o");
         else
             tcc_add_crt(s, "crtbegin.o");
@@ -929,10 +994,15 @@ LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
         tcc_add_crt(s, "crti.o");
         if (s->static_link)
             tcc_add_crt(s, "crtbeginT.o");
-        else if (output_type == TCC_OUTPUT_DLL)
+        else if (output_type & TCC_OUTPUT_DYN)
             tcc_add_crt(s, "crtbeginS.o");
         else
             tcc_add_crt(s, "crtbegin.o");
+#elif defined TARGETOS_ANDROID
+        if (output_type != TCC_OUTPUT_DLL)
+            tcc_add_crt(s, "crtbegin_dynamic.o");
+        else
+            tcc_add_crt(s, "crtbegin_so.o");
 #else
         if (output_type != TCC_OUTPUT_DLL)
             tcc_add_crt(s, "crt1.o");
@@ -955,11 +1025,29 @@ LIBTCCAPI int tcc_add_sysinclude_path(TCCState *s, const char *pathname)
     return 0;
 }
 
-ST_FUNC DLLReference *tcc_add_dllref(TCCState *s1, const char *dllname)
+/* add/update a 'DLLReference', Just find if level == -1  */
+ST_FUNC DLLReference *tcc_add_dllref(TCCState *s1, const char *dllname, int level)
 {
-    DLLReference *ref = tcc_mallocz(sizeof(DLLReference) + strlen(dllname));
+    DLLReference *ref = NULL;
+    int i;
+    for (i = 0; i < s1->nb_loaded_dlls; i++)
+        if (0 == strcmp(s1->loaded_dlls[i]->name, dllname)) {
+            ref = s1->loaded_dlls[i];
+            break;
+        }
+    if (level == -1)
+        return ref;
+    if (ref) {
+        if (level < ref->level)
+            ref->level = level;
+        ref->found = 1;
+        return ref;
+    }
+    ref = tcc_mallocz(sizeof(DLLReference) + strlen(dllname));
     strcpy(ref->name, dllname);
     dynarray_add(&s1->loaded_dlls, &s1->nb_loaded_dlls, ref);
+    ref->level = level;
+    ref->index = s1->nb_loaded_dlls;
     return ref;
 }
 
@@ -998,6 +1086,11 @@ ST_FUNC int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
         filename = buf;
 #endif
 
+    /* ignore binary files with -E */
+    if (s1->output_type == TCC_OUTPUT_PREPROCESS
+        && (flags & AFF_TYPE_BIN))
+        return 0;
+
     /* open the file */
     fd = _tcc_open(s1, filename);
     if (fd < 0) {
@@ -1040,7 +1133,7 @@ ST_FUNC int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
                     soname = macho_tbd_soname(filename);
                 dl = dlopen(soname, RTLD_GLOBAL | RTLD_LAZY);
                 if (dl)
-                    tcc_add_dllref(s1, soname)->handle = dl, ret = 0;
+                    tcc_add_dllref(s1, soname, 0)->handle = dl, ret = 0;
 	        if (filename != soname)
 		    tcc_free((void *)soname);
 #endif
@@ -1049,7 +1142,7 @@ ST_FUNC int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
             } else {
                 ret = macho_load_tbd(s1, fd, filename, (flags & AFF_REFERENCED_DLL) != 0);
             }
-            break;
+            goto check_success;
         default:
         {
             const char *ext = tcc_fileextension(filename);
@@ -1068,7 +1161,7 @@ ST_FUNC int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
 #ifdef TCC_IS_NATIVE
                 void* dl = dlopen(filename, RTLD_GLOBAL | RTLD_LAZY);
                 if (dl)
-                    tcc_add_dllref(s1, filename)->handle = dl, ret = 0;
+                    tcc_add_dllref(s1, filename, 0)->handle = dl, ret = 0;
 #endif
             } else
                 ret = tcc_load_dll(s1, fd, filename, (flags & AFF_REFERENCED_DLL) != 0);
@@ -1147,21 +1240,29 @@ static int tcc_add_library_internal(TCCState *s, const char *fmt,
     return -1;
 }
 
-#ifndef TCC_TARGET_MACHO
 /* find and load a dll. Return non zero if not found */
 ST_FUNC int tcc_add_dll(TCCState *s, const char *filename, int flags)
 {
     return tcc_add_library_internal(s, "%s/%s", filename, flags,
         s->library_paths, s->nb_library_paths);
 }
-#endif
+
+/* find [cross-]libtcc1.a and tcc helper objects in library path */
+ST_FUNC void tcc_add_support(TCCState *s1, const char *filename)
+{
+    char buf[100];
+    if (CONFIG_TCC_CROSSPREFIX[0])
+        filename = strcat(strcpy(buf, CONFIG_TCC_CROSSPREFIX), filename);
+    if (tcc_add_dll(s1, filename, 0) < 0)
+        tcc_error_noabort("%s not found", filename);
+}
 
 #if !defined TCC_TARGET_PE && !defined TCC_TARGET_MACHO
 ST_FUNC int tcc_add_crt(TCCState *s1, const char *filename)
 {
     if (-1 == tcc_add_library_internal(s1, "%s/%s",
         filename, 0, s1->crt_paths, s1->nb_crt_paths))
-        tcc_error_noabort("file '%s' not found", filename);
+        return tcc_error_noabort("file '%s' not found", filename);
     return 0;
 }
 #endif
@@ -1320,6 +1421,14 @@ static void copy_linker_arg(char **pp, const char *s, int sep)
     pstrncpy(l + (*pp = tcc_realloc(p, q - s + l + 1)), s, q - s);
 }
 
+static void args_parser_add_file(TCCState *s, const char* filename, int filetype)
+{
+    struct filespec *f = tcc_malloc(sizeof *f + strlen(filename));
+    f->type = filetype;
+    strcpy(f->name, filename);
+    dynarray_add(&s->files, &s->nb_files, f);
+}
+
 /* set linker options */
 static int tcc_set_linker(TCCState *s, const char *option)
 {
@@ -1335,7 +1444,8 @@ static int tcc_set_linker(TCCState *s, const char *option)
             s->symbolic = 1;
         } else if (link_option(option, "nostdlib", &p)) {
             s->nostdlib = 1;
-        } else if (link_option(option, "e=", &p)) {
+        } else if (link_option(option, "e=", &p)
+               ||  link_option(option, "entry=", &p)) {
             copy_linker_arg(&s->elf_entryname, p, 0);
         } else if (link_option(option, "fini=", &p)) {
             copy_linker_arg(&s->fini_symbol, p, 0);
@@ -1347,6 +1457,9 @@ static int tcc_set_linker(TCCState *s, const char *option)
         } else if (link_option(option, "init=", &p)) {
             copy_linker_arg(&s->init_symbol, p, 0);
             ignoring = 1;
+        } else if (link_option(option, "Map=", &p)) {
+            copy_linker_arg(&s->mapfile, p, 0);
+            ignoring = 1;
         } else if (link_option(option, "oformat=", &p)) {
 #if defined(TCC_TARGET_PE)
             if (strstart("pe-", &p)) {
@@ -1381,6 +1494,8 @@ static int tcc_set_linker(TCCState *s, const char *option)
             s->section_align = strtoul(p, &end, 16);
         } else if (link_option(option, "soname=", &p)) {
             copy_linker_arg(&s->soname, p, 0);
+        } else if (link_option(option, "install_name=", &p)) {
+            copy_linker_arg(&s->soname, p, 0);
 #ifdef TCC_TARGET_PE
         } else if (link_option(option, "large-address-aware", &p)) {
             s->pe_characteristics |= 0x20;
@@ -1412,6 +1527,16 @@ static int tcc_set_linker(TCCState *s, const char *option)
 #endif
             } else
                 goto err;
+#endif
+#ifdef TCC_TARGET_MACHO
+        } else if (link_option(option, "all_load", &p)) {
+	    s->filetype |= AFF_WHOLE_ARCHIVE;
+        } else if (link_option(option, "force_load", &p)) {
+	    s->filetype |= AFF_WHOLE_ARCHIVE;
+            args_parser_add_file(s, p, AFF_TYPE_LIB | (s->filetype & ~AFF_TYPE_MASK));
+            s->nb_libraries++;
+        } else if (link_option(option, "single_module", &p)) {
+            ignoring = 1;
 #endif
         } else if (ret = link_option(option, "?whole-archive", &p), ret) {
             if (ret > 0)
@@ -1424,7 +1549,7 @@ static int tcc_set_linker(TCCState *s, const char *option)
             return 0;
         } else {
     err:
-            tcc_error("unsupported linker option '%s'", option);
+            return tcc_error_noabort("unsupported linker option '%s'", option);
         }
         if (ignoring)
             tcc_warning_c(warn_unsupported)("unsupported linker option '%s'", option);
@@ -1457,6 +1582,7 @@ enum {
     TCC_OPTION_ba,
     TCC_OPTION_g,
     TCC_OPTION_c,
+    TCC_OPTION_dumpmachine,
     TCC_OPTION_dumpversion,
     TCC_OPTION_d,
     TCC_OPTION_static,
@@ -1488,9 +1614,17 @@ enum {
     TCC_OPTION_MF,
     TCC_OPTION_MM,
     TCC_OPTION_MMD,
+    TCC_OPTION_MP,
     TCC_OPTION_x,
     TCC_OPTION_ar,
     TCC_OPTION_impdef,
+    TCC_OPTION_dynamiclib,
+    TCC_OPTION_flat_namespace,
+    TCC_OPTION_two_levelnamespace,
+    TCC_OPTION_undefined,
+    TCC_OPTION_install_name,
+    TCC_OPTION_compatibility_version ,
+    TCC_OPTION_current_version,
 };
 
 #define TCC_OPTION_HAS_ARG 0x0001
@@ -1518,7 +1652,15 @@ static const TCCOption tcc_options[] = {
     { "b", TCC_OPTION_b, 0 },
 #endif
     { "g", TCC_OPTION_g, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
+#ifdef TCC_TARGET_MACHO
+    { "compatibility_version", TCC_OPTION_compatibility_version, TCC_OPTION_HAS_ARG },
+    { "current_version", TCC_OPTION_current_version, TCC_OPTION_HAS_ARG },
+#endif
     { "c", TCC_OPTION_c, 0 },
+#ifdef TCC_TARGET_MACHO
+    { "dynamiclib", TCC_OPTION_dynamiclib, 0 },
+#endif
+    { "dumpmachine", TCC_OPTION_dumpmachine, 0},
     { "dumpversion", TCC_OPTION_dumpversion, 0},
     { "d", TCC_OPTION_d, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
     { "static", TCC_OPTION_static, 0 },
@@ -1538,6 +1680,9 @@ static const TCCOption tcc_options[] = {
     { "mfloat-abi", TCC_OPTION_mfloat_abi, TCC_OPTION_HAS_ARG },
 #endif
     { "m", TCC_OPTION_m, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
+#ifdef TCC_TARGET_MACHO
+    { "flat_namespace", TCC_OPTION_flat_namespace, 0 },
+#endif
     { "f", TCC_OPTION_f, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
     { "isystem", TCC_OPTION_isystem, TCC_OPTION_HAS_ARG },
     { "include", TCC_OPTION_include, TCC_OPTION_HAS_ARG },
@@ -1551,10 +1696,16 @@ static const TCCOption tcc_options[] = {
     { "MF", TCC_OPTION_MF, TCC_OPTION_HAS_ARG },
     { "MM", TCC_OPTION_MM, 0},
     { "MMD", TCC_OPTION_MMD, 0},
+    { "MP", TCC_OPTION_MP, 0},
     { "x", TCC_OPTION_x, TCC_OPTION_HAS_ARG },
     { "ar", TCC_OPTION_ar, 0},
 #ifdef TCC_TARGET_PE
     { "impdef", TCC_OPTION_impdef, 0},
+#endif
+#ifdef TCC_TARGET_MACHO
+    { "install_name", TCC_OPTION_install_name, TCC_OPTION_HAS_ARG },
+    { "two_levelnamespace", TCC_OPTION_two_levelnamespace, 0 },
+    { "undefined", TCC_OPTION_undefined, TCC_OPTION_HAS_ARG },
 #endif
     /* ignored (silently, except after -Wunsupported) */
     { "arch", 0, TCC_OPTION_HAS_ARG},
@@ -1567,23 +1718,6 @@ static const TCCOption tcc_options[] = {
     { NULL, 0, 0 },
 };
 
-typedef struct stdvalue {
-    uint32_t cversion;
-    const char * name;
-} stdvalue;
-
-/* accepted values for the -std= option */
-static const stdvalue std_values[] = {
-    { 199901, "c99" },
-    { 201112, "c11" },
-    { 201710, "c17" },
-    { 202000, "c2x" },
-    { 199901, "gnu99" },
-    { 201112, "gnu11" },
-    { 201710, "gnu17" },
-    { 202000, "gnu2x" }
-};
-
 typedef struct FlagDef {
     uint16_t offset;
     uint16_t flags;
@@ -1656,14 +1790,6 @@ static int set_flag(TCCState *s, const FlagDef *flags, const char *name)
     return ret;
 }
 
-static void args_parser_add_file(TCCState *s, const char* filename, int filetype)
-{
-    struct filespec *f = tcc_malloc(sizeof *f + strlen(filename));
-    f->type = filetype;
-    strcpy(f->name, filename);
-    dynarray_add(&s->files, &s->nb_files, f);
-}
-
 static int args_parser_make_argv(const char *r, int *argc, char ***argv)
 {
     int ret = 0, q, c;
@@ -1697,7 +1823,7 @@ static int args_parser_make_argv(const char *r, int *argc, char ***argv)
 }
 
 /* read list file */
-static void args_parser_listfile(TCCState *s,
+static int args_parser_listfile(TCCState *s,
     const char *filename, int optind, int *pargc, char ***pargv)
 {
     TCCState *s1 = s;
@@ -1708,7 +1834,7 @@ static void args_parser_listfile(TCCState *s,
 
     fd = open(filename, O_RDONLY | O_BINARY);
     if (fd < 0)
-        tcc_error("listfile '%s' not found", filename);
+        return tcc_error_noabort("listfile '%s' not found", filename);
 
     p = tcc_load_text(fd);
     for (i = 0; i < *pargc; ++i)
@@ -1720,7 +1846,28 @@ static void args_parser_listfile(TCCState *s,
     tcc_free(p);
     dynarray_reset(&s->argv, &s->argc);
     *pargc = s->argc = argc, *pargv = s->argv = argv;
+    return 0;
+}
+
+#if defined TCC_TARGET_MACHO
+static uint32_t parse_version(TCCState *s1, const char *version)
+{
+    uint32_t a = 0;
+    uint32_t b = 0;
+    uint32_t c = 0;
+    char* last;
+
+    a = strtoul(version, &last, 10);
+    if (*last == '.') {
+        b = strtoul(&last[1], &last, 10);
+        if (*last == '.')
+             c = strtoul(&last[1], &last, 10);
+    }
+    if (*last || a > 0xffff || b > 0xff || c > 0xff)
+        tcc_error_noabort("version a.b.c not correct: %s", version);
+    return (a << 16) | (b << 8) | c;
 }
+#endif
 
 PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
 {
@@ -1729,17 +1876,17 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
     const char *optarg, *r;
     const char *run = NULL;
     int x;
-    CString linker_arg; /* collect -Wl options */
     int tool = 0, arg_start = 0, noaction = optind;
     char **argv = *pargv;
     int argc = *pargc;
 
-    cstr_new(&linker_arg);
+    cstr_reset(&s->linker_arg);
 
     while (optind < argc) {
         r = argv[optind];
         if (r[0] == '@' && r[1] != '\0') {
-            args_parser_listfile(s, r + 1, optind, &argc, &argv);
+            if (args_parser_listfile(s, r + 1, optind, &argc, &argv))
+                return -1;
             continue;
         }
         optind++;
@@ -1750,22 +1897,27 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
         }
 reparse:
         if (r[0] != '-' || r[1] == '\0') {
-            if (r[0] != '@') /* allow "tcc file(s) -run @ args ..." */
-                args_parser_add_file(s, r, s->filetype);
+            args_parser_add_file(s, r, s->filetype);
             if (run) {
-                tcc_set_options(s, run);
+dorun:
+                if (tcc_set_options(s, run))
+                    return -1;
                 arg_start = optind - 1;
                 break;
             }
             continue;
         }
 
+        /* allow "tcc files... -run -- args ..." */
+        if (r[1] == '-' && r[2] == '\0' && run)
+            goto dorun;
+
         /* find option in table */
         for(popt = tcc_options; ; ++popt) {
             const char *p1 = popt->name;
             const char *r1 = r + 1;
             if (p1 == NULL)
-                tcc_error("invalid option -- '%s'", r);
+                return tcc_error_noabort("invalid option -- '%s'", r);
             if (!strstart(p1, &r1))
                 continue;
             optarg = r1;
@@ -1773,7 +1925,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
                 if (*r1 == '\0' && !(popt->flags & TCC_OPTION_NOSEP)) {
                     if (optind >= argc)
                 arg_err:
-                        tcc_error("argument to '%s' is missing", r);
+                        return tcc_error_noabort("argument to '%s' is missing", r);
                     optarg = argv[optind++];
                 }
             } else if (*r1 != '\0')
@@ -1803,6 +1955,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
         case TCC_OPTION_B:
             /* set tcc utilities path (mainly for tcc development) */
             tcc_set_lib_path(s, optarg);
+            ++noaction;
             break;
         case TCC_OPTION_l:
             args_parser_add_file(s, optarg, AFF_TYPE_LIB | (s->filetype & ~AFF_TYPE_MASK));
@@ -1816,26 +1969,32 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             break;
 #ifdef CONFIG_TCC_BACKTRACE
         case TCC_OPTION_bt:
-            s->rt_num_callers = atoi(optarg);
+            s->rt_num_callers = atoi(optarg); /* zero = default (6) */
+        enable_backtrace:
             s->do_backtrace = 1;
-            s->do_debug = 1;
+            s->do_debug = s->do_debug ? s->do_debug : 1;
+	    s->dwarf = DWARF_VERSION;
             break;
-#endif
 #ifdef CONFIG_TCC_BCHECK
         case TCC_OPTION_b:
             s->do_bounds_check = 1;
-            s->do_backtrace = 1;
-            s->do_debug = 1;
-            break;
+            goto enable_backtrace;
+#endif
 #endif
         case TCC_OPTION_g:
-            /* Use "-g" as alias for "-g1". Use "-g0" to disable debug */
-            /* Other common used values: "-g0", "-g1", "-g2" and "-g3" */
-            /* no failure with unsupported options */
-            if (isnum(*optarg))
-                s->do_debug = atoi(optarg);
-            else
-                s->do_debug = 1;
+            s->do_debug = 2;
+            s->dwarf = DWARF_VERSION;
+            if (strstart("dwarf", &optarg)) {
+                s->dwarf = (*optarg) ? (0 - atoi(optarg)) : DEFAULT_DWARF_VERSION;
+            } else if (isnum(*optarg)) {
+                x = *optarg - '0';
+                /* -g0 = no info, -g1 = lines/functions only, -g2 = full info */
+                s->do_debug = x > 2 ? 2 : x == 0 && s->do_backtrace ? 1 : x;
+#ifdef TCC_TARGET_PE
+            } else if (0 == strcmp(".pdb", optarg)) {
+                s->dwarf = 5, s->do_debug |= 16;
+#endif
+            }
             break;
         case TCC_OPTION_c:
             x = TCC_OUTPUT_OBJ;
@@ -1860,21 +2019,8 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             s->static_link = 1;
             break;
         case TCC_OPTION_std:
-            x = 0;
-            if (*optarg == '=') {
-                do {
-                    if (strcmp(std_values[x].name, &optarg[1]) == 0) {
-                        x = std_values[x].cversion;
-                    }
-                    else
-                        ++x;
-                } while (x < (sizeof(std_values)/sizeof(stdvalue)));
-            }
-            if (x > (sizeof(std_values)/sizeof(stdvalue)))
-                s->cversion = x;
-            else
-                goto unsupported_option;
-
+            if (strcmp(optarg, "=c11") == 0)
+                s->cversion = 201112;
             break;
         case TCC_OPTION_shared:
             x = TCC_OUTPUT_DLL;
@@ -1908,11 +2054,12 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             break;
         case TCC_OPTION_run:
 #ifndef TCC_IS_NATIVE
-            tcc_error("-run is not available in a cross compiler");
-#endif
+            return tcc_error_noabort("-run is not available in a cross compiler");
+#else
             run = optarg;
             x = TCC_OUTPUT_MEMORY;
             goto set_output_type;
+#endif
         case TCC_OPTION_v:
             do ++s->verbose; while (*optarg++ == 'v');
             ++noaction;
@@ -1929,7 +2076,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             } else if (!strcmp(optarg, "hard"))
                 s->float_abi = ARM_HARD_FLOAT;
             else
-                tcc_error("unsupported float abi '%s'", optarg);
+                return tcc_error_noabort("unsupported float abi '%s'", optarg);
             break;
 #endif
         case TCC_OPTION_m:
@@ -1953,11 +2100,14 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             s->rdynamic = 1;
             break;
         case TCC_OPTION_Wl:
-            if (linker_arg.size)
-                --linker_arg.size, cstr_ccat(&linker_arg, ',');
-            cstr_cat(&linker_arg, optarg, 0);
-            if (tcc_set_linker(s, linker_arg.data))
-                cstr_free(&linker_arg);
+            if (s->linker_arg.size)
+                ((char*)s->linker_arg.data)[s->linker_arg.size - 1] = ',';
+            cstr_cat(&s->linker_arg, optarg, 0);
+            x = tcc_set_linker(s, s->linker_arg.data);
+            if (x)
+                cstr_reset(&s->linker_arg);
+            if (x < 0)
+                return -1;
             break;
         case TCC_OPTION_Wp:
             r = optarg;
@@ -1986,6 +2136,43 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
         case TCC_OPTION_MF:
             s->deps_outfile = tcc_strdup(optarg);
             break;
+        case TCC_OPTION_MP:
+            s->gen_phony_deps = 1;
+            break;
+        case TCC_OPTION_dumpmachine:
+            /* this is a best guess, please refine as necessary */
+            printf("%s",
+#ifdef TCC_TARGET_I386
+                   "i386-pc"
+#elif defined TCC_TARGET_X86_64
+                   "x86_64-pc"
+#elif defined TCC_TARGET_C67
+                   "c67"
+#elif defined TCC_TARGET_ARM
+                   "arm"
+#elif defined TCC_TARGET_ARM64
+                   "aarch64"
+#elif defined TCC_TARGET_RISCV64
+                   "riscv64"
+#endif
+                   "-"
+#ifdef TCC_TARGET_PE
+                   "mingw32"
+#elif defined(TCC_TARGET_MACHO)
+                   "apple-darwin"
+#elif TARGETOS_FreeBSD || TARGETOS_FreeBSD_kernel
+                   "freebsd"
+#elif TARGETOS_OpenBSD
+                   "openbsd"
+#elif TARGETOS_NetBSD
+                   "netbsd"
+#else
+                   "linux-gnu"
+#endif
+                   "\n"
+                   );
+            exit(0);
+            break;
         case TCC_OPTION_dumpversion:
             printf ("%s\n", TCC_VERSION);
             exit(0);
@@ -2005,11 +2192,7 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             s->filetype = x | (s->filetype & ~AFF_TYPE_MASK);
             break;
         case TCC_OPTION_O:
-            /* Use "-O" as alias for "-O1". */
-            /* Other common used values: "-O0", "-O1", "-O2", "-O3" and "-Os" */
-            /* no failure with unsupported options */
-            x = *optarg;
-            s->optimize = isnum(x) ? atoi(optarg) : (x) ? x : 1;
+            s->optimize = atoi(optarg);
             break;
         case TCC_OPTION_print_search_dirs:
             x = OPT_PRINT_DIRS;
@@ -2017,12 +2200,32 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
         case TCC_OPTION_impdef:
             x = OPT_IMPDEF;
             goto extra_action;
+#if defined TCC_TARGET_MACHO
+        case TCC_OPTION_dynamiclib:
+            x = TCC_OUTPUT_DLL;
+            goto set_output_type;
+        case TCC_OPTION_flat_namespace:
+	     break;
+        case TCC_OPTION_two_levelnamespace:
+	     break;
+        case TCC_OPTION_undefined:
+	     break;
+        case TCC_OPTION_install_name:
+	    s->install_name = tcc_strdup(optarg);
+            break;
+        case TCC_OPTION_compatibility_version:
+	    s->compatibility_version = parse_version(s, optarg);
+            break;
+        case TCC_OPTION_current_version:
+	    s->current_version = parse_version(s, optarg);;
+            break;
+#endif
         case TCC_OPTION_ar:
             x = OPT_AR;
         extra_action:
             arg_start = optind - 1;
             if (arg_start != noaction)
-                tcc_error("cannot parse %s here", r);
+                return tcc_error_noabort("cannot parse %s here", r);
             tool = x;
             break;
         default:
@@ -2031,8 +2234,8 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
             break;
         }
     }
-    if (linker_arg.size) {
-        r = linker_arg.data;
+    if (s->linker_arg.size) {
+        r = s->linker_arg.data;
         goto arg_err;
     }
     *pargc = argc - arg_start;
@@ -2048,34 +2251,33 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *pargc, char ***pargv, int optind)
     return OPT_HELP;
 }
 
-LIBTCCAPI void tcc_set_options(TCCState *s, const char *r)
+LIBTCCAPI int tcc_set_options(TCCState *s, const char *r)
 {
     char **argv = NULL;
-    int argc = 0;
+    int argc = 0, ret;
     args_parser_make_argv(r, &argc, &argv);
-    tcc_parse_args(s, &argc, &argv, 0);
+    ret = tcc_parse_args(s, &argc, &argv, 0);
     dynarray_reset(&argv, &argc);
+    return ret < 0 ? ret : 0;
 }
 
 PUB_FUNC void tcc_print_stats(TCCState *s1, unsigned total_time)
 {
-    if (total_time < 1)
+    if (!total_time)
         total_time = 1;
-    if (total_bytes < 1)
-        total_bytes = 1;
-    fprintf(stderr, "* %d idents, %d lines, %d bytes\n"
-                    "* %0.3f s, %u lines/s, %0.1f MB/s\n",
+    fprintf(stderr, "# %d idents, %d lines, %u bytes\n"
+                    "# %0.3f s, %u lines/s, %0.1f MB/s\n",
            total_idents, total_lines, total_bytes,
            (double)total_time/1000,
            (unsigned)total_lines*1000/total_time,
            (double)total_bytes/1000/total_time);
-    fprintf(stderr, "* text %d, data.rw %d, data.ro %d, bss %d bytes\n",
+    fprintf(stderr, "# text %u, data.rw %u, data.ro %u, bss %u bytes\n",
            s1->total_output[0],
            s1->total_output[1],
            s1->total_output[2],
            s1->total_output[3]
            );
 #ifdef MEM_DEBUG
-    fprintf(stderr, "* %d bytes memory used\n", mem_max_size);
+    fprintf(stderr, "# %d bytes memory used\n", mem_max_size);
 #endif
 }
diff --git a/libtcc.h b/libtcc.h
index 25d247a79..8450ba8b9 100644
--- a/libtcc.h
+++ b/libtcc.h
@@ -34,7 +34,7 @@ LIBTCCAPI TCCErrorFunc tcc_get_error_func(TCCState *s);
 LIBTCCAPI void *tcc_get_error_opaque(TCCState *s);
 
 /* set options as from command line (multiple supported) */
-LIBTCCAPI void tcc_set_options(TCCState *s, const char *str);
+LIBTCCAPI int tcc_set_options(TCCState *s, const char *str);
 
 /*****************************/
 /* preprocessor */
@@ -65,11 +65,11 @@ LIBTCCAPI int tcc_compile_string(TCCState *s, const char *buf);
 
 /* set output type. MUST BE CALLED before any compilation */
 LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type);
-#define TCC_OUTPUT_MEMORY   1 /* output will be run in memory (default) */
+#define TCC_OUTPUT_MEMORY   1 /* output will be run in memory */
 #define TCC_OUTPUT_EXE      2 /* executable file */
-#define TCC_OUTPUT_DLL      3 /* dynamic library */
-#define TCC_OUTPUT_OBJ      4 /* object file */
-#define TCC_OUTPUT_PREPROCESS 5 /* only preprocess (used internally) */
+#define TCC_OUTPUT_DLL      4 /* dynamic library */
+#define TCC_OUTPUT_OBJ      3 /* object file */
+#define TCC_OUTPUT_PREPROCESS 5 /* only preprocess */
 
 /* equivalent to -Lpath option */
 LIBTCCAPI int tcc_add_library_path(TCCState *s, const char *pathname);
diff --git a/riscv64-asm.c b/riscv64-asm.c
index 30662df6d..7020f63bb 100644
--- a/riscv64-asm.c
+++ b/riscv64-asm.c
@@ -19,6 +19,61 @@ ST_FUNC void gen_le32(int c);
 #define USING_GLOBALS
 #include "tcc.h"
 
+enum {
+    OPT_REG,
+    OPT_IM12S,
+    OPT_IM32,
+};
+#define C_ENCODE_RS1(register_index) ((register_index) << 7)
+#define C_ENCODE_RS2(register_index) ((register_index) << 2)
+#define ENCODE_RD(register_index) ((register_index) << 7)
+#define ENCODE_RS1(register_index) ((register_index) << 15)
+#define ENCODE_RS2(register_index) ((register_index) << 20)
+#define NTH_BIT(b, n) ((b >> n) & 1)
+#define OP_IM12S (1 << OPT_IM12S)
+#define OP_IM32 (1 << OPT_IM32)
+#define OP_REG (1 << OPT_REG)
+
+typedef struct Operand {
+    uint32_t type;
+    union {
+        uint8_t reg;
+        uint16_t regset;
+        ExprValue e;
+    };
+} Operand;
+
+static void asm_binary_opcode(TCCState* s1, int token);
+ST_FUNC void asm_clobber(uint8_t *clobber_regs, const char *str);
+ST_FUNC void asm_compute_constraints(ASMOperand *operands, int nb_operands, int nb_outputs, const uint8_t *clobber_regs, int *pout_reg);
+static void asm_emit_b(int token, uint32_t opcode, const Operand *rs1, const Operand *rs2, const Operand *imm);
+static void asm_emit_i(int token, uint32_t opcode, const Operand *rd, const Operand *rs1, const Operand *rs2);
+static void asm_emit_j(int token, uint32_t opcode, const Operand *rd, const Operand *rs2);
+static void asm_emit_opcode(uint32_t opcode);
+static void asm_emit_r(int token, uint32_t opcode, const Operand *rd, const Operand *rs1, const Operand *rs2);
+static void asm_emit_s(int token, uint32_t opcode, const Operand *rs1, const Operand *rs2, const Operand *imm);
+static void asm_emit_u(int token, uint32_t opcode, const Operand *rd, const Operand *rs2);
+ST_FUNC void asm_gen_code(ASMOperand *operands, int nb_operands, int nb_outputs, int is_output, uint8_t *clobber_regs, int out_reg);
+static void asm_nullary_opcode(TCCState *s1, int token);
+ST_FUNC void asm_opcode(TCCState *s1, int token);
+static int asm_parse_csrvar(int t);
+ST_FUNC int asm_parse_regvar(int t);
+static void asm_ternary_opcode(TCCState *s1, int token);
+static void asm_unary_opcode(TCCState *s1, int token);
+ST_FUNC void gen_expr32(ExprValue *pe);
+static void parse_operand(TCCState *s1, Operand *op);
+ST_FUNC void subst_asm_operand(CString *add_str, SValue *sv, int modifier);
+/* C extension */
+static void asm_emit_ca(int token, uint16_t opcode, const Operand *rd, const Operand *rs2);
+static void asm_emit_cb(int token, uint16_t opcode, const Operand *rs1, const Operand *imm);
+static void asm_emit_ci(int token, uint16_t opcode, const Operand *rd, const Operand *imm);
+static void asm_emit_ciw(int token, uint16_t opcode, const Operand *rd, const Operand *imm);
+static void asm_emit_cj(int token, uint16_t opcode, const Operand *imm);
+static void asm_emit_cl(int token, uint16_t opcode, const Operand *rd, const Operand *rs1, const Operand *imm);
+static void asm_emit_cr(int token, uint16_t opcode, const Operand *rd, const Operand *rs2);
+static void asm_emit_cs(int token, uint16_t opcode, const Operand *rs2, const Operand *rs1, const Operand *imm);
+static void asm_emit_css(int token, uint16_t opcode, const Operand *rs2, const Operand *imm);
+
 /* XXX: make it faster ? */
 ST_FUNC void g(int c)
 {
@@ -63,6 +118,9 @@ static void asm_emit_opcode(uint32_t opcode) {
 
 static void asm_nullary_opcode(TCCState *s1, int token)
 {
+    static const Operand nil = {.type = OP_REG};
+    static const Operand zimm = {.type = OP_IM12S};
+
     switch (token) {
     // Sync instructions
 
@@ -75,55 +133,41 @@ static void asm_nullary_opcode(TCCState *s1, int token)
 
     // System calls
 
-    case TOK_ASM_scall: // I (pseudo)
+    case TOK_ASM_ecall: // I (pseudo)
         asm_emit_opcode((0x1C << 2) | 3 | (0 << 12));
         return;
-    case TOK_ASM_sbreak: // I (pseudo)
+    case TOK_ASM_ebreak: // I (pseudo)
         asm_emit_opcode((0x1C << 2) | 3 | (0 << 12) | (1 << 20));
         return;
 
-    // Privileged Instructions
+    // Other
 
-    case TOK_ASM_ecall:
-        asm_emit_opcode((0x1C << 2) | 3 | (0 << 20));
-        return;
-    case TOK_ASM_ebreak:
-        asm_emit_opcode((0x1C << 2) | 3 | (1 << 20));
+    case TOK_ASM_nop:
+        asm_emit_i(token, (4 << 2) | 3, &nil, &nil, &zimm);
         return;
 
-    // Other
-
     case TOK_ASM_wfi:
         asm_emit_opcode((0x1C << 2) | 3 | (0x105 << 20));
         return;
 
+    /* C extension */
+    case TOK_ASM_c_ebreak:
+        asm_emit_cr(token, 2 | (9 << 12), &nil, &nil);
+        return;
+    case TOK_ASM_c_nop:
+        asm_emit_ci(token, 1, &nil, &zimm);
+        return;
+
     default:
         expect("nullary instruction");
     }
 }
 
-enum {
-    OPT_REG,
-    OPT_IM12S,
-    OPT_IM32,
-};
-#define OP_REG    (1 << OPT_REG)
-#define OP_IM32   (1 << OPT_IM32)
-#define OP_IM12S   (1 << OPT_IM12S)
-
-typedef struct Operand {
-    uint32_t type;
-    union {
-        uint8_t reg;
-        uint16_t regset;
-        ExprValue e;
-    };
-} Operand;
-
 /* Parse a text containing operand and store the result in OP */
 static void parse_operand(TCCState *s1, Operand *op)
 {
-    ExprValue e;
+    ExprValue e = {0};
+    Sym label = {0};
     int8_t reg;
 
     op->type = 0;
@@ -136,34 +180,47 @@ static void parse_operand(TCCState *s1, Operand *op)
     } else if (tok == '$') {
         /* constant value */
         next(); // skip '#' or '$'
+    } else if ((e.v = asm_parse_csrvar(tok)) != -1) {
+        next();
+    } else {
+        asm_expr(s1, &e);
     }
-    asm_expr(s1, &e);
     op->type = OP_IM32;
     op->e = e;
+    /* compare against unsigned 12-bit maximum */
     if (!op->e.sym) {
-        if ((int) op->e.v >= -2048 && (int) op->e.v < 2048)
+        if (op->e.v < 0x1000)
             op->type = OP_IM12S;
-    } else
+    } else if (op->e.sym->type.t & (VT_EXTERN | VT_STATIC)) {
+        label.type.t = VT_VOID | VT_STATIC;
+
+        /* use the medium PIC model: GOT, auipc, lw */
+        if (op->e.sym->type.t & VT_STATIC)
+            greloca(cur_text_section, op->e.sym, ind, R_RISCV_PCREL_HI20, 0);
+        else
+            greloca(cur_text_section, op->e.sym, ind, R_RISCV_GOT_HI20, 0);
+        put_extern_sym(&label, cur_text_section, ind, 0);
+        greloca(cur_text_section, &label, ind+4, R_RISCV_PCREL_LO12_I, 0);
+
+        op->type = OP_IM12S;
+        op->e.v = 0;
+    } else {
         expect("operand");
+    }
 }
 
-#define ENCODE_RS1(register_index) ((register_index) << 15)
-#define ENCODE_RS2(register_index) ((register_index) << 20)
-#define ENCODE_RD(register_index) ((register_index) << 7)
-
-// Note: Those all map to CSR--so they are pseudo-instructions.
 static void asm_unary_opcode(TCCState *s1, int token)
 {
     uint32_t opcode = (0x1C << 2) | 3 | (2 << 12);
     Operand op;
+    static const Operand nil = {.type = OP_REG};
+
     parse_operand(s1, &op);
-    if (op.type != OP_REG) {
-        expect("register");
-        return;
-    }
+    /* Note: Those all map to CSR--so they are pseudo-instructions. */
     opcode |= ENCODE_RD(op.reg);
 
     switch (token) {
+    /* pseudoinstructions */
     case TOK_ASM_rdcycle:
         asm_emit_opcode(opcode | (0xC00 << 20));
         return;
@@ -182,6 +239,19 @@ static void asm_unary_opcode(TCCState *s1, int token)
     case TOK_ASM_rdinstreth:
         asm_emit_opcode(opcode | (0xC82 << 20) | ENCODE_RD(op.reg));
         return;
+    /* C extension */
+    case TOK_ASM_c_j:
+        asm_emit_cj(token, 1 | (5 << 13), &op);
+        return;
+    case TOK_ASM_c_jal: /* RV32C-only */
+        asm_emit_cj(token, 1 | (1 << 13), &op);
+        return;
+    case TOK_ASM_c_jalr:
+        asm_emit_cr(token, 2 | (9 << 12), &op, &nil);
+        return;
+    case TOK_ASM_c_jr:
+        asm_emit_cr(token, 2 | (8 << 12), &op, &nil);
+        return;
     default:
         expect("unary instruction");
     }
@@ -224,6 +294,118 @@ static void asm_binary_opcode(TCCState* s1, int token)
     case TOK_ASM_auipc:
         asm_emit_u(token, (0x05 << 2) | 3, &ops[0], &ops[1]);
         return;
+    case TOK_ASM_jal:
+        asm_emit_j(token, 0x6f, ops, ops + 1);
+        return;
+
+    /* C extension */
+    case TOK_ASM_c_add:
+        asm_emit_cr(token, 2 | (9 << 12), ops, ops + 1);
+        return;
+    case TOK_ASM_c_mv:
+        asm_emit_cr(token, 2 | (8 << 12), ops, ops + 1);
+        return;
+
+    case TOK_ASM_c_addi16sp:
+        asm_emit_ci(token, 1 | (3 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_addi:
+        asm_emit_ci(token, 1, ops, ops + 1);
+        return;
+    case TOK_ASM_c_addiw:
+        asm_emit_ci(token, 1 | (1 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_fldsp:
+        asm_emit_ci(token, 2 | (1 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_flwsp: /* RV32FC-only */
+        asm_emit_ci(token, 2 | (3 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_ldsp:
+        asm_emit_ci(token, 2 | (3 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_li:
+        asm_emit_ci(token, 1 | (2 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_lui:
+        asm_emit_ci(token, 1 | (3 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_lwsp:
+        asm_emit_ci(token, 2 | (2 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_slli:
+        asm_emit_ci(token, 2, ops, ops + 1);
+        return;
+
+    case TOK_ASM_c_addi4spn:
+        asm_emit_ciw(token, 0, ops, ops + 1);
+        return;
+
+#define CA (1 | (3 << 10) | (4 << 13))
+    case TOK_ASM_c_addw:
+        asm_emit_ca(token, CA | (1 << 5) | (1 << 12), ops, ops + 1);
+        return;
+    case TOK_ASM_c_and:
+        asm_emit_ca(token, CA | (3 << 5), ops, ops + 1);
+        return;
+    case TOK_ASM_c_or:
+        asm_emit_ca(token, CA | (2 << 5), ops, ops + 1);
+        return;
+    case TOK_ASM_c_sub:
+        asm_emit_ca(token, CA, ops, ops + 1);
+        return;
+    case TOK_ASM_c_subw:
+        asm_emit_ca(token, CA | (1 << 12), ops, ops + 1);
+        return;
+    case TOK_ASM_c_xor:
+        asm_emit_ca(token, CA | (1 << 5), ops, ops + 1);
+        return;
+#undef CA
+
+    case TOK_ASM_c_andi:
+        asm_emit_cb(token, 1 | (2 << 10) | (4 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_beqz:
+        asm_emit_cb(token, 1 | (6 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_bnez:
+        asm_emit_cb(token, 1 | (7 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_srai:
+        asm_emit_cb(token, 1 | (1 << 10) | (4 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_srli:
+        asm_emit_cb(token, 1 | (4 << 13), ops, ops + 1);
+        return;
+
+    case TOK_ASM_c_sdsp:
+        asm_emit_css(token, 2 | (7 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_swsp:
+        asm_emit_css(token, 2 | (6 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_fswsp: /* RV32FC-only */
+        asm_emit_css(token, 2 | (7 << 13), ops, ops + 1);
+        return;
+    case TOK_ASM_c_fsdsp:
+        asm_emit_css(token, 2 | (5 << 13), ops, ops + 1);
+        return;
+
+    /* pseudoinstructions */
+    /* rd, sym */
+    case TOK_ASM_la:
+        /* auipc rd, 0 */
+        asm_emit_u(token, 3 | (5 << 2), ops, ops + 1);
+        /* lw rd, rd, 0 */
+        asm_emit_i(token, 3 | (2 << 12), ops, ops, ops + 1);
+        return;
+    case TOK_ASM_lla:
+        /* auipc rd, 0 */
+        asm_emit_u(token, 3 | (5 << 2), ops, ops + 1);
+        /* addi rd, rd, 0 */
+        asm_emit_i(token, 3 | (4 << 2), ops, ops, ops + 1);
+        return;
+
     default:
         expect("binary instruction");
     }
@@ -266,7 +448,7 @@ static void asm_emit_i(int token, uint32_t opcode, const Operand* rd, const Oper
         return;
     }
     if (rs2->type != OP_IM12S) {
-        tcc_error("'%s': Expected second source operand that is an immediate value between 0 and 4095", get_tok_str(token, NULL));
+        tcc_error("'%s': Expected second source operand that is an immediate value between 0 and 8191", get_tok_str(token, NULL));
         return;
     }
     /* I-type instruction:
@@ -279,7 +461,42 @@ static void asm_emit_i(int token, uint32_t opcode, const Operand* rd, const Oper
     gen_le32(opcode | ENCODE_RD(rd->reg) | ENCODE_RS1(rs1->reg) | (rs2->e.v << 20));
 }
 
-static void asm_shift_opcode(TCCState *s1, int token)
+static void asm_emit_j(int token, uint32_t opcode, const Operand* rd, const Operand* rs2)
+{
+    uint32_t imm;
+
+    if (rd->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+    if (rs2->type != OP_IM12S && rs2->type != OP_IM32) {
+        tcc_error("'%s': Expected second source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    imm = rs2->e.v;
+
+    /* even offsets in a +- 1 MiB range */
+    if (imm > 0x1ffffe) {
+        tcc_error("'%s': Expected second source operand that is an immediate value between 0 and 0x1fffff", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm & 1) {
+        tcc_error("'%s': Expected second source operand that is an even immediate value", get_tok_str(token, NULL));
+        return;
+    }
+    /* J-type instruction:
+    31      imm[20]
+    30...21 imm[10:1]
+    20      imm[11]
+    19...12 imm[19:12]
+    11...7  rd
+    6...0   opcode */
+    gen_le32(opcode | ENCODE_RD(rd->reg) | (((imm >> 20) & 1) << 31) | (((imm >> 1) & 0x3ff) << 21) | (((imm >> 11) & 1) << 20) | (((imm >> 12) & 0xff) << 12));
+}
+
+static void asm_ternary_opcode(TCCState *s1, int token)
 {
     Operand ops[3];
     parse_operand(s1, &ops[0]);
@@ -331,27 +548,7 @@ static void asm_shift_opcode(TCCState *s1, int token)
     case TOK_ASM_sraiw:
         asm_emit_i(token, (0x6 << 2) | 3 | (5 << 12), &ops[0], &ops[1], &ops[2]);
         return;
-    default:
-        expect("shift instruction");
-    }
-}
-
-static void asm_data_processing_opcode(TCCState* s1, int token)
-{
-    Operand ops[3];
-    parse_operand(s1, &ops[0]);
-    if (tok == ',')
-        next();
-    else
-        expect("','");
-    parse_operand(s1, &ops[1]);
-    if (tok == ',')
-        next();
-    else
-        expect("','");
-    parse_operand(s1, &ops[2]);
 
-    switch (token) {
     // Arithmetic (RD,RS1,(RS2|IMM)); R-format, I-format or U-format
 
     case TOK_ASM_add:
@@ -408,64 +605,32 @@ static void asm_data_processing_opcode(TCCState* s1, int token)
     case TOK_ASM_sltiu:
          asm_emit_i(token, (0x4 << 2) | 3 | (3 << 12), &ops[0], &ops[1], &ops[2]);
          return;
-    default:
-         expect("known data processing instruction");
-    }
-}
 
-/* caller: Add funct3 to opcode */
-static void asm_emit_s(int token, uint32_t opcode, const Operand* rs1, const Operand* rs2, const Operand* imm)
-{
-    if (rs1->type != OP_REG) {
-        tcc_error("'%s': Expected first source operand that is a register", get_tok_str(token, NULL));
+    /* indirect jump (RD, RS1, IMM); I-format */
+    case TOK_ASM_jalr:
+        asm_emit_i(token, 0x67 | (0 << 12), ops, ops + 1, ops + 2);
         return;
-    }
-    if (rs2->type != OP_REG) {
-        tcc_error("'%s': Expected second source operand that is a register", get_tok_str(token, NULL));
+
+    /* branch (RS1, RS2, IMM); B-format */
+    case TOK_ASM_beq:
+        asm_emit_b(token, 0x63 | (0 << 12), ops, ops + 1, ops + 2);
         return;
-    }
-    if (imm->type != OP_IM12S) {
-        tcc_error("'%s': Expected third operand that is an immediate value between 0 and 0xfff", get_tok_str(token, NULL));
+    case TOK_ASM_bne:
+        asm_emit_b(token, 0x63 | (1 << 12), ops, ops + 1, ops + 2);
         return;
-    }
-    {
-        uint16_t v = imm->e.v;
-        /* S-type instruction:
-	        31...25 imm[11:5]
-	        24...20 rs2
-	        19...15 rs1
-	        14...12 funct3
-	        11...7 imm[4:0]
-	        6...0 opcode
-        opcode always fixed pos. */
-        gen_le32(opcode | ENCODE_RS1(rs1->reg) | ENCODE_RS2(rs2->reg) | ((v & 0x1F) << 7) | ((v >> 5) << 25));
-    }
-}
-
-static void asm_data_transfer_opcode(TCCState* s1, int token)
-{
-    Operand ops[3];
-    parse_operand(s1, &ops[0]);
-    if (ops[0].type != OP_REG) {
-        expect("register");
+    case TOK_ASM_blt:
+        asm_emit_b(token, 0x63 | (4 << 12), ops, ops + 1, ops + 2);
         return;
-    }
-    if (tok == ',')
-        next();
-    else
-        expect("','");
-    parse_operand(s1, &ops[1]);
-    if (ops[1].type != OP_REG) {
-        expect("register");
+    case TOK_ASM_bge:
+        asm_emit_b(token, 0x63 | (5 << 12), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_bltu:
+        asm_emit_b(token, 0x63 | (6 << 12), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_bgeu:
+        asm_emit_b(token, 0x63 | (7 << 12), ops, ops + 1, ops + 2);
         return;
-    }
-    if (tok == ',')
-        next();
-    else
-        expect("','");
-    parse_operand(s1, &ops[2]);
 
-    switch (token) {
     // Loads (RD,RS1,I); I-format
 
     case TOK_ASM_lb:
@@ -506,91 +671,180 @@ static void asm_data_transfer_opcode(TCCState* s1, int token)
          asm_emit_s(token, (0x8 << 2) | 3 | (3 << 12), &ops[0], &ops[1], &ops[2]);
          return;
 
-    default:
-         expect("known data transfer instruction");
-    }
-}
+    /* M extension */
+    case TOK_ASM_div:
+        asm_emit_r(token, 0x33 | (4 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_divu:
+        asm_emit_r(token, 0x33 | (5 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_divuw:
+        asm_emit_r(token, 0x3b | (5 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_divw:
+        asm_emit_r(token, 0x3b | (4 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_mul:
+        asm_emit_r(token, 0x33 | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_mulh:
+        asm_emit_r(token, 0x33 | (1 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_mulhsu:
+        asm_emit_r(token, 0x33 | (2 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_mulhu:
+        asm_emit_r(token, 0x33 | (3 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_mulw:
+        asm_emit_r(token, 0x3b | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_rem:
+        asm_emit_r(token, 0x33 | (6 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_remu:
+        asm_emit_r(token, 0x33 | (7 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_remuw:
+        asm_emit_r(token, 0x3b | (7 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_remw:
+        asm_emit_r(token, 0x3b | (6 << 12) | (1 << 25), ops, ops + 1, ops + 2);
+        return;
 
-static void asm_branch_opcode(TCCState* s1, int token)
-{
-    // Branch (RS1,RS2,IMM); SB-format
-    uint32_t opcode = (0x18 << 2) | 3;
-    uint32_t offset = 0;
-    Operand ops[3];
-    parse_operand(s1, &ops[0]);
-    if (ops[0].type != OP_REG) {
-        expect("register");
+    /* Zicsr extension; (rd, csr, rs/uimm) */
+    case TOK_ASM_csrrc:
+        asm_emit_i(token, 0x73 | (3 << 12), ops, ops + 2, ops + 1);
         return;
-    }
-    if (tok == ',')
-        next();
-    else
-        expect("','");
-    parse_operand(s1, &ops[1]);
-    if (ops[1].type != OP_REG) {
-        expect("register");
+    case TOK_ASM_csrrci:
+        /* using rs1 field for uimmm */
+        ops[2].type = OP_REG;
+        asm_emit_i(token, 0x73 | (7 << 12), ops, ops + 2, ops + 1);
+        return;
+    case TOK_ASM_csrrs:
+        asm_emit_i(token, 0x73 | (2 << 12), ops, ops + 2, ops + 1);
+        return;
+    case TOK_ASM_csrrsi:
+        ops[2].type = OP_REG;
+        asm_emit_i(token, 0x73 | (6 << 12), ops, ops + 2, ops + 1);
+        return;
+    case TOK_ASM_csrrw:
+        asm_emit_i(token, 0x73 | (1 << 12), ops, ops + 2, ops + 1);
+        return;
+    case TOK_ASM_csrrwi:
+        ops[2].type = OP_REG;
+        asm_emit_i(token, 0x73 | (5 << 12), ops, ops + 2, ops + 1);
         return;
-    }
-    if (tok == ',')
-        next();
-    else
-        expect("','");
-    parse_operand(s1, &ops[2]);
 
-    if (ops[2].type != OP_IM12S) {
-        tcc_error("'%s': Expected third operand that is an immediate value between 0 and 0xfff", get_tok_str(token, NULL));
+    /* C extension */
+    /* register-based loads and stores (RD, RS1, IMM); CL-format */
+    case TOK_ASM_c_fld:
+        asm_emit_cl(token, 1 << 13, ops, ops + 1, ops + 2);
         return;
-    }
-    offset = ops[2].e.v;
-    if (offset & 1) {
-        tcc_error("'%s': Expected third operand that is an even immediate value", get_tok_str(token, NULL));
+    case TOK_ASM_c_flw: /* RV32FC-only */
+        asm_emit_cl(token, 3 << 13, ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_c_fsd:
+        asm_emit_cs(token, 5 << 13, ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_c_fsw: /* RV32FC-only */
+        asm_emit_cs(token, 7 << 13, ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_c_ld:
+        asm_emit_cl(token, 3 << 13, ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_c_lw:
+        asm_emit_cl(token, 2 << 13, ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_c_sd:
+        asm_emit_cs(token, 7 << 13, ops, ops + 1, ops + 2);
+        return;
+    case TOK_ASM_c_sw:
+        asm_emit_cs(token, 6 << 13, ops, ops + 1, ops + 2);
         return;
-    }
 
-    switch (token) {
-    case TOK_ASM_beq:
-        opcode |= 0 << 12;
-        break;
-    case TOK_ASM_bne:
-        opcode |= 1 << 12;
-        break;
-    case TOK_ASM_blt:
-        opcode |= 4 << 12;
-        break;
-    case TOK_ASM_bge:
-        opcode |= 5 << 12;
-        break;
-    case TOK_ASM_bltu:
-        opcode |= 6 << 12;
-        break;
-    case TOK_ASM_bgeu:
-        opcode |= 7 << 12;
-        break;
     default:
-        expect("known branch instruction");
+        expect("ternary instruction");
     }
-    asm_emit_opcode(opcode | ENCODE_RS1(ops[0].reg) | ENCODE_RS2(ops[1].reg) | (((offset >> 1) & 0xF) << 8) | (((offset >> 5) & 0x1f) << 25) | (((offset >> 11) & 1) << 7) | (((offset >> 12) & 1) << 31));
 }
 
-ST_FUNC void asm_opcode(TCCState *s1, int token)
+/* caller: Add funct3 to opcode */
+static void asm_emit_s(int token, uint32_t opcode, const Operand* rs1, const Operand* rs2, const Operand* imm)
 {
-    switch (token) {
-    case TOK_ASM_fence:
-    case TOK_ASM_fence_i:
-    case TOK_ASM_scall:
-    case TOK_ASM_sbreak:
-    case TOK_ASM_ecall:
-    case TOK_ASM_ebreak:
-    case TOK_ASM_mrts:
-    case TOK_ASM_mrth:
-    case TOK_ASM_hrts:
-    case TOK_ASM_wfi:
-        asm_nullary_opcode(s1, token);
+    if (rs1->type != OP_REG) {
+        tcc_error("'%s': Expected first source operand that is a register", get_tok_str(token, NULL));
         return;
-
-    case TOK_ASM_rdcycle:
-    case TOK_ASM_rdcycleh:
-    case TOK_ASM_rdtime:
+    }
+    if (rs2->type != OP_REG) {
+        tcc_error("'%s': Expected second source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+    if (imm->type != OP_IM12S) {
+        tcc_error("'%s': Expected third operand that is an immediate value between 0 and 8191", get_tok_str(token, NULL));
+        return;
+    }
+    {
+        uint16_t v = imm->e.v;
+        /* S-type instruction:
+	        31...25 imm[11:5]
+	        24...20 rs2
+	        19...15 rs1
+	        14...12 funct3
+	        11...7 imm[4:0]
+	        6...0 opcode
+        opcode always fixed pos. */
+        gen_le32(opcode | ENCODE_RS1(rs1->reg) | ENCODE_RS2(rs2->reg) | ((v & 0x1F) << 7) | ((v >> 5) << 25));
+    }
+}
+
+static void asm_emit_b(int token, uint32_t opcode, const Operand *rs1, const Operand *rs2, const Operand *imm)
+{
+    uint32_t offset;
+
+    if (rs1->type != OP_REG) {
+        tcc_error("'%s': Expected first source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+    if (rs2->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+    if (imm->type != OP_IM12S) {
+        tcc_error("'%s': Expected second source operand that is an immediate value between 0 and 8191", get_tok_str(token, NULL));
+        return;
+    }
+
+    offset = imm->e.v;
+
+    /* B-type instruction:
+    31      imm[12]
+    30...25 imm[10:5]
+    24...20 rs2
+    19...15 rs1
+    14...12 funct3
+    8...11  imm[4:1]
+    7       imm[11]
+    6...0   opcode */
+    asm_emit_opcode(opcode | ENCODE_RS1(rs1->reg) | ENCODE_RS2(rs2->reg) | (((offset >> 1) & 0xF) << 8) | (((offset >> 5) & 0x1f) << 25) | (((offset >> 11) & 1) << 7) | (((offset >> 12) & 1) << 31));
+}
+
+ST_FUNC void asm_opcode(TCCState *s1, int token)
+{
+    switch (token) {
+    case TOK_ASM_ebreak:
+    case TOK_ASM_ecall:
+    case TOK_ASM_fence:
+    case TOK_ASM_fence_i:
+    case TOK_ASM_hrts:
+    case TOK_ASM_mrth:
+    case TOK_ASM_mrts:
+    case TOK_ASM_wfi:
+        asm_nullary_opcode(s1, token);
+        return;
+
+    case TOK_ASM_rdcycle:
+    case TOK_ASM_rdcycleh:
+    case TOK_ASM_rdtime:
     case TOK_ASM_rdtimeh:
     case TOK_ASM_rdinstret:
     case TOK_ASM_rdinstreth:
@@ -599,72 +853,143 @@ ST_FUNC void asm_opcode(TCCState *s1, int token)
 
     case TOK_ASM_lui:
     case TOK_ASM_auipc:
+    case TOK_ASM_jal:
         asm_binary_opcode(s1, token);
         return;
 
-    case TOK_ASM_sll:
-    case TOK_ASM_slli:
-    case TOK_ASM_srl:
-    case TOK_ASM_srli:
-    case TOK_ASM_sra:
-    case TOK_ASM_srai:
-    case TOK_ASM_sllw:
-    case TOK_ASM_slld:
-    case TOK_ASM_slliw:
-    case TOK_ASM_sllid:
-    case TOK_ASM_srlw:
-    case TOK_ASM_srld:
-    case TOK_ASM_srliw:
-    case TOK_ASM_srlid:
-    case TOK_ASM_sraw:
-    case TOK_ASM_srad:
-    case TOK_ASM_sraiw:
-    case TOK_ASM_sraid:
-        asm_shift_opcode(s1, token);
-        return;
-
     case TOK_ASM_add:
     case TOK_ASM_addi:
-    case TOK_ASM_sub:
-    case TOK_ASM_addw:
-    case TOK_ASM_addd:
     case TOK_ASM_addiw:
-    case TOK_ASM_addid:
-    case TOK_ASM_subw:
-    case TOK_ASM_subd:
-    case TOK_ASM_xor:
-    case TOK_ASM_xori:
-    case TOK_ASM_or:
-    case TOK_ASM_ori:
+    case TOK_ASM_addw:
     case TOK_ASM_and:
     case TOK_ASM_andi:
-    case TOK_ASM_slt:
-    case TOK_ASM_slti:
-    case TOK_ASM_sltu:
-    case TOK_ASM_sltiu:
-        asm_data_processing_opcode(s1, token);
-
+    case TOK_ASM_beq:
+    case TOK_ASM_bge:
+    case TOK_ASM_bgeu:
+    case TOK_ASM_blt:
+    case TOK_ASM_bltu:
+    case TOK_ASM_bne:
+    case TOK_ASM_jalr:
     case TOK_ASM_lb:
-    case TOK_ASM_lh:
-    case TOK_ASM_lw:
     case TOK_ASM_lbu:
-    case TOK_ASM_lhu:
     case TOK_ASM_ld:
+    case TOK_ASM_lh:
+    case TOK_ASM_lhu:
+    case TOK_ASM_lw:
     case TOK_ASM_lwu:
+    case TOK_ASM_or:
+    case TOK_ASM_ori:
     case TOK_ASM_sb:
+    case TOK_ASM_sd:
     case TOK_ASM_sh:
+    case TOK_ASM_sll:
+    case TOK_ASM_slli:
+    case TOK_ASM_slliw:
+    case TOK_ASM_sllw:
+    case TOK_ASM_slt:
+    case TOK_ASM_slti:
+    case TOK_ASM_sltiu:
+    case TOK_ASM_sltu:
+    case TOK_ASM_sra:
+    case TOK_ASM_srai:
+    case TOK_ASM_sraiw:
+    case TOK_ASM_sraw:
+    case TOK_ASM_srl:
+    case TOK_ASM_srli:
+    case TOK_ASM_srliw:
+    case TOK_ASM_srlw:
+    case TOK_ASM_sub:
+    case TOK_ASM_subw:
     case TOK_ASM_sw:
-    case TOK_ASM_sd:
-        asm_data_transfer_opcode(s1, token);
+    case TOK_ASM_xor:
+    case TOK_ASM_xori:
+    /* M extension */
+    case TOK_ASM_div:
+    case TOK_ASM_divu:
+    case TOK_ASM_divuw:
+    case TOK_ASM_divw:
+    case TOK_ASM_mul:
+    case TOK_ASM_mulh:
+    case TOK_ASM_mulhsu:
+    case TOK_ASM_mulhu:
+    case TOK_ASM_mulw:
+    case TOK_ASM_rem:
+    case TOK_ASM_remu:
+    case TOK_ASM_remuw:
+    case TOK_ASM_remw:
+    /* Zicsr extension */
+    case TOK_ASM_csrrc:
+    case TOK_ASM_csrrci:
+    case TOK_ASM_csrrs:
+    case TOK_ASM_csrrsi:
+    case TOK_ASM_csrrw:
+    case TOK_ASM_csrrwi:
+        asm_ternary_opcode(s1, token);
         return;
 
-    case TOK_ASM_beq:
-    case TOK_ASM_bne:
-    case TOK_ASM_blt:
-    case TOK_ASM_bge:
-    case TOK_ASM_bltu:
-    case TOK_ASM_bgeu:
-        asm_branch_opcode(s1, token);
+    /* C extension */
+    case TOK_ASM_c_ebreak:
+    case TOK_ASM_c_nop:
+        asm_nullary_opcode(s1, token);
+        return;
+
+    case TOK_ASM_c_j:
+    case TOK_ASM_c_jal:
+    case TOK_ASM_c_jalr:
+    case TOK_ASM_c_jr:
+        asm_unary_opcode(s1, token);
+        return;
+
+    case TOK_ASM_c_add:
+    case TOK_ASM_c_addi16sp:
+    case TOK_ASM_c_addi4spn:
+    case TOK_ASM_c_addi:
+    case TOK_ASM_c_addiw:
+    case TOK_ASM_c_addw:
+    case TOK_ASM_c_and:
+    case TOK_ASM_c_andi:
+    case TOK_ASM_c_beqz:
+    case TOK_ASM_c_bnez:
+    case TOK_ASM_c_fldsp:
+    case TOK_ASM_c_flwsp:
+    case TOK_ASM_c_fsdsp:
+    case TOK_ASM_c_fswsp:
+    case TOK_ASM_c_ldsp:
+    case TOK_ASM_c_li:
+    case TOK_ASM_c_lui:
+    case TOK_ASM_c_lwsp:
+    case TOK_ASM_c_mv:
+    case TOK_ASM_c_or:
+    case TOK_ASM_c_sdsp:
+    case TOK_ASM_c_slli:
+    case TOK_ASM_c_srai:
+    case TOK_ASM_c_srli:
+    case TOK_ASM_c_sub:
+    case TOK_ASM_c_subw:
+    case TOK_ASM_c_swsp:
+    case TOK_ASM_c_xor:
+        asm_binary_opcode(s1, token);
+        return;
+
+    case TOK_ASM_c_fld:
+    case TOK_ASM_c_flw:
+    case TOK_ASM_c_fsd:
+    case TOK_ASM_c_fsw:
+    case TOK_ASM_c_ld:
+    case TOK_ASM_c_lw:
+    case TOK_ASM_c_sd:
+    case TOK_ASM_c_sw:
+        asm_ternary_opcode(s1, token);
+        return;
+
+    /* pseudoinstructions */
+    case TOK_ASM_nop:
+        asm_nullary_opcode(s1, token);
+        return;
+
+    case TOK_ASM_la:
+    case TOK_ASM_lla:
+        asm_binary_opcode(s1, token);
         return;
 
     default:
@@ -672,6 +997,32 @@ ST_FUNC void asm_opcode(TCCState *s1, int token)
     }
 }
 
+static int asm_parse_csrvar(int t)
+{
+    switch (t) {
+    case TOK_ASM_cycle:
+        return 0xc00;
+    case TOK_ASM_fcsr:
+        return 3;
+    case TOK_ASM_fflags:
+        return 1;
+    case TOK_ASM_frm:
+        return 2;
+    case TOK_ASM_instret:
+        return 0xc02;
+    case TOK_ASM_time:
+        return 0xc01;
+    case TOK_ASM_cycleh:
+        return 0xc80;
+    case TOK_ASM_instreth:
+        return 0xc82;
+    case TOK_ASM_timeh:
+        return 0xc81;
+    default:
+        return -1;
+    }
+}
+
 ST_FUNC void subst_asm_operand(CString *add_str, SValue *sv, int modifier)
 {
     tcc_error("RISCV64 asm not implemented.");
@@ -711,15 +1062,451 @@ ST_FUNC void asm_clobber(uint8_t *clobber_regs, const char *str)
 
 ST_FUNC int asm_parse_regvar (int t)
 {
-    if (t >= TOK_ASM_x0 && t <= TOK_ASM_pc) { /* register name */
-        switch (t) {
-            case TOK_ASM_pc:
-                return -1; // TODO: Figure out where it can be used after all
-            default:
-                return t - TOK_ASM_x0;
-        }
-    } else
+    /* PC register not implemented */
+    if (t >= TOK_ASM_pc || t < TOK_ASM_x0)
         return -1;
+
+    if (t < TOK_ASM_f0)
+        return t - TOK_ASM_x0;
+
+    if (t < TOK_ASM_zero)
+        return t - TOK_ASM_f0;
+
+    /* ABI mnemonic */
+    if (t < TOK_ASM_ft0)
+        return t - TOK_ASM_zero;
+
+    return t - TOK_ASM_ft0;
+}
+
+/*************************************************************/
+/* C extension */
+
+/* caller: Add funct6, funct2 into opcode */
+static void asm_emit_ca(int token, uint16_t opcode, const Operand *rd, const Operand *rs2)
+{
+    uint8_t dst, src;
+
+    if (rd->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (rs2->type != OP_REG) {
+        tcc_error("'%s': Expected source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* subtract index of x8 */
+    dst = rd->reg - 8;
+    src = rs2->reg - 8;
+
+    /* only registers {x,f}8 to {x,f}15 are valid (3-bit) */
+    if (dst > 7) {
+        tcc_error("'%s': Expected destination operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (src > 7) {
+        tcc_error("'%s': Expected source operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CA-type instruction:
+    15...10 funct6
+    9...7   rd'/rs1'
+    6..5    funct2
+    4...2   rs2'
+    1...0   opcode */
+
+    gen_le16(opcode | C_ENCODE_RS2(src) | C_ENCODE_RS1(dst));
+}
+
+static void asm_emit_cb(int token, uint16_t opcode, const Operand *rs1, const Operand *imm)
+{
+    uint32_t offset;
+    uint8_t src;
+
+    if (rs1->type != OP_REG) {
+        tcc_error("'%s': Expected source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm->type != OP_IM12S && imm->type != OP_IM32) {
+        tcc_error("'%s': Expected source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    offset = imm->e.v;
+
+    if (offset & 1) {
+        tcc_error("'%s': Expected source operand that is an even immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    src = rs1->reg - 8;
+
+    if (src > 7) {
+        tcc_error("'%s': Expected source operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CB-type instruction:
+    15...13 funct3
+    12...10 offset
+    9..7    rs1'
+    6...2   offset
+    1...0   opcode */
+
+    /* non-branch also using CB:
+    15...13 funct3
+    12      imm
+    11..10  funct2
+    9...7   rd'/rs1'
+    6..2    imm
+    1...0   opcode */
+
+    switch (token) {
+    case TOK_ASM_c_beqz:
+    case TOK_ASM_c_bnez:
+        gen_le16(opcode | C_ENCODE_RS1(src) | ((NTH_BIT(offset, 5) | (((offset >> 1) & 3) << 1) | (((offset >> 6) & 3) << 3)) << 2) | ((((offset >> 3) & 3) | NTH_BIT(offset, 8)) << 10));
+        return;
+    default:
+        gen_le16(opcode | C_ENCODE_RS1(src) | ((offset & 0x1f) << 2) | (NTH_BIT(offset, 5) << 12));
+        return;
+    }
+}
+
+static void asm_emit_ci(int token, uint16_t opcode, const Operand *rd, const Operand *imm)
+{
+    uint32_t immediate;
+
+    if (rd->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm->type != OP_IM12S && imm->type != OP_IM32) {
+        tcc_error("'%s': Expected source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    immediate = imm->e.v;
+
+    /* CI-type instruction:
+    15...13 funct3
+    12      imm
+    11...7  rd/rs1
+    6...2   imm
+    1...0   opcode */
+
+    switch (token) {
+    case TOK_ASM_c_addi:
+    case TOK_ASM_c_addiw:
+    case TOK_ASM_c_li:
+    case TOK_ASM_c_slli:
+        gen_le16(opcode | ((immediate & 0x1f) << 2) | ENCODE_RD(rd->reg) | (NTH_BIT(immediate, 5) << 12));
+        return;
+    case TOK_ASM_c_addi16sp:
+        gen_le16(opcode | NTH_BIT(immediate, 5) << 2 | (((immediate >> 7) & 3) << 3) | NTH_BIT(immediate, 6) << 5 | NTH_BIT(immediate, 4) << 6 | ENCODE_RD(rd->reg) | (NTH_BIT(immediate, 9) << 12));
+        return;
+    case TOK_ASM_c_lui:
+        gen_le16(opcode | (((immediate >> 12) & 0x1f) << 2) | ENCODE_RD(rd->reg) | (NTH_BIT(immediate, 17) << 12));
+        return;
+    case TOK_ASM_c_fldsp:
+    case TOK_ASM_c_ldsp:
+        gen_le16(opcode | (((immediate >> 6) & 7) << 2) | (((immediate >> 3) & 2) << 5) | ENCODE_RD(rd->reg) | (NTH_BIT(immediate, 5) << 12));
+        return;
+    case TOK_ASM_c_flwsp:
+    case TOK_ASM_c_lwsp:
+        gen_le16(opcode | (((immediate >> 6) & 3) << 2) | (((immediate >> 2) & 7) << 4) | ENCODE_RD(rd->reg) | (NTH_BIT(immediate, 5) << 12));
+        return;
+    case TOK_ASM_c_nop:
+        gen_le16(opcode);
+        return;
+    default:
+        expect("known instruction");
+    }
+}
+
+/* caller: Add funct3 into opcode */
+static void asm_emit_ciw(int token, uint16_t opcode, const Operand *rd, const Operand *imm)
+{
+    uint32_t nzuimm;
+    uint8_t dst;
+
+    if (rd->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm->type != OP_IM12S && imm->type != OP_IM32) {
+        tcc_error("'%s': Expected source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    dst = rd->reg - 8;
+
+    if (dst > 7) {
+        tcc_error("'%s': Expected destination operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    nzuimm = imm->e.v;
+
+    if (nzuimm > 0x3fc) {
+        tcc_error("'%s': Expected source operand that is an immediate value between 0 and 0x3ff", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (nzuimm & 3) {
+        tcc_error("'%s': Expected source operand that is a non-zero immediate value divisible by 4", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CIW-type instruction:
+    15...13 funct3
+    12...5  imm
+    4...2   rd'
+    1...0   opcode */
+
+    gen_le16(opcode | ENCODE_RS2(rd->reg) | ((NTH_BIT(nzuimm, 3) | (NTH_BIT(nzuimm, 2) << 1) | (((nzuimm >> 6) & 0xf) << 2) | (((nzuimm >> 4) & 3) << 6)) << 5));
+}
+
+/* caller: Add funct3 into opcode */
+static void asm_emit_cj(int token, uint16_t opcode, const Operand *imm)
+{
+    uint32_t offset;
+
+    /* +-2 KiB range */
+    if (imm->type != OP_IM12S) {
+        tcc_error("'%s': Expected source operand that is a 12-bit immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    offset = imm->e.v;
+
+    if (offset & 1) {
+        tcc_error("'%s': Expected source operand that is an even immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CJ-type instruction:
+    15...13 funct3
+    12...2  offset[11|4|9:8|10|6|7|3:1|5]
+    1...0   opcode */
+
+    gen_le16(opcode | (NTH_BIT(offset, 5) << 2) | (((offset >> 1) & 7) << 3) | (NTH_BIT(offset, 7) << 6) | (NTH_BIT(offset, 6) << 7) | (NTH_BIT(offset, 10) << 8) | (((offset >> 8) & 3) << 9) | (NTH_BIT(offset, 4) << 11) | (NTH_BIT(offset, 11) << 12));
+}
+
+/* caller: Add funct3 into opcode */
+static void asm_emit_cl(int token, uint16_t opcode, const Operand *rd, const Operand *rs1, const Operand *imm)
+{
+    uint32_t offset;
+    uint8_t dst, src;
+
+    if (rd->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (rs1->type != OP_REG) {
+        tcc_error("'%s': Expected source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm->type != OP_IM12S && imm->type != OP_IM32) {
+        tcc_error("'%s': Expected source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    dst = rd->reg - 8;
+    src = rs1->reg - 8;
+
+    if (dst > 7) {
+        tcc_error("'%s': Expected destination operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (src > 7) {
+        tcc_error("'%s': Expected source operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    offset = imm->e.v;
+
+    if (offset > 0xff) {
+        tcc_error("'%s': Expected source operand that is an immediate value between 0 and 0xff", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (offset & 3) {
+        tcc_error("'%s': Expected source operand that is an immediate value divisible by 4", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CL-type instruction:
+    15...13 funct3
+    12...10 imm
+    9...7   rs1'
+    6...5   imm
+    4...2   rd'
+    1...0   opcode */
+
+    switch (token) {
+    /* imm variant 1 */
+    case TOK_ASM_c_flw:
+    case TOK_ASM_c_lw:
+        gen_le16(opcode | C_ENCODE_RS2(dst) | C_ENCODE_RS1(src) | (NTH_BIT(offset, 6) << 5) | (NTH_BIT(offset, 2) << 6) | (((offset >> 3) & 7) << 10));
+        return;
+    /* imm variant 2 */
+    case TOK_ASM_c_fld:
+    case TOK_ASM_c_ld:
+        gen_le16(opcode | C_ENCODE_RS2(dst) | C_ENCODE_RS1(src) | (((offset >> 6) & 3) << 5) | (((offset >> 3) & 7) << 10));
+        return;
+    default:
+        expect("known instruction");
+    }
+}
+
+/* caller: Add funct4 into opcode */
+static void asm_emit_cr(int token, uint16_t opcode, const Operand *rd, const Operand *rs2)
+{
+    if (rd->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (rs2->type != OP_REG) {
+        tcc_error("'%s': Expected source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CR-type instruction:
+    15...12 funct4
+    11..7   rd/rs1
+    6...2   rs2
+    1...0   opcode */
+
+    gen_le16(opcode | C_ENCODE_RS1(rd->reg) | C_ENCODE_RS2(rs2->reg));
+}
+
+/* caller: Add funct3 into opcode */
+static void asm_emit_cs(int token, uint16_t opcode, const Operand *rs2, const Operand *rs1, const Operand *imm)
+{
+    uint32_t offset;
+    uint8_t base, src;
+
+    if (rs2->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (rs1->type != OP_REG) {
+        tcc_error("'%s': Expected source operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm->type != OP_IM12S && imm->type != OP_IM32) {
+        tcc_error("'%s': Expected source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    base = rs1->reg - 8;
+    src = rs2->reg - 8;
+
+    if (base > 7) {
+        tcc_error("'%s': Expected destination operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (src > 7) {
+        tcc_error("'%s': Expected source operand that is a valid C-extension register", get_tok_str(token, NULL));
+        return;
+    }
+
+    offset = imm->e.v;
+
+    if (offset > 0xff) {
+        tcc_error("'%s': Expected source operand that is an immediate value between 0 and 0xff", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (offset & 3) {
+        tcc_error("'%s': Expected source operand that is an immediate value divisible by 4", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CS-type instruction:
+    15...13 funct3
+    12...10 imm
+    9...7   rs1'
+    6...5   imm
+    4...2   rs2'
+    1...0   opcode */
+    switch (token) {
+    /* imm variant 1 */
+    case TOK_ASM_c_fsw:
+    case TOK_ASM_c_sw:
+        gen_le16(opcode | C_ENCODE_RS2(base) | C_ENCODE_RS1(src) | (NTH_BIT(offset, 6) << 5) | (NTH_BIT(offset, 2) << 6) | (((offset >> 3) & 7) << 10));
+        return;
+    /* imm variant 2 */
+    case TOK_ASM_c_fsd:
+    case TOK_ASM_c_sd:
+        gen_le16(opcode | C_ENCODE_RS2(base) | C_ENCODE_RS1(src) | (((offset >> 6) & 3) << 5) | (((offset >> 3) & 7) << 10));
+        return;
+    default:
+        expect("known instruction");
+    }
+}
+
+/* caller: Add funct3 into opcode */
+static void asm_emit_css(int token, uint16_t opcode, const Operand *rs2, const Operand *imm)
+{
+    uint32_t offset;
+
+    if (rs2->type != OP_REG) {
+        tcc_error("'%s': Expected destination operand that is a register", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (imm->type != OP_IM12S && imm->type != OP_IM32) {
+        tcc_error("'%s': Expected source operand that is an immediate value", get_tok_str(token, NULL));
+        return;
+    }
+
+    offset = imm->e.v;
+
+    if (offset > 0xff) {
+        tcc_error("'%s': Expected source operand that is an immediate value between 0 and 0xff", get_tok_str(token, NULL));
+        return;
+    }
+
+    if (offset & 3) {
+        tcc_error("'%s': Expected source operand that is an immediate value divisible by 4", get_tok_str(token, NULL));
+        return;
+    }
+
+    /* CSS-type instruction:
+    15...13 funct3
+    12...7  imm
+    6...2   rs2
+    1...0   opcode */
+
+    switch (token) {
+    /* imm variant 1 */
+    case TOK_ASM_c_fswsp:
+    case TOK_ASM_c_swsp:
+        gen_le16(opcode | ENCODE_RS2(rs2->reg) | (((offset >> 6) & 3) << 7) | (((offset >> 2) & 0xf) << 9));
+        return;
+    /* imm variant 2 */
+    case TOK_ASM_c_fsdsp:
+    case TOK_ASM_c_sdsp:
+        gen_le16(opcode | ENCODE_RS2(rs2->reg) | (((offset >> 6) & 7) << 7) | (((offset >> 3) & 7) << 10));
+        return;
+    default:
+        expect("known instruction");
+    }
 }
 
 /*************************************************************/
diff --git a/riscv64-gen.c b/riscv64-gen.c
index 9a521d5a2..8a17b701a 100644
--- a/riscv64-gen.c
+++ b/riscv64-gen.c
@@ -471,7 +471,7 @@ static void gen_bounds_epilog(void)
     *bounds_ptr = 0;
 
     sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
-                           func_bound_offset, lbounds_section->data_offset);
+                           func_bound_offset, PTR_SIZE);
 
     label.type.t = VT_VOID | VT_STATIC;
     /* generate bound local allocation */
@@ -627,10 +627,14 @@ ST_FUNC void gfunc_call(int nb_args)
     if ((vtop->r & VT_VALMASK) == VT_CMP)
       gv(RC_INT);
 
+
     if (stack_add) {
-        if (stack_add >= 0x1000) {
-            o(0x37 | (5 << 7) | (-stack_add & 0xfffff000)); //lui t0, upper(v)
-            EI(0x13, 0, 5, 5, -stack_add << 20 >> 20); // addi t0, t0, lo(v)
+        if (stack_add >= 0x800) {
+            unsigned int bit11 = (((unsigned int)-stack_add) >> 11) & 1;
+            o(0x37 | (5 << 7) |
+              ((-stack_add + (bit11 << 12)) & 0xfffff000)); //lui t0, upper(v)
+            EI(0x13, 0, 5, 5, ((-stack_add & 0xfff) - bit11 * (1 << 12)));
+                                                         // addi t0, t0, lo(v)
             ER(0x33, 0, 2, 2, 5, 0); // add sp, sp, t0
         }
         else
@@ -757,9 +761,12 @@ ST_FUNC void gfunc_call(int nb_args)
     gcall_or_jmp(1);
     vtop -= nb_args + 1;
     if (stack_add) {
-        if (stack_add >= 0x1000) {
-            o(0x37 | (5 << 7) | (stack_add & 0xfffff000)); //lui t0, upper(v)
-            EI(0x13, 0, 5, 5, stack_add << 20 >> 20); // addi t0, t0, lo(v)
+        if (stack_add >= 0x800) {
+            unsigned int bit11 = ((unsigned int)stack_add >> 11) & 1;
+            o(0x37 | (5 << 7) |
+              ((stack_add + (bit11 << 12)) & 0xfffff000)); //lui t0, upper(v)
+            EI(0x13, 0, 5, 5, (stack_add & 0xfff) - bit11 * (1 << 12));
+                                                           // addi t0, t0, lo(v)
             ER(0x33, 0, 2, 2, 5, 0); // add sp, sp, t0
         }
         else
@@ -1382,12 +1389,24 @@ ST_FUNC void ggoto(void)
 
 ST_FUNC void gen_vla_sp_save(int addr)
 {
-    ES(0x23, 3, 8, 2, addr); // sd sp, fc(s0)
+    if (((unsigned)addr + (1 << 11)) >> 12) {
+	o(0x37 | (5 << 7) | ((0x800 + addr) & 0xfffff000)); //lui t0,upper(addr)
+        ER(0x33, 0, 5, 5, 8, 0); // add t0, t0, s0
+        ES(0x23, 3, 5, 2, (int)addr << 20 >> 20); // sd sp, fc(t0)
+    }
+    else
+        ES(0x23, 3, 8, 2, addr); // sd sp, fc(s0)
 }
 
 ST_FUNC void gen_vla_sp_restore(int addr)
 {
-    EI(0x03, 3, 2, 8, addr); // ld sp, fc(s0)
+    if (((unsigned)addr + (1 << 11)) >> 12) {
+	o(0x37 | (5 << 7) | ((0x800 + addr) & 0xfffff000)); //lui t0,upper(addr)
+        ER(0x33, 0, 5, 5, 8, 0); // add t0, t0, s0
+        EI(0x03, 3, 2, 5, (int)addr << 20 >> 20); // ld sp, fc(t0)
+    }
+    else
+        EI(0x03, 3, 2, 8, addr); // ld sp, fc(s0)
 }
 
 ST_FUNC void gen_vla_alloc(CType *type, int align)
diff --git a/riscv64-link.c b/riscv64-link.c
index 2aeefefbe..39c0c5d20 100644
--- a/riscv64-link.c
+++ b/riscv64-link.c
@@ -39,10 +39,13 @@ int code_reloc (int reloc_type)
     case R_RISCV_PCREL_LO12_S:
     case R_RISCV_32_PCREL:
     case R_RISCV_SET6:
+    case R_RISCV_SET8:
+    case R_RISCV_SET16:
     case R_RISCV_SUB6:
     case R_RISCV_ADD16:
     case R_RISCV_ADD32:
     case R_RISCV_ADD64:
+    case R_RISCV_SUB8:
     case R_RISCV_SUB16:
     case R_RISCV_SUB32:
     case R_RISCV_SUB64:
@@ -68,8 +71,11 @@ int gotplt_entry_type (int reloc_type)
     case R_RISCV_RVC_JUMP:
     case R_RISCV_JUMP_SLOT:
     case R_RISCV_SET6:
+    case R_RISCV_SET8:
+    case R_RISCV_SET16:
     case R_RISCV_SUB6:
     case R_RISCV_ADD16:
+    case R_RISCV_SUB8:
     case R_RISCV_SUB16:
         return NO_GOTPLT_ENTRY;
 
@@ -127,7 +133,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
         uint64_t got = s1->got->sh_addr;
         uint64_t off = (got - plt + 0x800) >> 12;
         if ((off + ((uint32_t)1 << 20)) >> 21)
-            tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);
+            tcc_error_noabort("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);
         write32le(p, 0x397 | (off << 12)); // auipc t2, %pcrel_hi(got)
         write32le(p + 4, 0x41c30333); // sub t1, t1, t3
         write32le(p + 8, 0x0003be03   // ld t3, %pcrel_lo(got)(t2)
@@ -144,7 +150,7 @@ ST_FUNC void relocate_plt(TCCState *s1)
             uint64_t addr = got + read64le(p);
             uint64_t off = (addr - pc + 0x800) >> 12;
             if ((off + ((uint32_t)1 << 20)) >> 21)
-                tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);
+                tcc_error_noabort("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);
             write32le(p, 0xe17 | (off << 12)); // auipc t3, %pcrel_hi(func@got)
             write32le(p + 4, 0x000e3e03 // ld t3, %pcrel_lo(func@got)(t3)
                              | (((addr - pc) & 0xfff) << 20));
@@ -179,7 +185,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
     case R_RISCV_BRANCH:
         off64 = val - addr;
         if ((off64 + (1 << 12)) & ~(uint64_t)0x1ffe)
-          tcc_error("R_RISCV_BRANCH relocation failed"
+          tcc_error_noabort("R_RISCV_BRANCH relocation failed"
                     " (val=%lx, addr=%lx)", (long)val, (long)addr);
         off32 = off64 >> 1;
         write32le(ptr, (read32le(ptr) & ~0xfe000f80)
@@ -191,7 +197,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
     case R_RISCV_JAL:
         off64 = val - addr;
         if ((off64 + (1 << 21)) & ~(((uint64_t)1 << 22) - 2))
-          tcc_error("R_RISCV_JAL relocation failed"
+          tcc_error_noabort("R_RISCV_JAL relocation failed"
                     " (val=%lx, addr=%lx)", (long)val, (long)addr);
         off32 = off64;
         write32le(ptr, (read32le(ptr) & 0xfff)
@@ -213,7 +219,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
 #endif
         off64 = (int64_t)(val - addr + 0x800) >> 12;
         if ((off64 + ((uint64_t)1 << 20)) >> 21)
-          tcc_error("R_RISCV_PCREL_HI20 relocation failed: off=%lx cond=%lx sym=%s",
+          tcc_error_noabort("R_RISCV_PCREL_HI20 relocation failed: off=%lx cond=%lx sym=%s",
                     (long)off64, (long)((int64_t)(off64 + ((uint64_t)1 << 20)) >> 21),
                     symtab_section->link->data + sym->st_name);
         write32le(ptr, (read32le(ptr) & 0xfff)
@@ -225,7 +231,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
         val = s1->got->sh_addr + get_sym_attr(s1, sym_index, 0)->got_offset;
         off64 = (int64_t)(val - addr + 0x800) >> 12;
         if ((off64 + ((uint64_t)1 << 20)) >> 21)
-          tcc_error("R_RISCV_GOT_HI20 relocation failed");
+          tcc_error_noabort("R_RISCV_GOT_HI20 relocation failed");
         last_hi.addr = addr;
         last_hi.val = val;
         write32le(ptr, (read32le(ptr) & 0xfff)
@@ -236,7 +242,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
         printf("PCREL_LO12_I: val=%lx addr=%lx\n", (long)val, (long)addr);
 #endif
         if (val != last_hi.addr)
-          tcc_error("unsupported hi/lo pcrel reloc scheme");
+          tcc_error_noabort("unsupported hi/lo pcrel reloc scheme");
         val = last_hi.val;
         addr = last_hi.addr;
         write32le(ptr, (read32le(ptr) & 0xfffff)
@@ -244,7 +250,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
         return;
     case R_RISCV_PCREL_LO12_S:
         if (val != last_hi.addr)
-          tcc_error("unsupported hi/lo pcrel reloc scheme");
+          tcc_error_noabort("unsupported hi/lo pcrel reloc scheme");
         val = last_hi.val;
         addr = last_hi.addr;
         off32 = val - addr;
@@ -256,7 +262,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
     case R_RISCV_RVC_BRANCH:
         off64 = (val - addr);
         if ((off64 + (1 << 8)) & ~(uint64_t)0x1fe)
-          tcc_error("R_RISCV_RVC_BRANCH relocation failed"
+          tcc_error_noabort("R_RISCV_RVC_BRANCH relocation failed"
                     " (val=%lx, addr=%lx)", (long)val, (long)addr);
         off32 = off64;
         write16le(ptr, (read16le(ptr) & 0xe383)
@@ -269,7 +275,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
     case R_RISCV_RVC_JUMP:
         off64 = (val - addr);
         if ((off64 + (1 << 11)) & ~(uint64_t)0xffe)
-          tcc_error("R_RISCV_RVC_BRANCH relocation failed"
+          tcc_error_noabort("R_RISCV_RVC_BRANCH relocation failed"
                     " (val=%lx, addr=%lx)", (long)val, (long)addr);
         off32 = off64;
         write16le(ptr, (read16le(ptr) & 0xe003)
@@ -284,7 +290,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
         return;
 
     case R_RISCV_32:
-        if (s1->output_type == TCC_OUTPUT_DLL) {
+        if (s1->output_type & TCC_OUTPUT_DYN) {
             /* XXX: this logic may depend on TCC's codegen
                now TCC uses R_RISCV_RELATIVE even for a 64bit pointer */
             qrel->r_offset = rel->r_offset;
@@ -296,7 +302,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
         add32le(ptr, val);
         return;
     case R_RISCV_64:
-        if (s1->output_type == TCC_OUTPUT_DLL) {
+        if (s1->output_type & TCC_OUTPUT_DYN) {
             esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
             qrel->r_offset = rel->r_offset;
             if (esym_index) {
@@ -328,12 +334,21 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr,
     case R_RISCV_ADD16:
         write16le(ptr, read16le(ptr) + val);
         return;
+    case R_RISCV_SUB8:
+        *ptr -= val;
+        return;
     case R_RISCV_SUB16:
         write16le(ptr, read16le(ptr) - val);
         return;
     case R_RISCV_SET6:
         *ptr = (*ptr & ~0x3f) | (val & 0x3f);
         return;
+    case R_RISCV_SET8:
+        *ptr = (*ptr & ~0xff) | (val & 0xff);
+        return;
+    case R_RISCV_SET16:
+        *ptr = (*ptr & ~0xffff) | (val & 0xffff);
+        return;
     case R_RISCV_SUB6:
         *ptr = (*ptr & ~0x3f) | ((*ptr - val) & 0x3f);
         return;
diff --git a/riscv64-tok.h b/riscv64-tok.h
index 0b2184126..ecf448eff 100644
--- a/riscv64-tok.h
+++ b/riscv64-tok.h
@@ -1,10 +1,15 @@
 /* ------------------------------------------------------------------ */
 /* WARNING: relative order of tokens is important.                    */
 
-// See https://riscv.org/wp-content/uploads/2017/05/riscv-spec-v2.2.pdf
+/*
+ * The specifications are available under https://riscv.org/technical/specifications/
+ */
 
-/* register */
+#define DEF_ASM_WITH_SUFFIX(x, y) \
+  DEF(TOK_ASM_ ## x ## _ ## y, #x "." #y)
 
+/* register */
+ /* integer */
  DEF_ASM(x0)
  DEF_ASM(x1)
  DEF_ASM(x2)
@@ -37,11 +42,43 @@
  DEF_ASM(x29)
  DEF_ASM(x30)
  DEF_ASM(x31)
-
-/* register macros */
-
+ /* float */
+ DEF_ASM(f0)
+ DEF_ASM(f1)
+ DEF_ASM(f2)
+ DEF_ASM(f3)
+ DEF_ASM(f4)
+ DEF_ASM(f5)
+ DEF_ASM(f6)
+ DEF_ASM(f7)
+ DEF_ASM(f8)
+ DEF_ASM(f9)
+ DEF_ASM(f10)
+ DEF_ASM(f11)
+ DEF_ASM(f12)
+ DEF_ASM(f13)
+ DEF_ASM(f14)
+ DEF_ASM(f15)
+ DEF_ASM(f16)
+ DEF_ASM(f17)
+ DEF_ASM(f18)
+ DEF_ASM(f19)
+ DEF_ASM(f20)
+ DEF_ASM(f21)
+ DEF_ASM(f22)
+ DEF_ASM(f23)
+ DEF_ASM(f24)
+ DEF_ASM(f25)
+ DEF_ASM(f26)
+ DEF_ASM(f27)
+ DEF_ASM(f28)
+ DEF_ASM(f29)
+ DEF_ASM(f30)
+ DEF_ASM(f31)
+
+/* register ABI mnemonics, refer to RISC-V ABI 1.0 */
+ /* integer */
  DEF_ASM(zero)
-/*
  DEF_ASM(ra)
  DEF_ASM(sp)
  DEF_ASM(gp)
@@ -49,7 +86,7 @@
  DEF_ASM(t0)
  DEF_ASM(t1)
  DEF_ASM(t2)
- DEF_ASM(fp)
+ DEF_ASM(s0)
  DEF_ASM(s1)
  DEF_ASM(a0)
  DEF_ASM(a1)
@@ -73,15 +110,42 @@
  DEF_ASM(t4)
  DEF_ASM(t5)
  DEF_ASM(t6)
-
- DEF_ASM(s0) // = x8
-*/
-
+ /* float */
+ DEF_ASM(ft0)
+ DEF_ASM(ft1)
+ DEF_ASM(ft2)
+ DEF_ASM(ft3)
+ DEF_ASM(ft4)
+ DEF_ASM(ft5)
+ DEF_ASM(ft6)
+ DEF_ASM(ft7)
+ DEF_ASM(fs0)
+ DEF_ASM(fs1)
+ DEF_ASM(fa0)
+ DEF_ASM(fa1)
+ DEF_ASM(fa2)
+ DEF_ASM(fa3)
+ DEF_ASM(fa4)
+ DEF_ASM(fa5)
+ DEF_ASM(fa6)
+ DEF_ASM(fa7)
+ DEF_ASM(fs2)
+ DEF_ASM(fs3)
+ DEF_ASM(fs4)
+ DEF_ASM(fs5)
+ DEF_ASM(fs6)
+ DEF_ASM(fs7)
+ DEF_ASM(fs8)
+ DEF_ASM(fs9)
+ DEF_ASM(fs10)
+ DEF_ASM(fs11)
+ DEF_ASM(ft8)
+ DEF_ASM(ft9)
+ DEF_ASM(ft10)
+ DEF_ASM(ft11)
+ /* not in the ABI */
  DEF_ASM(pc)
 
-#define DEF_ASM_WITH_SUFFIX(x, y) \
-  DEF(TOK_ASM_ ## x ## _ ## y, #x #y)
-
 /*   Loads */
 
  DEF_ASM(lb)
@@ -89,40 +153,33 @@
  DEF_ASM(lw)
  DEF_ASM(lbu)
  DEF_ASM(lhu)
+ /* RV64 */
  DEF_ASM(ld)
- DEF_ASM(lq)
  DEF_ASM(lwu)
- DEF_ASM(ldu)
 
 /* Stores */
 
  DEF_ASM(sb)
  DEF_ASM(sh)
  DEF_ASM(sw)
+ /* RV64 */
  DEF_ASM(sd)
- DEF_ASM(sq)
 
 /* Shifts */
 
  DEF_ASM(sll)
- DEF_ASM(slli)
  DEF_ASM(srl)
- DEF_ASM(srli)
  DEF_ASM(sra)
- DEF_ASM(srai)
-
+ /* RV64 */
+ DEF_ASM(slli)
+ DEF_ASM(srli)
  DEF_ASM(sllw)
- DEF_ASM(slld)
  DEF_ASM(slliw)
- DEF_ASM(sllid)
  DEF_ASM(srlw)
- DEF_ASM(srld)
  DEF_ASM(srliw)
- DEF_ASM(srlid)
+ DEF_ASM(srai)
  DEF_ASM(sraw)
- DEF_ASM(srad)
  DEF_ASM(sraiw)
- DEF_ASM(sraid)
 
 /* Arithmetic */
 
@@ -131,13 +188,10 @@
  DEF_ASM(sub)
  DEF_ASM(lui)
  DEF_ASM(auipc)
-
+ /* RV64 */
  DEF_ASM(addw)
- DEF_ASM(addd)
  DEF_ASM(addiw)
- DEF_ASM(addid)
  DEF_ASM(subw)
- DEF_ASM(subd)
 
 /* Logical */
 
@@ -164,15 +218,22 @@
  DEF_ASM(bltu)
  DEF_ASM(bgeu)
 
+/* Jump */
+
+ DEF_ASM(jal)
+ DEF_ASM(jalr)
+
 /* Sync */
 
  DEF_ASM(fence)
+ /* Zifencei extension */
  DEF_ASM_WITH_SUFFIX(fence, i)
 
 /* System call */
 
- DEF_ASM(scall)
- DEF_ASM(sbreak)
+ /* used to be called scall and sbreak */
+ DEF_ASM(ecall)
+ DEF_ASM(ebreak)
 
 /* Counters */
 
@@ -183,13 +244,169 @@
  DEF_ASM(rdinstret)
  DEF_ASM(rdinstreth)
 
-/* Privileged Instructions */
+/* “M” Standard Extension for Integer Multiplication and Division, V2.0 */
+ DEF_ASM(mul)
+ DEF_ASM(mulh)
+ DEF_ASM(mulhsu)
+ DEF_ASM(mulhu)
+ DEF_ASM(div)
+ DEF_ASM(divu)
+ DEF_ASM(rem)
+ DEF_ASM(remu)
+ /* RV64 */
+ DEF_ASM(mulw)
+ DEF_ASM(divw)
+ DEF_ASM(divuw)
+ DEF_ASM(remw)
+ DEF_ASM(remuw)
+
+/* "C" Extension for Compressed Instructions, V2.0 */
+ DEF_ASM_WITH_SUFFIX(c, nop)
+/* Loads */
+ DEF_ASM_WITH_SUFFIX(c, li)
+ DEF_ASM_WITH_SUFFIX(c, lw)
+ DEF_ASM_WITH_SUFFIX(c, lwsp)
+ /* single float */
+ DEF_ASM_WITH_SUFFIX(c, flw)
+ DEF_ASM_WITH_SUFFIX(c, flwsp)
+ /* double float */
+ DEF_ASM_WITH_SUFFIX(c, fld)
+ DEF_ASM_WITH_SUFFIX(c, fldsp)
+ /* RV64 */
+ DEF_ASM_WITH_SUFFIX(c, ld)
+ DEF_ASM_WITH_SUFFIX(c, ldsp)
 
- DEF_ASM(ecall)
- DEF_ASM(ebreak)
+/* Stores */
+
+ DEF_ASM_WITH_SUFFIX(c, sw)
+ DEF_ASM_WITH_SUFFIX(c, sd)
+ DEF_ASM_WITH_SUFFIX(c, swsp)
+ DEF_ASM_WITH_SUFFIX(c, sdsp)
+ /* single float */
+ DEF_ASM_WITH_SUFFIX(c, fsw)
+ DEF_ASM_WITH_SUFFIX(c, fswsp)
+ /* double float */
+ DEF_ASM_WITH_SUFFIX(c, fsd)
+ DEF_ASM_WITH_SUFFIX(c, fsdsp)
+
+/* Shifts */
+ DEF_ASM_WITH_SUFFIX(c, slli)
+ DEF_ASM_WITH_SUFFIX(c, srli)
+ DEF_ASM_WITH_SUFFIX(c, srai)
+
+/* Arithmetic */
+ DEF_ASM_WITH_SUFFIX(c, add)
+ DEF_ASM_WITH_SUFFIX(c, addi)
+ DEF_ASM_WITH_SUFFIX(c, addi16sp)
+ DEF_ASM_WITH_SUFFIX(c, addi4spn)
+ DEF_ASM_WITH_SUFFIX(c, lui)
+ DEF_ASM_WITH_SUFFIX(c, sub)
+ DEF_ASM_WITH_SUFFIX(c, mv)
+ /* RV64 */
+ DEF_ASM_WITH_SUFFIX(c, addw)
+ DEF_ASM_WITH_SUFFIX(c, addiw)
+ DEF_ASM_WITH_SUFFIX(c, subw)
+
+/* Logical */
+ DEF_ASM_WITH_SUFFIX(c, xor)
+ DEF_ASM_WITH_SUFFIX(c, or)
+ DEF_ASM_WITH_SUFFIX(c, and)
+ DEF_ASM_WITH_SUFFIX(c, andi)
+
+/* Branch */
+ DEF_ASM_WITH_SUFFIX(c, beqz)
+ DEF_ASM_WITH_SUFFIX(c, bnez)
+
+/* Jump */
+ DEF_ASM_WITH_SUFFIX(c, j)
+ DEF_ASM_WITH_SUFFIX(c, jr)
+ DEF_ASM_WITH_SUFFIX(c, jal)
+ DEF_ASM_WITH_SUFFIX(c, jalr)
+
+/* System call */
+ DEF_ASM_WITH_SUFFIX(c, ebreak)
+
+/* XXX F Extension: Single-Precision Floating Point */
+/* XXX D Extension: Double-Precision Floating Point */
+/* from the spec: Tables 16.5–16.7 list the RVC instructions. */
+
+/* “Zicsr”, Control and Status Register (CSR) Instructions, V2.0 */
+ DEF_ASM(csrrw)
+ DEF_ASM(csrrs)
+ DEF_ASM(csrrc)
+ DEF_ASM(csrrwi)
+ DEF_ASM(csrrsi)
+ DEF_ASM(csrrci)
+ /* registers */
+ DEF_ASM(cycle)
+ DEF_ASM(fcsr)
+ DEF_ASM(fflags)
+ DEF_ASM(frm)
+ DEF_ASM(instret)
+ DEF_ASM(time)
+ /* RV32I-only */
+ DEF_ASM(cycleh)
+ DEF_ASM(instreth)
+ DEF_ASM(timeh)
+ /* pseudo */
+ DEF_ASM(csrc)
+ DEF_ASM(csrci)
+ DEF_ASM(csrr)
+ DEF_ASM(csrs)
+ DEF_ASM(csrsi)
+ DEF_ASM(csrw)
+ DEF_ASM(csrwi)
+ DEF_ASM(frcsr)
+ DEF_ASM(frflags)
+ DEF_ASM(frrm)
+ DEF_ASM(fscsr)
+ DEF_ASM(fsflags)
+ DEF_ASM(fsrm)
+
+/* Privileged Instructions */
 
  DEF_ASM(mrts)
  DEF_ASM(mrth)
  DEF_ASM(hrts)
  DEF_ASM(wfi)
 
+/* pseudoinstructions */
+ DEF_ASM(beqz)
+ DEF_ASM(bgez)
+ DEF_ASM(bgt)
+ DEF_ASM(bgtu)
+ DEF_ASM(bgtz)
+ DEF_ASM(ble)
+ DEF_ASM(bleu)
+ DEF_ASM(blez)
+ DEF_ASM(bltz)
+ DEF_ASM(bnez)
+ DEF_ASM(call)
+ DEF_ASM_WITH_SUFFIX(fabs, d)
+ DEF_ASM_WITH_SUFFIX(fabs, s)
+ DEF_ASM(fld)
+ DEF_ASM(flw)
+ DEF_ASM_WITH_SUFFIX(fmv, d)
+ DEF_ASM_WITH_SUFFIX(fmv, s)
+ DEF_ASM_WITH_SUFFIX(fneg, d)
+ DEF_ASM_WITH_SUFFIX(fneg, s)
+ DEF_ASM(fsd)
+ DEF_ASM(fsw)
+ DEF_ASM(j)
+ DEF_ASM(la)
+ DEF_ASM(li)
+ DEF_ASM(lla)
+ DEF_ASM(mv)
+ DEF_ASM(neg)
+ DEF_ASM(negw)
+ DEF_ASM(nop)
+ DEF_ASM(not)
+ DEF_ASM(ret)
+ DEF_ASM(seqz)
+ DEF_ASM_WITH_SUFFIX(sext, w)
+ DEF_ASM(sgtz)
+ DEF_ASM(sltz)
+ DEF_ASM(snez)
+ DEF_ASM(tail)
+
+#undef DEF_ASM_WITH_SUFFIX
diff --git a/tcc-doc.texi b/tcc-doc.texi
index fa2232509..8d172c2af 100644
--- a/tcc-doc.texi
+++ b/tcc-doc.texi
@@ -350,21 +350,25 @@ Debugger options:
 
 @table @option
 @item -g
-Generate run time debug information so that you get clear run time
+Generate run time stab debug information so that you get clear run time
 error messages: @code{ test.c:68: in function 'test5()': dereferencing
 invalid pointer} instead of the laconic @code{Segmentation
 fault}.
 
+@item -gdwarf[-x]
+Generate run time dwarf debug information instead of stab debug information.
+
 @item -b
 Generate additional support code to check memory allocations and array/pointer
 bounds (@pxref{Bounds}). @option{-g} is implied.
 
 @item -bt[N]
 Display N callers in stack traces. This is useful with @option{-g} or @option{-b}.
-With executables, additional support for stack traces is included.
+When activated, @code{__TCC_BACKTRACE__} is defined.
 
-A function @code{ int tcc_backtrace(const char *fmt, ...); } is provided
-to trigger a stack trace with a message on demand.
+With executables, additional support for stack traces is included. A function
+    @code{ int tcc_backtrace(const char *fmt, ...); }
+is provided to trigger a stack trace with a message on demand.
 
 @end table
 
@@ -934,7 +938,7 @@ Here are some examples of caught errors:
 @end example
 @end table
 
-TCC defines @code{__BOUNDS_CHECKING_ON} if activated.
+TCC defines @code{__TCC_BCHECK__} if activated.
 
 There are five environment variables that can be used to control the behavior:
 @itemize
@@ -981,7 +985,7 @@ for bounds checking errors.
 @end itemize
 
 @example
-#if defined(__TINYC__) && __BOUNDS_CHECKING_ON
+#ifdef __TCC_BCHECK__
 extern void __bounds_checking (int x);
 # define BOUNDS_CHECKING_OFF __bounds_checking(1)
 # define BOUNDS_CHECKING_ON  __bounds_checking(-1)
diff --git a/tcc.c b/tcc.c
index ce1945a19..b38dae9be 100644
--- a/tcc.c
+++ b/tcc.c
@@ -27,7 +27,7 @@
 static const char help[] =
     "Tiny C Compiler "TCC_VERSION" - Copyright (C) 2001-2006 Fabrice Bellard\n"
     "Usage: tcc [options...] [-o outfile] [-c] infile(s)...\n"
-    "       tcc [options...] -run infile [arguments...]\n"
+    "       tcc [options...] -run infile (or --) [arguments...]\n"
     "General options:\n"
     "  -c           compile only - generate an object file\n"
     "  -o outfile   set output filename\n"
@@ -48,7 +48,6 @@ static const char help[] =
     "  -Dsym[=val]  define 'sym' with value 'val'\n"
     "  -Usym        undefine 'sym'\n"
     "  -E           preprocess only\n"
-    "  -C           keep comments (not yet implemented)\n"
     "Linker options:\n"
     "  -Ldir        add library path 'dir'\n"
     "  -llib        link with dynamic or static library 'lib'\n"
@@ -58,7 +57,11 @@ static const char help[] =
     "  -soname      set name for shared library to be used at runtime\n"
     "  -Wl,-opt[=val]  set linker option (see tcc -hh)\n"
     "Debugger options:\n"
-    "  -g           generate runtime debug info\n"
+    "  -g           generate stab runtime debug info\n"
+    "  -gdwarf[-x]  generate dwarf runtime debug info\n"
+#ifdef TCC_TARGET_PE
+    "  -g.pdb       create .pdb debug database\n"
+#endif
 #ifdef CONFIG_TCC_BCHECK
     "  -b           compile with built-in memory and bounds checker (implies -g)\n"
 #endif
@@ -77,7 +80,7 @@ static const char help[] =
     "  -m32/64      defer to i386/x86_64 cross compiler\n"
 #endif
     "Tools:\n"
-    "  create library  : tcc -ar [rcsv] lib.a [files]\n"
+    "  create library  : tcc -ar [crstvx] lib [files]\n"
 #ifdef TCC_TARGET_PE
     "  create def file : tcc -impdef lib.dll [-v] [-o lib.def]\n"
 #endif
@@ -141,9 +144,12 @@ static const char help2[] =
     "  -rpath=                       set dynamic library search path\n"
     "  -enable-new-dtags             set DT_RUNPATH instead of DT_RPATH\n"
     "  -soname=                      set DT_SONAME elf tag\n"
+#if defined(TCC_TARGET_MACHO)
+    "  -install_name=                set DT_SONAME elf tag (soname macOS alias)\n"
+#endif
     "  -Bsymbolic                    set DT_SYMBOLIC elf tag\n"
     "  -oformat=[elf32/64-* binary]  set executable output format\n"
-    "  -init= -fini= -as-needed -O   (ignored)\n"
+    "  -init= -fini= -Map= -as-needed -O   (ignored)\n"
     "Predefined macros:\n"
     "  tcc -E -dM - < /dev/null\n"
 #endif
@@ -205,10 +211,8 @@ static void print_search_dirs(TCCState *s)
     /* print_dirs("programs", NULL, 0); */
     print_dirs("include", s->sysinclude_paths, s->nb_sysinclude_paths);
     print_dirs("libraries", s->library_paths, s->nb_library_paths);
-#ifdef TCC_TARGET_PE
-    printf("libtcc1:\n  %s/lib/"TCC_LIBTCC1"\n", s->tcc_lib_path);
-#else
-    printf("libtcc1:\n  %s/"TCC_LIBTCC1"\n", s->tcc_lib_path);
+    printf("libtcc1:\n  %s/%s\n", s->library_paths[0], CONFIG_TCC_CROSSPREFIX TCC_LIBTCC1);
+#if !defined TCC_TARGET_PE && !defined TCC_TARGET_MACHO
     print_dirs("crt", s->crt_paths, s->nb_crt_paths);
     printf("elfinterp:\n  %s\n",  DEFAULT_ELFINTERP(s));
 #endif
@@ -280,7 +284,12 @@ int main(int argc0, char **argv0)
 redo:
     argc = argc0, argv = argv0;
     s = s1 = tcc_new();
+#ifdef CONFIG_TCC_SWITCHES /* predefined options */
+    tcc_set_options(s, CONFIG_TCC_SWITCHES);
+#endif
     opt = tcc_parse_args(s, &argc, &argv, 1);
+    if (opt < 0)
+        return 1;
 
     if (n == 0) {
         if (opt == OPT_HELP) {
@@ -294,9 +303,9 @@ int main(int argc0, char **argv0)
             return 0;
         }
         if (opt == OPT_M32 || opt == OPT_M64)
-            tcc_tool_cross(s, argv, opt); /* never returns */
+            return tcc_tool_cross(s, argv, opt);
         if (s->verbose)
-            printf(version);
+            printf("%s", version);
         if (opt == OPT_AR)
             return tcc_tool_ar(s, argc, argv);
 #ifdef TCC_TARGET_PE
@@ -313,22 +322,22 @@ int main(int argc0, char **argv0)
             return 0;
         }
 
-        if (s->nb_files == 0)
-            tcc_error("no input files");
-
-        if (s->output_type == TCC_OUTPUT_PREPROCESS) {
+        if (s->nb_files == 0) {
+            tcc_error_noabort("no input files");
+        } else if (s->output_type == TCC_OUTPUT_PREPROCESS) {
             if (s->outfile && 0!=strcmp("-",s->outfile)) {
                 ppfp = fopen(s->outfile, "w");
                 if (!ppfp)
-                    tcc_error("could not write '%s'", s->outfile);
+                    tcc_error_noabort("could not write '%s'", s->outfile);
             }
         } else if (s->output_type == TCC_OUTPUT_OBJ && !s->option_r) {
             if (s->nb_libraries)
-                tcc_error("cannot specify libraries with -c");
-            if (s->nb_files > 1 && s->outfile)
-                tcc_error("cannot specify output file with -c many files");
+                tcc_error_noabort("cannot specify libraries with -c");
+            else if (s->nb_files > 1 && s->outfile)
+                tcc_error_noabort("cannot specify output file with -c many files");
         }
-
+        if (s->nb_errors)
+            return 1;
         if (s->do_bench)
             start_time = getclock_ms();
     }
@@ -386,7 +395,7 @@ int main(int argc0, char **argv0)
             if (!s->just_deps && tcc_output_file(s, s->outfile))
                 ret = 1;
             else if (s->gen_deps)
-                gen_makedeps(s, s->outfile, s->deps_outfile);
+                ret = gen_makedeps(s, s->outfile, s->deps_outfile);
         }
     }
 
diff --git a/tcc.h b/tcc.h
index d66baf785..e41738634 100644
--- a/tcc.h
+++ b/tcc.h
@@ -65,19 +65,13 @@ extern long double strtold (const char *__nptr, char **__endptr);
 # ifndef __GNUC__
 #  define strtold (long double)strtod
 #  define strtof (float)strtod
-#  ifdef _WIN64
-#   define strtoll _strtoi64
-#   define strtoull _strtoui64
-#  else
-#   define strtoll strtol
-#   define strtoull strtoul
-#  endif
+#  define strtoll _strtoi64
+#  define strtoull _strtoui64
 # endif
 # ifdef LIBTCC_AS_DLL
 #  define LIBTCCAPI __declspec(dllexport)
 #  define PUB_FUNC LIBTCCAPI
 # endif
-# define inp next_inp /* inp is an intrinsic on msvc/mingw */
 # ifdef _MSC_VER
 #  pragma warning (disable : 4244)  // conversion from 'uint64_t' to 'int', possible loss of data
 #  pragma warning (disable : 4267)  // conversion from 'size_t' to 'int', possible loss of data
@@ -203,8 +197,7 @@ extern long double strtold (const char *__nptr, char **__endptr);
 # endif
 #endif
 
-#if !defined TCC_IS_NATIVE \
-    || (defined CONFIG_TCC_BACKTRACE && CONFIG_TCC_BACKTRACE==0)
+#if defined CONFIG_TCC_BACKTRACE && CONFIG_TCC_BACKTRACE==0
 # undef CONFIG_TCC_BACKTRACE
 #else
 # define CONFIG_TCC_BACKTRACE 1 /* enable builtin stack backtraces */
@@ -216,6 +209,12 @@ extern long double strtold (const char *__nptr, char **__endptr);
 #  define CONFIG_TCC_BCHECK 1 /* enable bound checking code */
 #endif
 
+#if defined CONFIG_NEW_MACHO && CONFIG_NEW_MACHO==0
+#  undef CONFIG_NEW_MACHO
+#else
+#  define CONFIG_NEW_MACHO 1 /* enable new macho code */
+#endif
+
 #if defined TARGETOS_OpenBSD \
     || defined TARGETOS_FreeBSD \
     || defined TARGETOS_NetBSD \
@@ -237,6 +236,10 @@ extern long double strtold (const char *__nptr, char **__endptr);
 # define TCC_USING_DOUBLE_FOR_LDOUBLE 1
 #endif
 
+#ifdef CONFIG_TCC_PIE
+# define CONFIG_TCC_PIC 1
+#endif
+
 /* ------------ path configuration ------------ */
 
 #ifndef CONFIG_SYSROOT
@@ -258,9 +261,7 @@ extern long double strtold (const char *__nptr, char **__endptr);
 
 /* path to find crt1.o, crti.o and crtn.o */
 #ifndef CONFIG_TCC_CRTPREFIX
-# define CONFIG_TCC_CRTPREFIX \
-        ALSO_TRIPLET(CONFIG_SYSROOT "/usr/" CONFIG_LDDIR) \
-    ":" USE_TRIPLET(CONFIG_SYSROOT "/usr") "/lib"
+# define CONFIG_TCC_CRTPREFIX USE_TRIPLET(CONFIG_SYSROOT "/usr/" CONFIG_LDDIR)
 #endif
 
 #ifndef CONFIG_USR_INCLUDE
@@ -277,21 +278,18 @@ extern long double strtold (const char *__nptr, char **__endptr);
 #  define CONFIG_TCC_SYSINCLUDEPATHS \
         "{B}/include" \
     ":" ALSO_TRIPLET(CONFIG_SYSROOT "/usr/local/include") \
-    ":" USE_TRIPLET(CONFIG_SYSROOT "/usr") "/include" \
-    ":" USE_TRIPLET(CONFIG_SYSROOT "/usr/local") "/include" \
     ":" ALSO_TRIPLET(CONFIG_SYSROOT CONFIG_USR_INCLUDE)
 # endif
 #endif
 
 /* library search paths */
 #ifndef CONFIG_TCC_LIBPATHS
-# ifdef TCC_TARGET_PE
+# if defined TCC_TARGET_PE || defined _WIN32
 #  define CONFIG_TCC_LIBPATHS "{B}/lib"
 # else
 #  define CONFIG_TCC_LIBPATHS \
-        ALSO_TRIPLET(CONFIG_SYSROOT "/usr/" CONFIG_LDDIR) \
-    ":" USE_TRIPLET(CONFIG_SYSROOT "/usr") "/lib" \
-    ":" USE_TRIPLET(CONFIG_SYSROOT "/usr/local") "/lib" \
+        "{B}" \
+    ":" ALSO_TRIPLET(CONFIG_SYSROOT "/usr/" CONFIG_LDDIR) \
     ":" ALSO_TRIPLET(CONFIG_SYSROOT "/" CONFIG_LDDIR) \
     ":" ALSO_TRIPLET(CONFIG_SYSROOT "/usr/local/" CONFIG_LDDIR)
 # endif
@@ -358,6 +356,10 @@ extern long double strtold (const char *__nptr, char **__endptr);
 # define TCC_LIBTCC1 "libtcc1.a"
 #endif
 
+#ifndef CONFIG_TCC_CROSSPREFIX
+# define CONFIG_TCC_CROSSPREFIX ""
+#endif
+
 /* library to use with CONFIG_USE_LIBGCC instead of libtcc1.a */
 #if defined CONFIG_USE_LIBGCC && !defined TCC_LIBGCC
 #define TCC_LIBGCC USE_TRIPLET(CONFIG_SYSROOT "/" CONFIG_LDDIR) "/libgcc_s.so.1"
@@ -368,6 +370,7 @@ extern long double strtold (const char *__nptr, char **__endptr);
 #include "libtcc.h"
 #include "elf.h"
 #include "stab.h"
+#include "dwarf.h"
 
 /* -------------------------------------------- */
 
@@ -396,6 +399,7 @@ extern long double strtold (const char *__nptr, char **__endptr);
 
 #ifdef TCC_PROFILE /* profile all functions */
 # define static
+# define inline
 #endif
 
 /* -------------------------------------------- */
@@ -461,7 +465,7 @@ extern long double strtold (const char *__nptr, char **__endptr);
 
 #define INCLUDE_STACK_SIZE  32
 #define IFDEF_STACK_SIZE    64
-#define VSTACK_SIZE         256
+#define VSTACK_SIZE         512
 #define STRING_MAX_SIZE     1024
 #define TOKSTR_MAX_SIZE     256
 #define PACK_STACK_SIZE     8
@@ -490,8 +494,8 @@ typedef int nwchar_t;
 
 typedef struct CString {
     int size; /* size in bytes */
-    void *data; /* either 'char *' or 'nwchar_t *' */
     int size_allocated;
+    void *data; /* either 'char *' or 'nwchar_t *' */
 } CString;
 
 /* type definition */
@@ -541,7 +545,8 @@ struct SymAttr {
     nodecorate  : 1,
     dllimport   : 1,
     addrtaken   : 1,
-    xxxx        : 3; /* not used */
+    nodebug     : 1,
+    xxxx        : 2; /* not used */
 };
 
 /* function attributes or temporary attributes for parsing */
@@ -614,6 +619,7 @@ typedef struct Section {
 typedef struct DLLReference {
     int level;
     void *handle;
+    unsigned char found, index;
     char name[1];
 } DLLReference;
 
@@ -727,8 +733,8 @@ typedef struct ExprValue {
 
 #define MAX_ASM_OPERANDS 30
 typedef struct ASMOperand {
-    int id; /* GCC 3 optional identifier (0 if number only supported */
-    char *constraint;
+    int id; /* GCC 3 optional identifier (0 if number only supported) */
+    char constraint[16];
     char asm_str[16]; /* computed asm string for operand */
     SValue *vt; /* C value of the expression */
     int ref_index; /* if >= 0, gives reference to a output constraint */
@@ -738,6 +744,7 @@ typedef struct ASMOperand {
     int is_llong; /* true if double register value */
     int is_memory; /* true if memory operand */
     int is_rw;     /* for '+' modifier */
+    int is_label;  /* for asm goto */
 } ASMOperand;
 #endif
 
@@ -789,9 +796,11 @@ struct TCCState {
     unsigned char just_deps; /* option -M  */
     unsigned char gen_deps; /* option -MD  */
     unsigned char include_sys_deps; /* option -MD  */
+    unsigned char gen_phony_deps; /* option -MP */
 
     /* compile with debug symbol (and use them if error during execution) */
     unsigned char do_debug;
+    unsigned char dwarf;
     unsigned char do_backtrace;
 #ifdef CONFIG_TCC_BCHECK
     /* compile with built-in memory and bounds checker */
@@ -824,9 +833,10 @@ struct TCCState {
     char *tcc_lib_path; /* CONFIG_TCCDIR or -B option */
     char *soname; /* as specified on the command line (-soname) */
     char *rpath; /* as specified on the command line (-Wl,-rpath=) */
-
+    char *elf_entryname; /* "_start" unless set */
     char *init_symbol; /* symbols to call at load-time (not used currently) */
     char *fini_symbol; /* symbols to call at unload-time (not used currently) */
+    char *mapfile; /* create a mapfile (not used currently) */
 
     /* output type, see TCC_OUTPUT_XXX */
     int output_type;
@@ -903,10 +913,6 @@ struct TCCState {
     Section **priv_sections;
     int nb_priv_sections; /* number of private sections */
 
-    /* got & plt handling */
-    Section *got;
-    Section *plt;
-
     /* predefined sections */
     Section *text_section, *data_section, *rodata_section, *bss_section;
     Section *common_section;
@@ -916,21 +922,32 @@ struct TCCState {
     Section *bounds_section; /* contains global data bound description */
     Section *lbounds_section; /* contains local data bound description */
 #endif
-    /* test coverage */
-    Section *tcov_section;
-    /* symbol sections */
+    /* symbol section */
     Section *symtab_section;
-    /* debug sections */
-    Section *stab_section;
-    /* Is there a new undefined sym since last new_undef_sym() */
-    int new_undef_sym;
-
     /* temporary dynamic symbol sections (for dll loading) */
     Section *dynsymtab_section;
     /* exported dynamic symbol section */
     Section *dynsym;
     /* copy of the global symtab_section variable */
     Section *symtab;
+    /* got & plt handling */
+    Section *got, *plt;
+    /* debug sections */
+    Section *stab_section;
+    Section *dwarf_info_section;
+    Section *dwarf_abbrev_section;
+    Section *dwarf_line_section;
+    Section *dwarf_aranges_section;
+    Section *dwarf_str_section;
+    Section *dwarf_line_str_section;
+    int dwlo, dwhi; /* dwarf section range */
+    /* test coverage */
+    Section *tcov_section;
+    /* debug state */
+    struct _tccdbg *dState;
+
+    /* Is there a new undefined sym since last new_undef_sym() */
+    int new_undef_sym;
     /* extra attributes (eg. GOT/PLT value) for symtab symbols */
     struct sym_attr *sym_attrs;
     int nb_sym_attrs;
@@ -957,6 +974,12 @@ struct TCCState {
 # endif
 #endif
 
+#if defined TCC_TARGET_MACHO
+    char *install_name;
+    uint32_t compatibility_version;
+    uint32_t current_version;
+#endif
+
 #ifndef ELF_OBJ_ONLY
     int nb_sym_versions;
     struct sym_version *sym_versions;
@@ -967,8 +990,6 @@ struct TCCState {
     Section *verneed_section;
 #endif
 
-    char *elf_entryname;
-
 #ifdef TCC_IS_NATIVE
     const char *runtime_main;
     void **runtime_mem;
@@ -982,8 +1003,8 @@ struct TCCState {
     /* benchmark info */
     int total_idents;
     int total_lines;
-    int total_bytes;
-    int total_output[4];
+    unsigned int total_bytes;
+    unsigned int total_output[4];
 
     /* option -dnum (for general development purposes) */
     int g_debug;
@@ -1002,6 +1023,7 @@ struct TCCState {
     char *deps_outfile; /* option -MF */
     int argc;
     char **argv;
+    CString linker_arg; /* collect -Wl options */
 };
 
 struct filespec {
@@ -1021,6 +1043,8 @@ struct filespec {
 #define VT_SYM       0x0200  /* a symbol value is added */
 #define VT_MUSTCAST  0x0C00  /* value must be casted to be correct (used for
                                 char/short stored in integer registers) */
+#define VT_NONCONST  0x1000  /* VT_CONST, but not an (C standard) integer
+                                constant expression */
 #define VT_MUSTBOUND 0x4000  /* bound checking must be done before
                                 dereferencing value */
 #define VT_BOUNDED   0x8000  /* value is bounded. The address of the
@@ -1186,6 +1210,8 @@ enum tcc_token {
 /* ------------ libtcc.c ------------ */
 
 ST_DATA struct TCCState *tcc_state;
+ST_DATA void** stk_data;
+ST_DATA int nb_stk_data;
 
 /* public functions currently used by the tcc main function */
 ST_FUNC char *pstrcpy(char *buf, size_t buf_size, const char *s);
@@ -1218,7 +1244,7 @@ PUB_FUNC char *tcc_strdup_debug(const char *str, const char *file, int line);
 #define realloc(p, s) use_tcc_realloc(p, s)
 #undef strdup
 #define strdup(s) use_tcc_strdup(s)
-PUB_FUNC void _tcc_error_noabort(const char *fmt, ...) PRINTF_LIKE(1,2);
+PUB_FUNC int _tcc_error_noabort(const char *fmt, ...) PRINTF_LIKE(1,2);
 PUB_FUNC NORETURN void _tcc_error(const char *fmt, ...) PRINTF_LIKE(1,2);
 PUB_FUNC void _tcc_warning(const char *fmt, ...) PRINTF_LIKE(1,2);
 #define tcc_internal_error(msg) tcc_error("internal compiler error\n"\
@@ -1235,11 +1261,17 @@ ST_FUNC void cstr_free(CString *cstr);
 ST_FUNC int cstr_printf(CString *cs, const char *fmt, ...) PRINTF_LIKE(2,3);
 ST_FUNC int cstr_vprintf(CString *cstr, const char *fmt, va_list ap);
 ST_FUNC void cstr_reset(CString *cstr);
-
 ST_FUNC void tcc_open_bf(TCCState *s1, const char *filename, int initlen);
 ST_FUNC int tcc_open(TCCState *s1, const char *filename);
 ST_FUNC void tcc_close(void);
 
+/* mark a memory pointer on stack for cleanup after errors */
+#define stk_push(p) dynarray_add(&stk_data, &nb_stk_data, p)
+#define stk_pop() (--nb_stk_data)
+/* mark CString on stack for cleanup errors */
+#define cstr_new_s(cstr) (cstr_new(cstr), stk_push(&(cstr)->data))
+#define cstr_free_s(cstr) (cstr_free(cstr), stk_pop())
+
 ST_FUNC int tcc_add_file_internal(TCCState *s1, const char *filename, int flags);
 /* flags: */
 #define AFF_PRINT_ERROR     0x10 /* print error if file not found */
@@ -1262,9 +1294,8 @@ ST_FUNC int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
 #ifndef ELF_OBJ_ONLY
 ST_FUNC int tcc_add_crt(TCCState *s, const char *filename);
 #endif
-#ifndef TCC_TARGET_MACHO
 ST_FUNC int tcc_add_dll(TCCState *s, const char *filename, int flags);
-#endif
+ST_FUNC void tcc_add_support(TCCState *s1, const char *filename);
 #ifdef CONFIG_TCC_BCHECK
 ST_FUNC void tcc_add_bcheck(TCCState *s1);
 #endif
@@ -1278,8 +1309,10 @@ PUB_FUNC int tcc_parse_args(TCCState *s, int *argc, char ***argv, int optind);
 #ifdef _WIN32
 ST_FUNC char *normalize_slashes(char *path);
 #endif
-ST_FUNC DLLReference *tcc_add_dllref(TCCState *s1, const char *dllname);
+ST_FUNC DLLReference *tcc_add_dllref(TCCState *s1, const char *dllname, int level);
 ST_FUNC char *tcc_load_text(int fd);
+/* for #pragma once */
+ST_FUNC int normalized_PATHCMP(const char *f1, const char *f2);
 
 /* tcc_parse_args return codes: */
 #define OPT_HELP 1
@@ -1294,7 +1327,7 @@ ST_FUNC char *tcc_load_text(int fd);
 /* ------------ tccpp.c ------------ */
 
 ST_DATA struct BufferedFile *file;
-ST_DATA int ch, tok;
+ST_DATA int tok;
 ST_DATA CValue tokc;
 ST_DATA const int *macro_ptr;
 ST_DATA int parse_flags;
@@ -1348,9 +1381,6 @@ ST_INLN void define_push(int v, int macro_type, int *str, Sym *first_arg);
 ST_FUNC void define_undef(Sym *s);
 ST_INLN Sym *define_find(int v);
 ST_FUNC void free_defines(Sym *b);
-ST_FUNC Sym *label_find(int v);
-ST_FUNC Sym *label_push(Sym **ptop, int v, int flags);
-ST_FUNC void label_pop(Sym **ptop, Sym *slast, int keep);
 ST_FUNC void parse_define(void);
 ST_FUNC void preprocess(int is_bof);
 ST_FUNC void next(void);
@@ -1394,20 +1424,14 @@ ST_DATA SValue *vtop;
 ST_DATA int rsym, anon_sym, ind, loc;
 ST_DATA char debug_modes;
 
-ST_DATA int const_wanted; /* true if constant wanted */
 ST_DATA int nocode_wanted; /* true if no code generation wanted for an expression */
 ST_DATA int global_expr;  /* true if compound literals must be allocated globally (used during initializers parsing */
 ST_DATA CType func_vt; /* current function return type (used by return instruction) */
 ST_DATA int func_var; /* true if current function is variadic */
 ST_DATA int func_vc;
+ST_DATA int func_ind;
 ST_DATA const char *funcname;
 
-ST_FUNC void tcc_debug_start(TCCState *s1);
-ST_FUNC void tcc_debug_end(TCCState *s1);
-ST_FUNC void tcc_debug_bincl(TCCState *s1);
-ST_FUNC void tcc_debug_eincl(TCCState *s1);
-ST_FUNC void tcc_debug_putfile(TCCState *s1, const char *filename);
-
 ST_FUNC void tccgen_init(TCCState *s1);
 ST_FUNC int tccgen_compile(TCCState *s1);
 ST_FUNC void tccgen_finish(TCCState *s1);
@@ -1433,6 +1457,9 @@ ST_FUNC void sym_pop(Sym **ptop, Sym *b, int keep);
 ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int c);
 ST_FUNC Sym *sym_find2(Sym *s, int v);
 ST_INLN Sym *sym_find(int v);
+ST_FUNC Sym *label_find(int v);
+ST_FUNC Sym *label_push(Sym **ptop, int v, int flags);
+ST_FUNC void label_pop(Sym **ptop, Sym *slast, int keep);
 ST_INLN Sym *struct_find(int v);
 
 ST_FUNC Sym *global_identifier_push(int v, int t, int c);
@@ -1467,8 +1494,8 @@ ST_FUNC int type_size(CType *type, int *a);
 ST_FUNC void mk_pointer(CType *type);
 ST_FUNC void vstore(void);
 ST_FUNC void inc(int post, int c);
-ST_FUNC void parse_mult_str (CString *astr, const char *msg);
-ST_FUNC void parse_asm_str(CString *astr);
+ST_FUNC CString* parse_mult_str(const char *msg);
+ST_FUNC CString* parse_asm_str(void);
 ST_FUNC void indir(void);
 ST_FUNC void unary(void);
 ST_FUNC void gexpr(void);
@@ -1489,8 +1516,9 @@ ST_DATA int func_bound_add_epilog;
 #define TCC_OUTPUT_FORMAT_ELF    0 /* default output format: ELF */
 #define TCC_OUTPUT_FORMAT_BINARY 1 /* binary image output */
 #define TCC_OUTPUT_FORMAT_COFF   2 /* COFF */
+#define TCC_OUTPUT_DYN           TCC_OUTPUT_DLL
 
-#define ARMAG  "!<arch>\012"    /* For COFF and a.out archives */
+#define ARMAG  "!<arch>\n"    /* For COFF and a.out archives */
 
 typedef struct {
     unsigned int n_strx;         /* index into string table of name */
@@ -1502,7 +1530,6 @@ typedef struct {
 
 ST_FUNC void tccelf_new(TCCState *s);
 ST_FUNC void tccelf_delete(TCCState *s);
-ST_FUNC void tccelf_stab_new(TCCState *s);
 ST_FUNC void tccelf_begin_file(TCCState *s1);
 ST_FUNC void tccelf_end_file(TCCState *s1);
 #ifdef CONFIG_TCC_BCHECK
@@ -1522,10 +1549,6 @@ ST_FUNC int find_elf_sym(Section *s, const char *name);
 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset, int type, int symbol);
 ST_FUNC void put_elf_reloca(Section *symtab, Section *s, unsigned long offset, int type, int symbol, addr_t addend);
 
-ST_FUNC void put_stabs(TCCState *s1, const char *str, int type, int other, int desc, unsigned long value);
-ST_FUNC void put_stabs_r(TCCState *s1, const char *str, int type, int other, int desc, unsigned long value, Section *sec, int sym_index);
-ST_FUNC void put_stabn(TCCState *s1, int type, int other, int desc, int value);
-
 ST_FUNC void resolve_common_syms(TCCState *s1);
 ST_FUNC void relocate_syms(TCCState *s1, Section *symtab, int do_resolve);
 ST_FUNC void relocate_sections(TCCState *s1);
@@ -1537,9 +1560,6 @@ ST_FUNC int tcc_load_object_file(TCCState *s1, int fd, unsigned long file_offset
 ST_FUNC int tcc_load_archive(TCCState *s1, int fd, int alacarte);
 ST_FUNC void add_array(TCCState *s1, const char *sec, int c);
 
-#if !defined(ELF_OBJ_ONLY) || (defined(TCC_TARGET_MACHO) && defined TCC_IS_NATIVE)
-ST_FUNC void build_got_entries(TCCState *s1);
-#endif
 ST_FUNC struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc);
 ST_FUNC addr_t get_sym_addr(TCCState *s, const char *name, int err, int forc);
 ST_FUNC void list_elf_symbols(TCCState *s, void *ctx,
@@ -1562,6 +1582,9 @@ ST_FUNC void tcc_add_runtime(TCCState *s1);
 
 /* ------------ xxx-link.c ------------ */
 
+#if !defined ELF_OBJ_ONLY || defined TCC_TARGET_MACHO
+ST_FUNC int code_reloc (int reloc_type);
+ST_FUNC int gotplt_entry_type (int reloc_type);
 /* Whether to generate a GOT/PLT entry and when. NO_GOTPLT_ENTRY is first so
    that unknown relocation don't create a GOT or PLT entry */
 enum gotplt_entry {
@@ -1570,15 +1593,17 @@ enum gotplt_entry {
     AUTO_GOTPLT_ENTRY,	/* generate if sym is UNDEF */
     ALWAYS_GOTPLT_ENTRY	/* always generate (eg. PLTOFF relocs) */
 };
+#define NEED_RELOC_TYPE
 
-#if !defined(ELF_OBJ_ONLY) || defined(TCC_TARGET_MACHO)
-ST_FUNC int code_reloc (int reloc_type);
-ST_FUNC int gotplt_entry_type (int reloc_type);
-#if !defined(TCC_TARGET_MACHO) || defined TCC_IS_NATIVE
+#if !defined TCC_TARGET_MACHO || defined TCC_IS_NATIVE
 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr);
 ST_FUNC void relocate_plt(TCCState *s1);
+ST_FUNC void build_got_entries(TCCState *s1, int got_sym); /* in tccelf.c */
+#define NEED_BUILD_GOT
+
 #endif
 #endif
+
 ST_FUNC void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t addr, addr_t val);
 
 /* ------------ xxx-gen.c ------------ */
@@ -1696,7 +1721,6 @@ ST_FUNC void gen_increment_tcov (SValue *sv);
 #endif
 
 /* ------------ tcccoff.c ------------ */
-
 #ifdef TCC_TARGET_COFF
 ST_FUNC int tcc_output_coff(TCCState *s1, FILE *f);
 ST_FUNC int tcc_load_coff(TCCState * s1, int fd);
@@ -1775,8 +1799,65 @@ ST_FUNC int tcc_tool_ar(TCCState *s, int argc, char **argv);
 #ifdef TCC_TARGET_PE
 ST_FUNC int tcc_tool_impdef(TCCState *s, int argc, char **argv);
 #endif
-ST_FUNC void tcc_tool_cross(TCCState *s, char **argv, int option);
-ST_FUNC void gen_makedeps(TCCState *s, const char *target, const char *filename);
+ST_FUNC int tcc_tool_cross(TCCState *s, char **argv, int option);
+ST_FUNC int gen_makedeps(TCCState *s, const char *target, const char *filename);
+#endif
+
+/* ------------ tccdbg.c ------------ */
+
+ST_FUNC void tcc_debug_new(TCCState *s);
+
+ST_FUNC void tcc_debug_start(TCCState *s1);
+ST_FUNC void tcc_debug_end(TCCState *s1);
+ST_FUNC void tcc_debug_bincl(TCCState *s1);
+ST_FUNC void tcc_debug_eincl(TCCState *s1);
+ST_FUNC void tcc_debug_putfile(TCCState *s1, const char *filename);
+
+ST_FUNC void tcc_debug_line(TCCState *s1);
+ST_FUNC void tcc_add_debug_info(TCCState *s1, int param, Sym *s, Sym *e);
+ST_FUNC void tcc_debug_funcstart(TCCState *s1, Sym *sym);
+ST_FUNC void tcc_debug_prolog_epilog(TCCState *s1, int value);
+ST_FUNC void tcc_debug_funcend(TCCState *s1, int size);
+ST_FUNC void tcc_debug_extern_sym(TCCState *s1, Sym *sym, int sh_num, int sym_bind, int sym_type);
+ST_FUNC void tcc_debug_typedef(TCCState *s1, Sym *sym);
+ST_FUNC void tcc_debug_stabn(TCCState *s1, int type, int value);
+ST_FUNC void tcc_debug_fix_anon(TCCState *s1, CType *t);
+
+ST_FUNC void tcc_tcov_start(TCCState *s1);
+ST_FUNC void tcc_tcov_end(TCCState *s1);
+ST_FUNC void tcc_tcov_check_line(TCCState *s1, int start);
+ST_FUNC void tcc_tcov_block_end(TCCState *s1, int line);
+ST_FUNC void tcc_tcov_block_begin(TCCState *s1);
+ST_FUNC void tcc_tcov_reset_ind(TCCState *s1);
+
+#define stab_section            s1->stab_section
+#define stabstr_section         stab_section->link
+#define tcov_section            s1->tcov_section
+#define dwarf_info_section      s1->dwarf_info_section
+#define dwarf_abbrev_section    s1->dwarf_abbrev_section
+#define dwarf_line_section      s1->dwarf_line_section
+#define dwarf_aranges_section   s1->dwarf_aranges_section
+#define dwarf_str_section       s1->dwarf_str_section
+#define dwarf_line_str_section  s1->dwarf_line_str_section
+
+/* default dwarf version for "-g". use 0 to emit stab debug infos */
+#ifndef DWARF_VERSION
+# define DWARF_VERSION 0
+#endif
+
+/* default dwarf version for "-gdwarf" */
+#ifdef TCC_TARGET_MACHO
+# define DEFAULT_DWARF_VERSION 2
+#else
+# define DEFAULT_DWARF_VERSION 5
+#endif
+
+#if defined TCC_TARGET_PE
+# define R_DATA_32DW 'Z' /* fake code to avoid DLL relocs */
+#elif defined TCC_TARGET_X86_64
+# define R_DATA_32DW R_X86_64_32
+#else
+# define R_DATA_32DW R_DATA_32
 #endif
 
 /********************************************************/
@@ -1818,10 +1899,7 @@ ST_FUNC void post_sem(TCCSem *p);
 #define cur_text_section    TCC_STATE_VAR(cur_text_section)
 #define bounds_section      TCC_STATE_VAR(bounds_section)
 #define lbounds_section     TCC_STATE_VAR(lbounds_section)
-#define tcov_section        TCC_STATE_VAR(tcov_section)
 #define symtab_section      TCC_STATE_VAR(symtab_section)
-#define stab_section        TCC_STATE_VAR(stab_section)
-#define stabstr_section     stab_section->link
 #define gnu_ext             TCC_STATE_VAR(gnu_ext)
 #define tcc_error_noabort   TCC_SET_STATE(_tcc_error_noabort)
 #define tcc_error           TCC_SET_STATE(_tcc_error)
@@ -1849,7 +1927,9 @@ PUB_FUNC void tcc_exit_state(TCCState *s1);
 # define TCC_STATE_VAR(sym) tcc_state->sym
 # define TCC_SET_STATE(fn) fn
 # undef USING_GLOBALS
+# undef _tcc_error
 #else
 # define TCC_STATE_VAR(sym) s1->sym
 # define TCC_SET_STATE(fn) (tcc_enter_state(s1),fn)
+# define _tcc_error use_tcc_error_noabort
 #endif
diff --git a/tccasm.c b/tccasm.c
index 2dd8921b1..fcae05eb2 100644
--- a/tccasm.c
+++ b/tccasm.c
@@ -23,14 +23,20 @@
 #ifdef CONFIG_TCC_ASM
 
 static Section *last_text_section; /* to handle .previous asm directive */
+static int asmgoto_n;
 
-ST_FUNC int asm_get_local_label_name(TCCState *s1, unsigned int n)
+static int asm_get_prefix_name(TCCState *s1, const char *prefix, unsigned int n)
 {
     char buf[64];
-    snprintf(buf, sizeof(buf), "L..%u", n);
+    snprintf(buf, sizeof(buf), "%s%u", prefix, n);
     return tok_alloc_const(buf);
 }
 
+ST_FUNC int asm_get_local_label_name(TCCState *s1, unsigned int n)
+{
+    return asm_get_prefix_name(s1, "L..", n);
+}
+
 static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global);
 static Sym* asm_new_label(TCCState *s1, int label, int is_local);
 static Sym* asm_new_label1(TCCState *s1, int label, int is_local, int sh_num, int value);
@@ -1058,15 +1064,12 @@ ST_FUNC int find_constraint(ASMOperand *operands, int nb_operands,
 }
 
 static void subst_asm_operands(ASMOperand *operands, int nb_operands, 
-                               CString *out_str, CString *in_str)
+                               CString *out_str, const char *str)
 {
     int c, index, modifier;
-    const char *str;
     ASMOperand *op;
     SValue sv;
 
-    cstr_new(out_str);
-    str = in_str->data;
     for(;;) {
         c = *str++;
         if (c == '%') {
@@ -1077,7 +1080,7 @@ static void subst_asm_operands(ASMOperand *operands, int nb_operands,
             modifier = 0;
             if (*str == 'c' || *str == 'n' ||
                 *str == 'b' || *str == 'w' || *str == 'h' || *str == 'k' ||
-		*str == 'q' ||
+		*str == 'q' || *str == 'l' ||
 		/* P in GCC would add "@PLT" to symbol refs in PIC mode,
 		   and make literal operands not be decorated with '$'.  */
 		*str == 'P')
@@ -1086,13 +1089,17 @@ static void subst_asm_operands(ASMOperand *operands, int nb_operands,
             if (index < 0)
                 tcc_error("invalid operand reference after %%");
             op = &operands[index];
-            sv = *op->vt;
-            if (op->reg >= 0) {
-                sv.r = op->reg;
-                if ((op->vt->r & VT_VALMASK) == VT_LLOCAL && op->is_memory)
-                    sv.r |= VT_LVAL;
+            if (modifier == 'l') {
+                cstr_cat(out_str, get_tok_str(op->is_label, NULL), -1);
+            } else {
+                sv = *op->vt;
+                if (op->reg >= 0) {
+                    sv.r = op->reg;
+                    if ((op->vt->r & VT_VALMASK) == VT_LLOCAL && op->is_memory)
+                      sv.r |= VT_LVAL;
+                }
+                subst_asm_operand(out_str, &sv, modifier);
             }
-            subst_asm_operand(out_str, &sv, modifier);
         } else {
         add_char:
             cstr_ccat(out_str, c);
@@ -1108,11 +1115,11 @@ static void parse_asm_operands(ASMOperand *operands, int *nb_operands_ptr,
 {
     ASMOperand *op;
     int nb_operands;
+    char* astr;
 
     if (tok != ':') {
         nb_operands = *nb_operands_ptr;
         for(;;) {
-	    CString astr;
             if (nb_operands >= MAX_ASM_OPERANDS)
                 tcc_error("too many asm operands");
             op = &operands[nb_operands++];
@@ -1125,10 +1132,8 @@ static void parse_asm_operands(ASMOperand *operands, int *nb_operands_ptr,
                 next();
                 skip(']');
             }
-	    parse_mult_str(&astr, "string constant");
-            op->constraint = tcc_malloc(astr.size);
-            strcpy(op->constraint, astr.data);
-	    cstr_free(&astr);
+	    astr = parse_mult_str("string constant")->data;
+            pstrcpy(op->constraint, sizeof op->constraint, astr);
             skip('(');
             gexpr();
             if (is_output) {
@@ -1161,20 +1166,27 @@ static void parse_asm_operands(ASMOperand *operands, int *nb_operands_ptr,
 /* parse the GCC asm() instruction */
 ST_FUNC void asm_instr(void)
 {
-    CString astr, astr1;
+    CString astr, *astr1;
+
     ASMOperand operands[MAX_ASM_OPERANDS];
-    int nb_outputs, nb_operands, i, must_subst, out_reg;
+    int nb_outputs, nb_operands, i, must_subst, out_reg, nb_labels;
     uint8_t clobber_regs[NB_ASM_REGS];
     Section *sec;
 
     /* since we always generate the asm() instruction, we can ignore
        volatile */
-    if (tok == TOK_VOLATILE1 || tok == TOK_VOLATILE2 || tok == TOK_VOLATILE3) {
+    while (tok == TOK_VOLATILE1 || tok == TOK_VOLATILE2 || tok == TOK_VOLATILE3
+           || tok == TOK_GOTO) {
         next();
     }
-    parse_asm_str(&astr);
+
+    astr1 = parse_asm_str();
+    cstr_new_s(&astr);
+    cstr_cat(&astr, astr1->data, astr1->size);
+
     nb_operands = 0;
     nb_outputs = 0;
+    nb_labels = 0;
     must_subst = 0;
     memset(clobber_regs, 0, sizeof(clobber_regs));
     if (tok == ':') {
@@ -1193,6 +1205,8 @@ ST_FUNC void asm_instr(void)
                     /* XXX: handle registers */
                     next();
                     for(;;) {
+                        if (tok == ':')
+                          break;
                         if (tok != TOK_STR)
                             expect("string constant");
                         asm_clobber(clobber_regs, tokc.str.data);
@@ -1204,6 +1218,39 @@ ST_FUNC void asm_instr(void)
                         }
                     }
                 }
+                if (tok == ':') {
+                    /* goto labels */
+                    next();
+                    for (;;) {
+                        Sym *csym;
+                        int asmname;
+                        if (nb_operands + nb_labels >= MAX_ASM_OPERANDS)
+                          tcc_error("too many asm operands");
+                        if (tok < TOK_UIDENT)
+                          expect("label identifier");
+                        operands[nb_operands + nb_labels++].id = tok;
+
+                        csym = label_find(tok);
+                        if (!csym) {
+                            csym = label_push(&global_label_stack, tok,
+                                              LABEL_FORWARD);
+                        } else {
+                            if (csym->r == LABEL_DECLARED)
+                              csym->r = LABEL_FORWARD;
+                        }
+                        next();
+                        asmname = asm_get_prefix_name(tcc_state, "LG.",
+                                                      ++asmgoto_n);
+                        if (!csym->c)
+                          put_extern_sym2(csym, SHN_UNDEF, 0, 0, 1);
+                        get_asm_sym(asmname, csym);
+                        operands[nb_operands + nb_labels - 1].is_label = asmname;
+
+                        if (tok != ',')
+                          break;
+                        next();
+                    }
+                }
             }
         }
     }
@@ -1226,13 +1273,14 @@ ST_FUNC void asm_instr(void)
     printf("asm: \"%s\"\n", (char *)astr.data);
 #endif
     if (must_subst) {
-        subst_asm_operands(operands, nb_operands, &astr1, &astr);
-        cstr_free(&astr);
-    } else {
-        astr1 = astr;
+        cstr_reset(astr1);
+        cstr_cat(astr1, astr.data, astr.size);
+        cstr_reset(&astr);
+        subst_asm_operands(operands, nb_operands + nb_labels, &astr, astr1->data);
     }
+
 #ifdef ASM_DEBUG
-    printf("subst_asm: \"%s\"\n", (char *)astr1.data);
+    printf("subst_asm: \"%s\"\n", (char *)astr.data);
 #endif
 
     /* generate loads */
@@ -1243,7 +1291,8 @@ ST_FUNC void asm_instr(void)
        bleed out to surrounding code.  */
     sec = cur_text_section;
     /* assemble the string with tcc internal assembler */
-    tcc_assemble_inline(tcc_state, astr1.data, astr1.size - 1, 0);
+    tcc_assemble_inline(tcc_state, astr.data, astr.size - 1, 0);
+    cstr_free_s(&astr);
     if (sec != cur_text_section) {
         tcc_warning("inline asm tries to change current section");
         use_section1(tcc_state, sec);
@@ -1258,23 +1307,20 @@ ST_FUNC void asm_instr(void)
     
     /* free everything */
     for(i=0;i<nb_operands;i++) {
-        ASMOperand *op;
-        op = &operands[i];
-        tcc_free(op->constraint);
         vpop();
     }
-    cstr_free(&astr1);
+
 }
 
 ST_FUNC void asm_global_instr(void)
 {
-    CString astr;
+    CString *astr;
     int saved_nocode_wanted = nocode_wanted;
 
     /* Global asm blocks are always emitted.  */
     nocode_wanted = 0;
     next();
-    parse_asm_str(&astr);
+    astr = parse_asm_str();
     skip(')');
     /* NOTE: we do not eat the ';' so that we can restore the current
        token after the assembler parsing */
@@ -1288,14 +1334,13 @@ ST_FUNC void asm_global_instr(void)
     ind = cur_text_section->data_offset;
 
     /* assemble the string with tcc internal assembler */
-    tcc_assemble_inline(tcc_state, astr.data, astr.size - 1, 1);
+    tcc_assemble_inline(tcc_state, astr->data, astr->size - 1, 1);
     
     cur_text_section->data_offset = ind;
 
     /* restore the current C token */
     next();
 
-    cstr_free(&astr);
     nocode_wanted = saved_nocode_wanted;
 }
 
diff --git a/tcccoff.c b/tcccoff.c
index 651bbe829..56064cdd6 100644
--- a/tcccoff.c
+++ b/tcccoff.c
@@ -21,6 +21,9 @@
 
 #include "tcc.h"
 
+/* XXX: this file uses tcc_error() to the effect of exit(1) */
+#undef _tcc_error
+
 #define MAXNSCNS 255		/* MAXIMUM NUMBER OF SECTIONS         */
 #define MAX_STR_TABLE 1000000
 AOUTHDR o_filehdr;		/* OPTIONAL (A.OUT) FILE HEADER       */
diff --git a/tccdbg.c b/tccdbg.c
new file mode 100644
index 000000000..2509bacea
--- /dev/null
+++ b/tccdbg.c
@@ -0,0 +1,2181 @@
+/*
+ *  TCC - Tiny C Compiler
+ *
+ *  Copyright (c) 2001-2004 Fabrice Bellard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "tcc.h"
+
+/* stab debug support */
+
+static const struct {
+  int type;
+  int size;
+  int encoding;
+  const char *name;
+} default_debug[] = {
+    {   VT_INT, 4, DW_ATE_signed, "int:t1=r1;-2147483648;2147483647;" },
+    {   VT_BYTE, 1, DW_ATE_signed_char, "char:t2=r2;0;127;" },
+#if LONG_SIZE == 4
+    {   VT_LONG | VT_INT, 4, DW_ATE_signed, "long int:t3=r3;-2147483648;2147483647;" },
+#else
+    {   VT_LLONG | VT_LONG, 8, DW_ATE_signed, "long int:t3=r3;-9223372036854775808;9223372036854775807;" },
+#endif
+    {   VT_INT | VT_UNSIGNED, 4, DW_ATE_unsigned, "unsigned int:t4=r4;0;037777777777;" },
+#if LONG_SIZE == 4
+    {   VT_LONG | VT_INT | VT_UNSIGNED, 4, DW_ATE_unsigned, "long unsigned int:t5=r5;0;037777777777;" },
+#else
+    /* use octal instead of -1 so size_t works (-gstabs+ in gcc) */
+    {   VT_LLONG | VT_LONG | VT_UNSIGNED, 8, DW_ATE_unsigned, "long unsigned int:t5=r5;0;01777777777777777777777;" },
+#endif
+    {   VT_QLONG, 16, DW_ATE_signed, "__int128:t6=r6;0;-1;" },
+    {   VT_QLONG | VT_UNSIGNED, 16, DW_ATE_unsigned, "__int128 unsigned:t7=r7;0;-1;" },
+    {   VT_LLONG, 8, DW_ATE_signed, "long long int:t8=r8;-9223372036854775808;9223372036854775807;" },
+    {   VT_LLONG | VT_UNSIGNED, 8, DW_ATE_unsigned, "long long unsigned int:t9=r9;0;01777777777777777777777;" },
+    {   VT_SHORT, 2, DW_ATE_signed, "short int:t10=r10;-32768;32767;" },
+    {   VT_SHORT | VT_UNSIGNED, 2, DW_ATE_unsigned, "short unsigned int:t11=r11;0;65535;" },
+    {   VT_BYTE | VT_DEFSIGN, 1, DW_ATE_signed_char, "signed char:t12=r12;-128;127;" },
+    {   VT_BYTE | VT_DEFSIGN | VT_UNSIGNED, 1, DW_ATE_unsigned_char, "unsigned char:t13=r13;0;255;" },
+    {   VT_FLOAT, 4, DW_ATE_float, "float:t14=r1;4;0;" },
+    {   VT_DOUBLE, 8, DW_ATE_float, "double:t15=r1;8;0;" },
+#ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
+    {   VT_DOUBLE | VT_LONG, 8, DW_ATE_float, "long double:t16=r1;8;0;" },
+#else
+    {   VT_LDOUBLE, 16, DW_ATE_float, "long double:t16=r1;16;0;" },
+#endif
+    {   -1, -1, -1, "_Float32:t17=r1;4;0;" },
+    {   -1, -1, -1, "_Float64:t18=r1;8;0;" },
+    {   -1, -1, -1, "_Float128:t19=r1;16;0;" },
+    {   -1, -1, -1, "_Float32x:t20=r1;8;0;" },
+    {   -1, -1, -1, "_Float64x:t21=r1;16;0;" },
+    {   -1, -1, -1, "_Decimal32:t22=r1;4;0;" },
+    {   -1, -1, -1, "_Decimal64:t23=r1;8;0;" },
+    {   -1, -1, -1, "_Decimal128:t24=r1;16;0;" },
+    /* if default char is unsigned */
+    {   VT_BYTE | VT_UNSIGNED, 1, DW_ATE_unsigned_char, "unsigned char:t25=r25;0;255;" },
+    /* boolean type */
+    {   VT_BOOL, 1, DW_ATE_boolean, "bool:t26=r26;0;255;" },
+#if LONG_SIZE == 4
+    {   VT_VOID, 1, DW_ATE_unsigned_char, "void:t27=27" },
+#else 
+    /* bitfields use these */
+    {   VT_LONG | VT_INT, 8, DW_ATE_signed, "long int:t27=r27;-9223372036854775808;9223372036854775807;" },
+    {   VT_LONG | VT_INT | VT_UNSIGNED, 8, DW_ATE_unsigned, "long unsigned int:t28=r28;0;01777777777777777777777;" },
+    {   VT_VOID, 1, DW_ATE_unsigned_char, "void:t29=29" },
+#endif
+};
+
+#define	N_DEFAULT_DEBUG	(sizeof (default_debug) / sizeof (default_debug[0]))
+
+/* dwarf debug */
+
+#define	DWARF_LINE_BASE				-5
+#define	DWARF_LINE_RANGE			14
+#define	DWARF_OPCODE_BASE			13
+
+#if defined TCC_TARGET_ARM64
+#define	DWARF_MIN_INSTR_LEN			4
+#elif defined TCC_TARGET_ARM
+#define	DWARF_MIN_INSTR_LEN			2
+#else
+#define	DWARF_MIN_INSTR_LEN			1
+#endif
+
+#define	DWARF_ABBREV_COMPILE_UNIT		1
+#define	DWARF_ABBREV_BASE_TYPE			2
+#define	DWARF_ABBREV_VARIABLE_EXTERNAL		3
+#define	DWARF_ABBREV_VARIABLE_STATIC		4
+#define	DWARF_ABBREV_VARIABLE_LOCAL		5
+#define	DWARF_ABBREV_FORMAL_PARAMETER		6
+#define	DWARF_ABBREV_POINTER			7
+#define	DWARF_ABBREV_ARRAY_TYPE			8
+#define	DWARF_ABBREV_SUBRANGE_TYPE		9
+#define	DWARF_ABBREV_TYPEDEF			10
+#define	DWARF_ABBREV_ENUMERATOR_SIGNED		11
+#define	DWARF_ABBREV_ENUMERATOR_UNSIGNED	12
+#define	DWARF_ABBREV_ENUMERATION_TYPE		13
+#define	DWARF_ABBREV_MEMBER			14
+#define	DWARF_ABBREV_MEMBER_BF			15
+#define	DWARF_ABBREV_STRUCTURE_TYPE		16
+#define	DWARF_ABBREV_STRUCTURE_EMPTY_TYPE	17
+#define	DWARF_ABBREV_UNION_TYPE			18
+#define	DWARF_ABBREV_UNION_EMPTY_TYPE		19
+#define	DWARF_ABBREV_SUBPROGRAM_EXTERNAL	20
+#define	DWARF_ABBREV_SUBPROGRAM_STATIC		21
+#define	DWARF_ABBREV_LEXICAL_BLOCK		22
+#define	DWARF_ABBREV_LEXICAL_EMPTY_BLOCK	23
+#define	DWARF_ABBREV_SUBROUTINE_TYPE		24
+#define	DWARF_ABBREV_SUBROUTINE_EMPTY_TYPE	25
+#define	DWARF_ABBREV_FORMAL_PARAMETER2		26
+
+/* all entries should have been generated with dwarf_uleb128 except
+   has_children. All values are currently below 128 so this currently
+   works.  */
+static const unsigned char dwarf_abbrev_init[] = {
+    DWARF_ABBREV_COMPILE_UNIT, DW_TAG_compile_unit, 1,
+          DW_AT_producer, DW_FORM_strp,
+          DW_AT_language, DW_FORM_data1,
+          DW_AT_name, DW_FORM_line_strp,
+          DW_AT_comp_dir, DW_FORM_line_strp,
+          DW_AT_low_pc, DW_FORM_addr,
+#if PTR_SIZE == 4
+          DW_AT_high_pc, DW_FORM_data4,
+#else
+          DW_AT_high_pc, DW_FORM_data8,
+#endif
+          DW_AT_stmt_list, DW_FORM_sec_offset,
+          0, 0,
+    DWARF_ABBREV_BASE_TYPE, DW_TAG_base_type, 0,
+          DW_AT_byte_size, DW_FORM_udata,
+          DW_AT_encoding, DW_FORM_data1,
+          DW_AT_name, DW_FORM_strp,
+          0, 0,
+    DWARF_ABBREV_VARIABLE_EXTERNAL, DW_TAG_variable, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_external, DW_FORM_flag,
+          DW_AT_location, DW_FORM_exprloc,
+          0, 0,
+    DWARF_ABBREV_VARIABLE_STATIC, DW_TAG_variable, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_location, DW_FORM_exprloc,
+          0, 0,
+    DWARF_ABBREV_VARIABLE_LOCAL, DW_TAG_variable, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_location, DW_FORM_exprloc,
+          0, 0,
+    DWARF_ABBREV_FORMAL_PARAMETER, DW_TAG_formal_parameter, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_location, DW_FORM_exprloc,
+          0, 0,
+    DWARF_ABBREV_POINTER, DW_TAG_pointer_type, 0,
+          DW_AT_byte_size, DW_FORM_data1,
+          DW_AT_type, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_ARRAY_TYPE, DW_TAG_array_type, 1,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_sibling, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_SUBRANGE_TYPE, DW_TAG_subrange_type, 0,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_upper_bound, DW_FORM_udata,
+          0, 0,
+    DWARF_ABBREV_TYPEDEF, DW_TAG_typedef, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_ENUMERATOR_SIGNED, DW_TAG_enumerator, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_const_value, DW_FORM_sdata,
+          0, 0,
+    DWARF_ABBREV_ENUMERATOR_UNSIGNED, DW_TAG_enumerator, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_const_value, DW_FORM_udata,
+          0, 0,
+    DWARF_ABBREV_ENUMERATION_TYPE, DW_TAG_enumeration_type, 1,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_encoding, DW_FORM_data1,
+          DW_AT_byte_size, DW_FORM_data1,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_sibling, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_MEMBER, DW_TAG_member, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_data_member_location, DW_FORM_udata,
+          0, 0,
+    DWARF_ABBREV_MEMBER_BF, DW_TAG_member, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_bit_size, DW_FORM_udata,
+          DW_AT_data_bit_offset, DW_FORM_udata,
+          0, 0,
+    DWARF_ABBREV_STRUCTURE_TYPE, DW_TAG_structure_type, 1,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_byte_size, DW_FORM_udata,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_sibling, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_STRUCTURE_EMPTY_TYPE, DW_TAG_structure_type, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_byte_size, DW_FORM_udata,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          0, 0,
+    DWARF_ABBREV_UNION_TYPE, DW_TAG_union_type, 1,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_byte_size, DW_FORM_udata,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_sibling, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_UNION_EMPTY_TYPE, DW_TAG_union_type, 0,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_byte_size, DW_FORM_udata,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          0, 0,
+    DWARF_ABBREV_SUBPROGRAM_EXTERNAL, DW_TAG_subprogram, 1,
+          DW_AT_external, DW_FORM_flag,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_low_pc, DW_FORM_addr,
+#if PTR_SIZE == 4
+          DW_AT_high_pc, DW_FORM_data4,
+#else
+          DW_AT_high_pc, DW_FORM_data8,
+#endif
+          DW_AT_sibling, DW_FORM_ref4,
+	  DW_AT_frame_base, DW_FORM_exprloc,
+          0, 0,
+    DWARF_ABBREV_SUBPROGRAM_STATIC, DW_TAG_subprogram, 1,
+          DW_AT_name, DW_FORM_strp,
+          DW_AT_decl_file, DW_FORM_udata,
+          DW_AT_decl_line, DW_FORM_udata,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_low_pc, DW_FORM_addr,
+#if PTR_SIZE == 4
+          DW_AT_high_pc, DW_FORM_data4,
+#else
+          DW_AT_high_pc, DW_FORM_data8,
+#endif
+          DW_AT_sibling, DW_FORM_ref4,
+	  DW_AT_frame_base, DW_FORM_exprloc,
+          0, 0,
+    DWARF_ABBREV_LEXICAL_BLOCK, DW_TAG_lexical_block, 1,
+          DW_AT_low_pc, DW_FORM_addr,
+#if PTR_SIZE == 4
+          DW_AT_high_pc, DW_FORM_data4,
+#else
+          DW_AT_high_pc, DW_FORM_data8,
+#endif
+          0, 0,
+    DWARF_ABBREV_LEXICAL_EMPTY_BLOCK, DW_TAG_lexical_block, 0,
+          DW_AT_low_pc, DW_FORM_addr,
+#if PTR_SIZE == 4
+          DW_AT_high_pc, DW_FORM_data4,
+#else
+          DW_AT_high_pc, DW_FORM_data8,
+#endif
+          0, 0,
+    DWARF_ABBREV_SUBROUTINE_TYPE, DW_TAG_subroutine_type, 1,
+          DW_AT_type, DW_FORM_ref4,
+          DW_AT_sibling, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_SUBROUTINE_EMPTY_TYPE, DW_TAG_subroutine_type, 0,
+          DW_AT_type, DW_FORM_ref4,
+          0, 0,
+    DWARF_ABBREV_FORMAL_PARAMETER2, DW_TAG_formal_parameter, 0,
+          DW_AT_type, DW_FORM_ref4,
+          0, 0,
+  0
+};
+
+static const unsigned char dwarf_line_opcodes[] = {
+    0 ,1 ,1 ,1 ,1 ,0 ,0 ,0 ,1 ,0 ,0 ,1
+};
+
+/* ------------------------------------------------------------------------- */
+/* debug state */
+
+struct _tccdbg {
+
+    int last_line_num, new_file;
+    int section_sym;
+
+    int debug_next_type;
+
+    struct _debug_hash {
+        int debug_type;
+        Sym *type;
+    } *debug_hash;
+
+    struct _debug_anon_hash {
+        Sym *type;
+        int n_debug_type;
+        int *debug_type;
+    } *debug_anon_hash;
+
+    int n_debug_hash;
+    int n_debug_anon_hash;
+
+    struct _debug_info {
+        int start;
+        int end;
+        int n_sym;
+        struct debug_sym {
+            int type;
+            unsigned long value;
+            char *str;
+            Section *sec;
+            int sym_index;
+            int info;
+            int file;
+            int line;
+        } *sym;
+        struct _debug_info *child, *next, *last, *parent;
+    } *debug_info, *debug_info_root;
+
+    struct {
+        int info;
+        int abbrev;
+        int line;
+        int str;
+        int line_str;
+    } dwarf_sym;
+
+    struct {
+        int start;
+        int dir_size;
+        char **dir_table;
+        int filename_size;
+        struct dwarf_filename_struct {
+            int dir_entry;
+            char *name;
+        } *filename_table;
+        int line_size;
+        int line_max_size;
+        unsigned char *line_data;
+        int cur_file;
+        int last_file;
+        int last_pc;
+        int last_line;
+    } dwarf_line;
+
+    struct {
+        int start;
+        Sym *func;
+        int line;
+        int base_type_used[N_DEFAULT_DEBUG];
+    } dwarf_info;
+
+    /* test coverage */
+    struct {
+        unsigned long offset;
+        unsigned long last_file_name;
+        unsigned long last_func_name;
+        int ind;
+        int line;
+    } tcov_data;
+
+};
+
+#define last_line_num       s1->dState->last_line_num
+#define new_file            s1->dState->new_file
+#define section_sym         s1->dState->section_sym
+#define debug_next_type     s1->dState->debug_next_type
+#define debug_hash          s1->dState->debug_hash
+#define debug_anon_hash     s1->dState->debug_anon_hash
+#define n_debug_hash        s1->dState->n_debug_hash
+#define n_debug_anon_hash   s1->dState->n_debug_anon_hash
+#define debug_info          s1->dState->debug_info
+#define debug_info_root     s1->dState->debug_info_root
+#define dwarf_sym           s1->dState->dwarf_sym
+#define dwarf_line          s1->dState->dwarf_line
+#define dwarf_info          s1->dState->dwarf_info
+#define tcov_data           s1->dState->tcov_data
+
+/* ------------------------------------------------------------------------- */
+static void put_stabs(TCCState *s1, const char *str, int type, int other,
+    int desc, unsigned long value);
+
+ST_FUNC void tcc_debug_new(TCCState *s1)
+{
+    int shf = 0;
+    if (!s1->dState)
+        s1->dState = tcc_mallocz(sizeof *s1->dState);
+#ifdef CONFIG_TCC_BACKTRACE
+    /* include stab info with standalone backtrace support */
+    if (s1->do_backtrace
+        && (s1->output_type & (TCC_OUTPUT_EXE | TCC_OUTPUT_DLL)))
+        shf = SHF_ALLOC | SHF_WRITE; // SHF_WRITE needed for musl/SELINUX
+#endif
+    if (s1->dwarf) {
+        s1->dwlo = s1->nb_sections;
+        dwarf_info_section =
+	    new_section(s1, ".debug_info", SHT_PROGBITS, shf);
+        dwarf_abbrev_section =
+	    new_section(s1, ".debug_abbrev", SHT_PROGBITS, shf);
+        dwarf_line_section =
+	    new_section(s1, ".debug_line", SHT_PROGBITS, shf);
+        dwarf_aranges_section =
+	    new_section(s1, ".debug_aranges", SHT_PROGBITS, shf);
+	shf |= SHF_MERGE | SHF_STRINGS;
+        dwarf_str_section =
+	    new_section(s1, ".debug_str", SHT_PROGBITS, shf);
+	dwarf_str_section->sh_entsize = 1;
+	dwarf_info_section->sh_addralign =
+	dwarf_abbrev_section->sh_addralign =
+	dwarf_line_section->sh_addralign =
+	dwarf_aranges_section->sh_addralign =
+	dwarf_str_section->sh_addralign = 1;
+	if (s1->dwarf >= 5) {
+            dwarf_line_str_section =
+	        new_section(s1, ".debug_line_str", SHT_PROGBITS, shf);
+	    dwarf_line_str_section->sh_entsize = 1;
+	    dwarf_line_str_section->sh_addralign = 1;
+	}
+        s1->dwhi = s1->nb_sections;
+    }
+    else
+    {
+        stab_section = new_section(s1, ".stab", SHT_PROGBITS, shf);
+        stab_section->sh_entsize = sizeof(Stab_Sym);
+        stab_section->sh_addralign = sizeof ((Stab_Sym*)0)->n_value;
+        stab_section->link = new_section(s1, ".stabstr", SHT_STRTAB, shf);
+        /* put first entry */
+        put_stabs(s1, "", 0, 0, 0, 0);
+    }
+}
+
+/* put stab debug information */
+static void put_stabs(TCCState *s1, const char *str, int type, int other, int desc,
+                      unsigned long value)
+{
+    Stab_Sym *sym;
+
+    unsigned offset;
+    if (type == N_SLINE
+        && (offset = stab_section->data_offset)
+        && (sym = (Stab_Sym*)(stab_section->data + offset) - 1)
+        && sym->n_type == type
+        && sym->n_value == value) {
+        /* just update line_number in previous entry */
+        sym->n_desc = desc;
+        return;
+    }
+
+    sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
+    if (str) {
+        sym->n_strx = put_elf_str(stab_section->link, str);
+    } else {
+        sym->n_strx = 0;
+    }
+    sym->n_type = type;
+    sym->n_other = other;
+    sym->n_desc = desc;
+    sym->n_value = value;
+}
+
+static void put_stabs_r(TCCState *s1, const char *str, int type, int other, int desc,
+                        unsigned long value, Section *sec, int sym_index)
+{
+    put_elf_reloc(symtab_section, stab_section,
+                  stab_section->data_offset + 8,
+                  sizeof ((Stab_Sym*)0)->n_value == PTR_SIZE ? R_DATA_PTR : R_DATA_32,
+                  sym_index);
+    put_stabs(s1, str, type, other, desc, value);
+}
+
+static void put_stabn(TCCState *s1, int type, int other, int desc, int value)
+{
+    put_stabs(s1, NULL, type, other, desc, value);
+}
+
+/* ------------------------------------------------------------------------- */
+#define	dwarf_data1(s,data) \
+	{ unsigned char *p = section_ptr_add((s), 1); *p = (data); }
+#define	dwarf_data2(s,data) \
+	write16le(section_ptr_add((s), 2), (data))
+#define	dwarf_data4(s,data) \
+	write32le(section_ptr_add((s), 4), (data))
+#define	dwarf_data8(s,data) \
+	write64le(section_ptr_add((s), 8), (data))
+
+static int dwarf_get_section_sym(Section *s)
+{
+    TCCState *s1 = s->s1;
+    return put_elf_sym(symtab_section, 0, 0,
+                       ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
+                       s->sh_num, NULL);
+}
+
+static void dwarf_reloc(Section *s, int sym, int rel)
+{
+    TCCState *s1 = s->s1;
+    put_elf_reloca(symtab_section, s, s->data_offset, rel, sym, 0);
+}
+
+static void dwarf_string(Section *s, Section *dw, int sym, const char *str)
+{
+    TCCState *s1 = s->s1;
+    int offset, len;
+    char *ptr;
+
+    len = strlen(str) + 1;
+    offset = dw->data_offset;
+    ptr = section_ptr_add(dw, len);
+    memmove(ptr, str, len);
+    put_elf_reloca(symtab_section, s, s->data_offset, R_DATA_32DW, sym,
+                   PTR_SIZE == 4 ? 0 : offset);
+    dwarf_data4(s, PTR_SIZE == 4 ? offset : 0);
+}
+
+static void dwarf_strp(Section *s, const char *str)
+{
+    TCCState *s1 = s->s1;
+    dwarf_string(s, dwarf_str_section, dwarf_sym.str, str);
+}
+
+static void dwarf_line_strp(Section *s, const char *str)
+{
+    TCCState *s1 = s->s1;
+    dwarf_string(s, dwarf_line_str_section, dwarf_sym.line_str, str);
+}
+
+static void dwarf_line_op(TCCState *s1, unsigned char op)
+{
+    if (dwarf_line.line_size >= dwarf_line.line_max_size) {
+	dwarf_line.line_max_size += 1024;
+	dwarf_line.line_data =
+	    (unsigned char *)tcc_realloc(dwarf_line.line_data,
+					 dwarf_line.line_max_size);
+    }
+    dwarf_line.line_data[dwarf_line.line_size++] = op;
+}
+
+static void dwarf_file(TCCState *s1)
+{
+    int i, j;
+    char *filename;
+    int index_offset = s1->dwarf < 5;
+
+    if (!strcmp(file->filename, "<command line>")) {
+        dwarf_line.cur_file = 1;
+	return;
+    }
+    filename = strrchr(file->filename, '/');
+    if (filename == NULL) {
+        for (i = 1; i < dwarf_line.filename_size; i++)
+            if (dwarf_line.filename_table[i].dir_entry == 0 &&
+		strcmp(dwarf_line.filename_table[i].name,
+		       file->filename) == 0) {
+		    dwarf_line.cur_file = i + index_offset;
+	            return;
+		}
+	i = -index_offset;
+	filename = file->filename;
+    }
+    else {
+	char *undo = filename;
+	char *dir = file->filename;
+
+	*filename++ = '\0';
+        for (i = 0; i < dwarf_line.dir_size; i++)
+	    if (strcmp(dwarf_line.dir_table[i], dir) == 0) {
+		for (j = 1; j < dwarf_line.filename_size; j++)
+		    if (dwarf_line.filename_table[j].dir_entry - index_offset
+			== i &&
+			strcmp(dwarf_line.filename_table[j].name,
+			       filename) == 0) {
+			*undo = '/';
+		        dwarf_line.cur_file = j + index_offset;
+			return;
+		    }
+		break;
+	    }
+	if (i == dwarf_line.dir_size) {
+	    dwarf_line.dir_size++;
+	    dwarf_line.dir_table = 
+                (char **) tcc_realloc(dwarf_line.dir_table,
+                                      dwarf_line.dir_size *
+                                      sizeof (char *));
+            dwarf_line.dir_table[i] = tcc_strdup(dir);
+	}
+	*undo = '/';
+    }
+    dwarf_line.filename_table =
+        (struct dwarf_filename_struct *)
+        tcc_realloc(dwarf_line.filename_table,
+                    (dwarf_line.filename_size + 1) *
+                    sizeof (struct dwarf_filename_struct));
+    dwarf_line.filename_table[dwarf_line.filename_size].dir_entry =
+	i + index_offset;
+    dwarf_line.filename_table[dwarf_line.filename_size].name =
+        tcc_strdup(filename);
+    dwarf_line.cur_file = dwarf_line.filename_size++ + index_offset;
+    return;
+}
+
+#if 0
+static int dwarf_uleb128_size (unsigned long long value)
+{
+    int size =  0;
+
+    do {
+        value >>= 7;
+        size++;
+    } while (value != 0);
+    return size;
+}
+#endif
+
+static int dwarf_sleb128_size (long long value)
+{
+    int size =  0;
+    long long end = value >> 63;
+    unsigned char last = end & 0x40;
+    unsigned char byte;
+
+    do {
+        byte = value & 0x7f;
+        value >>= 7;
+        size++;
+    } while (value != end || (byte & 0x40) != last);
+    return size;
+}
+
+static void dwarf_uleb128 (Section *s, unsigned long long value)
+{
+    do {
+        unsigned char byte = value & 0x7f;
+
+        value >>= 7;
+        dwarf_data1(s, byte | (value ? 0x80 : 0));
+    } while (value != 0);
+}
+
+static void dwarf_sleb128 (Section *s, long long value)
+{
+    int more;
+    long long end = value >> 63;
+    unsigned char last = end & 0x40;
+
+    do {
+        unsigned char byte = value & 0x7f;
+
+        value >>= 7;
+	more = value != end || (byte & 0x40) != last;
+        dwarf_data1(s, byte | (0x80 * more));
+    } while (more);
+}
+
+static void dwarf_uleb128_op (TCCState *s1, unsigned long long value)
+{
+    do {
+        unsigned char byte = value & 0x7f;
+
+        value >>= 7;
+        dwarf_line_op(s1, byte | (value ? 0x80 : 0));
+    } while (value != 0);
+}
+
+static void dwarf_sleb128_op (TCCState *s1, long long value)
+{
+    int more;
+    long long end = value >> 63;
+    unsigned char last = end & 0x40;
+
+    do {
+        unsigned char byte = value & 0x7f;
+
+        value >>= 7;
+        more = value != end || (byte & 0x40) != last;
+        dwarf_line_op(s1, byte | (0x80 * more));
+    } while (more);
+}
+
+/* start of translation unit info */
+ST_FUNC void tcc_debug_start(TCCState *s1)
+{
+    int i;
+    char buf[512];
+    char *filename;
+
+    /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
+       symbols can be safely used */
+    filename = file->prev ? file->prev->filename : file->filename;
+    put_elf_sym(symtab_section, 0, 0,
+                ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
+                SHN_ABS, filename);
+
+    if (s1->do_debug) {
+
+        new_file = last_line_num = 0;
+        debug_next_type = N_DEFAULT_DEBUG;
+        debug_hash = NULL;
+        debug_anon_hash = NULL;
+        n_debug_hash = 0;
+        n_debug_anon_hash = 0;
+
+        getcwd(buf, sizeof(buf));
+#ifdef _WIN32
+        normalize_slashes(buf);
+#endif
+
+        if (s1->dwarf) {
+            int start_abbrev;
+            unsigned char *ptr;
+	    char *undo;
+
+            /* dwarf_abbrev */
+            start_abbrev = dwarf_abbrev_section->data_offset;
+            ptr = section_ptr_add(dwarf_abbrev_section, sizeof(dwarf_abbrev_init));
+            memcpy(ptr, dwarf_abbrev_init, sizeof(dwarf_abbrev_init));
+
+            if (s1->dwarf < 5) {
+    	        while (*ptr) {
+    	            ptr += 3;
+    	            while (*ptr) {
+    	                if (ptr[1] == DW_FORM_line_strp)
+    		            ptr[1] = DW_FORM_strp;
+		        if (s1->dwarf < 4) {
+			    /* These are compatable for DW_TAG_compile_unit
+			       DW_AT_stmt_list. */
+			    if  (ptr[1] == DW_FORM_sec_offset)
+			         ptr[1] = DW_FORM_data4;
+			    /* This code uses only size < 0x80 so these are
+			       compatible. */
+			    if  (ptr[1] == DW_FORM_exprloc)
+			         ptr[1] = DW_FORM_block1;
+			}
+    	                ptr += 2;
+    	            }
+		    ptr += 2;
+    	        }
+            }
+
+            dwarf_sym.info = dwarf_get_section_sym(dwarf_info_section);
+            dwarf_sym.abbrev = dwarf_get_section_sym(dwarf_abbrev_section);
+            dwarf_sym.line = dwarf_get_section_sym(dwarf_line_section);
+            dwarf_sym.str = dwarf_get_section_sym(dwarf_str_section);
+            if (tcc_state->dwarf >= 5)
+    	        dwarf_sym.line_str = dwarf_get_section_sym(dwarf_line_str_section);
+            else {
+    	        dwarf_line_str_section = dwarf_str_section;
+                dwarf_sym.line_str = dwarf_sym.str;
+            }
+            section_sym = dwarf_get_section_sym(text_section);
+
+            /* dwarf_info */
+            dwarf_info.start = dwarf_info_section->data_offset;
+            dwarf_data4(dwarf_info_section, 0); // size
+            dwarf_data2(dwarf_info_section, s1->dwarf); // version
+            if (s1->dwarf >= 5) {
+                dwarf_data1(dwarf_info_section, DW_UT_compile); // unit type
+                dwarf_data1(dwarf_info_section, PTR_SIZE);
+                dwarf_reloc(dwarf_info_section, dwarf_sym.abbrev, R_DATA_32DW);
+                dwarf_data4(dwarf_info_section, start_abbrev);
+            }
+            else {
+                dwarf_reloc(dwarf_info_section, dwarf_sym.abbrev, R_DATA_32DW);
+                dwarf_data4(dwarf_info_section, start_abbrev);
+                dwarf_data1(dwarf_info_section, PTR_SIZE);
+            }
+
+            dwarf_data1(dwarf_info_section, DWARF_ABBREV_COMPILE_UNIT);
+            dwarf_strp(dwarf_info_section, "tcc " TCC_VERSION);
+            dwarf_data1(dwarf_info_section, DW_LANG_C11);
+            dwarf_line_strp(dwarf_info_section, filename);
+            dwarf_line_strp(dwarf_info_section, buf);
+            dwarf_reloc(dwarf_info_section, section_sym, R_DATA_PTR);
+#if PTR_SIZE == 4
+            dwarf_data4(dwarf_info_section, ind); // low pc
+            dwarf_data4(dwarf_info_section, 0); // high pc
+#else
+            dwarf_data8(dwarf_info_section, ind); // low pc
+            dwarf_data8(dwarf_info_section, 0); // high pc
+#endif
+            dwarf_reloc(dwarf_info_section, dwarf_sym.line, R_DATA_32DW);
+            dwarf_data4(dwarf_info_section, dwarf_line_section->data_offset); // stmt_list
+
+            /* dwarf_line */
+            dwarf_line.start = dwarf_line_section->data_offset;
+            dwarf_data4(dwarf_line_section, 0); // length
+            dwarf_data2(dwarf_line_section, s1->dwarf); // version
+            if (s1->dwarf >= 5) {
+                dwarf_data1(dwarf_line_section, PTR_SIZE); // address size
+                dwarf_data1(dwarf_line_section, 0); // segment selector
+            }
+            dwarf_data4(dwarf_line_section, 0); // prologue Length
+            dwarf_data1(dwarf_line_section, DWARF_MIN_INSTR_LEN);
+            if (s1->dwarf >= 4)
+                dwarf_data1(dwarf_line_section, 1); // maximum ops per instruction
+            dwarf_data1(dwarf_line_section, 1); // Initial value of 'is_stmt'
+            dwarf_data1(dwarf_line_section, DWARF_LINE_BASE);
+            dwarf_data1(dwarf_line_section, DWARF_LINE_RANGE);
+            dwarf_data1(dwarf_line_section, DWARF_OPCODE_BASE);
+            ptr = section_ptr_add(dwarf_line_section, sizeof(dwarf_line_opcodes));
+            memcpy(ptr, dwarf_line_opcodes, sizeof(dwarf_line_opcodes));
+	    undo = strrchr(filename, '/');
+	    if (undo)
+		*undo = 0;
+            dwarf_line.dir_size = 1 + (undo != NULL);
+            dwarf_line.dir_table = (char **) tcc_malloc(sizeof (char *) *
+							dwarf_line.dir_size);
+            dwarf_line.dir_table[0] = tcc_strdup(buf);
+	    if (undo)
+                dwarf_line.dir_table[1] = tcc_strdup(filename);
+            dwarf_line.filename_size = 2;
+            dwarf_line.filename_table =
+    	        (struct dwarf_filename_struct *)
+    	        tcc_malloc(2*sizeof (struct dwarf_filename_struct));
+            dwarf_line.filename_table[0].dir_entry = 0;
+	    if (undo) {
+                dwarf_line.filename_table[0].name = tcc_strdup(undo + 1);
+                dwarf_line.filename_table[1].dir_entry = 1;
+                dwarf_line.filename_table[1].name = tcc_strdup(undo + 1);
+		*undo = '/';
+	    }
+	    else {
+                dwarf_line.filename_table[0].name = tcc_strdup(filename);
+                dwarf_line.filename_table[1].dir_entry = 0;
+                dwarf_line.filename_table[1].name = tcc_strdup(filename);
+	    }
+            dwarf_line.line_size = dwarf_line.line_max_size = 0;
+            dwarf_line.line_data = NULL;
+            dwarf_line.cur_file = 1;
+            dwarf_line.last_file = 0;
+            dwarf_line.last_pc = 0;
+            dwarf_line.last_line = 1;
+            dwarf_line_op(s1, 0); // extended
+            dwarf_uleb128_op(s1, 1 + PTR_SIZE); // extended size
+            dwarf_line_op(s1, DW_LNE_set_address);
+            for (i = 0; i < PTR_SIZE; i++)
+    	        dwarf_line_op(s1, 0);
+            memset(&dwarf_info.base_type_used, 0, sizeof(dwarf_info.base_type_used));
+        }
+        else
+        {
+            /* file info: full path + filename */
+            pstrcat(buf, sizeof(buf), "/");
+            section_sym = put_elf_sym(symtab_section, 0, 0,
+                                      ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
+                                      text_section->sh_num, NULL);
+            put_stabs_r(s1, buf, N_SO, 0, 0,
+                        text_section->data_offset, text_section, section_sym);
+            put_stabs_r(s1, filename, N_SO, 0, 0,
+                        text_section->data_offset, text_section, section_sym);
+            for (i = 0; i < N_DEFAULT_DEBUG; i++)
+                put_stabs(s1, default_debug[i].name, N_LSYM, 0, 0, 0);
+        }
+        /* we're currently 'including' the <command line> */
+        tcc_debug_bincl(s1);
+    }
+}
+
+/* put end of translation unit info */
+ST_FUNC void tcc_debug_end(TCCState *s1)
+{
+    if (!s1->do_debug || debug_next_type == 0)
+        return;
+
+    if (debug_info_root)
+        tcc_debug_funcend(s1, 0); /* free stuff in case of errors */
+
+    if (s1->dwarf) {
+	int i, j;
+	int start_aranges;
+	unsigned char *ptr;
+	int text_size = text_section->data_offset;
+
+	/* dwarf_info */
+	for (i = 0; i < n_debug_anon_hash; i++) {
+	    Sym *t = debug_anon_hash[i].type;
+	    int pos = dwarf_info_section->data_offset;
+
+	    dwarf_data1(dwarf_info_section,
+                        IS_UNION (t->type.t) ? DWARF_ABBREV_UNION_EMPTY_TYPE
+                                             : DWARF_ABBREV_STRUCTURE_EMPTY_TYPE);
+            dwarf_strp(dwarf_info_section,
+                       (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
+                       ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL));
+            dwarf_uleb128(dwarf_info_section, 0);
+            dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+            dwarf_uleb128(dwarf_info_section, file->line_num);
+	    for (j = 0; j < debug_anon_hash[i].n_debug_type; j++)
+		write32le(dwarf_info_section->data +
+			  debug_anon_hash[i].debug_type[j],
+			  pos - dwarf_info.start);
+	    tcc_free (debug_anon_hash[i].debug_type);
+	}
+	tcc_free (debug_anon_hash);
+	dwarf_data1(dwarf_info_section, 0);
+	ptr = dwarf_info_section->data + dwarf_info.start;
+	write32le(ptr, dwarf_info_section->data_offset - dwarf_info.start - 4);
+	write32le(ptr + 25 + (s1->dwarf >= 5) + PTR_SIZE, text_size);
+
+	/* dwarf_aranges */
+	start_aranges = dwarf_aranges_section->data_offset;
+	dwarf_data4(dwarf_aranges_section, 0); // size
+	dwarf_data2(dwarf_aranges_section, 2); // version
+	dwarf_reloc(dwarf_aranges_section, dwarf_sym.info, R_DATA_32DW);
+	dwarf_data4(dwarf_aranges_section, 0); // dwarf_info
+#if PTR_SIZE == 4
+	dwarf_data1(dwarf_aranges_section, 4); // address size
+#else
+	dwarf_data1(dwarf_aranges_section, 8); // address size
+#endif
+	dwarf_data1(dwarf_aranges_section, 0); // segment selector size
+	dwarf_data4(dwarf_aranges_section, 0); // padding
+	dwarf_reloc(dwarf_aranges_section, section_sym, R_DATA_PTR);
+#if PTR_SIZE == 4
+	dwarf_data4(dwarf_aranges_section, 0); // Begin
+	dwarf_data4(dwarf_aranges_section, text_size); // End
+	dwarf_data4(dwarf_aranges_section, 0); // End list
+	dwarf_data4(dwarf_aranges_section, 0); // End list
+#else
+	dwarf_data8(dwarf_aranges_section, 0); // Begin
+	dwarf_data8(dwarf_aranges_section, text_size); // End
+	dwarf_data8(dwarf_aranges_section, 0); // End list
+	dwarf_data8(dwarf_aranges_section, 0); // End list
+#endif
+	ptr = dwarf_aranges_section->data + start_aranges;
+	write32le(ptr, dwarf_aranges_section->data_offset - start_aranges - 4);
+
+	/* dwarf_line */
+	if (s1->dwarf >= 5) {
+	    dwarf_data1(dwarf_line_section, 1); /* col */
+	    dwarf_uleb128(dwarf_line_section, DW_LNCT_path);
+	    dwarf_uleb128(dwarf_line_section, DW_FORM_line_strp);
+	    dwarf_uleb128(dwarf_line_section, dwarf_line.dir_size);
+	    for (i = 0; i < dwarf_line.dir_size; i++)
+	        dwarf_line_strp(dwarf_line_section, dwarf_line.dir_table[i]);
+	    dwarf_data1(dwarf_line_section, 2); /* col */
+	    dwarf_uleb128(dwarf_line_section, DW_LNCT_path);
+	    dwarf_uleb128(dwarf_line_section, DW_FORM_line_strp);
+	    dwarf_uleb128(dwarf_line_section, DW_LNCT_directory_index);
+	    dwarf_uleb128(dwarf_line_section, DW_FORM_udata);
+	    dwarf_uleb128(dwarf_line_section, dwarf_line.filename_size);
+	    for (i = 0; i < dwarf_line.filename_size; i++) {
+	        dwarf_line_strp(dwarf_line_section,
+				dwarf_line.filename_table[i].name);
+	        dwarf_uleb128(dwarf_line_section,
+			      dwarf_line.filename_table[i].dir_entry);
+	    }
+	}
+	else {
+	    int len;
+
+	    for (i = 0; i < dwarf_line.dir_size; i++) {
+	        len = strlen(dwarf_line.dir_table[i]) + 1;
+	        ptr = section_ptr_add(dwarf_line_section, len);
+	        memmove(ptr, dwarf_line.dir_table[i], len);
+	    }
+	    dwarf_data1(dwarf_line_section, 0); /* end dir */
+	    for (i = 0; i < dwarf_line.filename_size; i++) {
+	        len = strlen(dwarf_line.filename_table[i].name) + 1;
+	        ptr = section_ptr_add(dwarf_line_section, len);
+	        memmove(ptr, dwarf_line.filename_table[i].name, len);
+	        dwarf_uleb128(dwarf_line_section,
+			      dwarf_line.filename_table[i].dir_entry);
+	        dwarf_uleb128(dwarf_line_section, 0); /* time */
+	        dwarf_uleb128(dwarf_line_section, 0); /* size */
+	    }
+	    dwarf_data1(dwarf_line_section, 0); /* end file */
+	}
+	for (i = 0; i < dwarf_line.dir_size; i++)
+	    tcc_free(dwarf_line.dir_table[i]);
+	tcc_free(dwarf_line.dir_table);
+	for (i = 0; i < dwarf_line.filename_size; i++)
+	    tcc_free(dwarf_line.filename_table[i].name);
+	tcc_free(dwarf_line.filename_table);
+
+	dwarf_line_op(s1, 0); // extended
+	dwarf_uleb128_op(s1, 1); // extended size
+	dwarf_line_op(s1, DW_LNE_end_sequence);
+	i = (s1->dwarf >= 5) * 2;
+	write32le(&dwarf_line_section->data[dwarf_line.start + 6 + i],
+		  dwarf_line_section->data_offset - dwarf_line.start - (10 + i));
+	section_ptr_add(dwarf_line_section, 3);
+	dwarf_reloc(dwarf_line_section, section_sym, R_DATA_PTR);
+	ptr = section_ptr_add(dwarf_line_section, dwarf_line.line_size - 3);
+	memmove(ptr - 3, dwarf_line.line_data, dwarf_line.line_size);
+	tcc_free(dwarf_line.line_data);
+	write32le(dwarf_line_section->data + dwarf_line.start,
+		  dwarf_line_section->data_offset - dwarf_line.start - 4);
+    }
+    else
+    {
+        put_stabs_r(s1, NULL, N_SO, 0, 0,
+                    text_section->data_offset, text_section, section_sym);
+    }
+    tcc_free(debug_hash);
+    debug_next_type = 0;
+}
+
+static BufferedFile* put_new_file(TCCState *s1)
+{
+    BufferedFile *f = file;
+    /* use upper file if from inline ":asm:" */
+    if (f->filename[0] == ':')
+        f = f->prev;
+    if (f && new_file) {
+        new_file = last_line_num = 0;
+        if (s1->dwarf)
+            dwarf_file(s1);
+        else
+            put_stabs_r(s1, f->filename, N_SOL, 0, 0, ind, text_section, section_sym);
+    }
+    return f;
+}
+
+/* put alternative filename */
+ST_FUNC void tcc_debug_putfile(TCCState *s1, const char *filename)
+{
+    if (0 == strcmp(file->filename, filename))
+        return;
+    pstrcpy(file->filename, sizeof(file->filename), filename);
+    if (!s1->do_debug)
+        return;
+    if (s1->dwarf)
+        dwarf_file(s1);
+    new_file = 1;
+}
+
+/* begin of #include */
+ST_FUNC void tcc_debug_bincl(TCCState *s1)
+{
+    if (!s1->do_debug)
+        return;
+    if (s1->dwarf)
+        dwarf_file(s1);
+    else
+        put_stabs(s1, file->filename, N_BINCL, 0, 0, 0);
+    new_file = 1;
+}
+
+/* end of #include */
+ST_FUNC void tcc_debug_eincl(TCCState *s1)
+{
+    if (!s1->do_debug)
+        return;
+    if (s1->dwarf)
+        dwarf_file(s1);
+    else
+        put_stabn(s1, N_EINCL, 0, 0, 0);
+    new_file = 1;
+}
+
+/* generate line number info */
+ST_FUNC void tcc_debug_line(TCCState *s1)
+{
+    BufferedFile *f;
+
+    if (!s1->do_debug)
+        return;
+    if (cur_text_section != text_section || nocode_wanted)
+        return;
+    f = put_new_file(s1);
+    if (!f)
+        return;
+    if (last_line_num == f->line_num)
+        return;
+    last_line_num = f->line_num;
+
+    if (s1->dwarf) {
+	int len_pc = (ind - dwarf_line.last_pc) / DWARF_MIN_INSTR_LEN;
+	int len_line = f->line_num - dwarf_line.last_line;
+	int n = len_pc * DWARF_LINE_RANGE + len_line + DWARF_OPCODE_BASE - DWARF_LINE_BASE;
+
+	if (dwarf_line.cur_file != dwarf_line.last_file) {
+	    dwarf_line.last_file = dwarf_line.cur_file;
+	    dwarf_line_op(s1, DW_LNS_set_file);
+	    dwarf_uleb128_op(s1, dwarf_line.cur_file);
+	}
+	if (len_pc &&
+	    len_line >= DWARF_LINE_BASE && len_line <= (DWARF_OPCODE_BASE + DWARF_LINE_BASE) &&
+	    n >= DWARF_OPCODE_BASE && n <= 255)
+            dwarf_line_op(s1, n);
+	else {
+	    if (len_pc) {
+	        n = len_pc * DWARF_LINE_RANGE + 0 + DWARF_OPCODE_BASE - DWARF_LINE_BASE;
+	        if (n >= DWARF_OPCODE_BASE && n <= 255)
+                    dwarf_line_op(s1, n);
+		else {
+	            dwarf_line_op(s1, DW_LNS_advance_pc);
+		    dwarf_uleb128_op(s1, len_pc);
+		}
+	    }
+	    if (len_line) {
+	        n = 0 * DWARF_LINE_RANGE + len_line + DWARF_OPCODE_BASE - DWARF_LINE_BASE;
+	        if (len_line >= DWARF_LINE_BASE && len_line <= (DWARF_OPCODE_BASE + DWARF_LINE_BASE) &&
+		    n >= DWARF_OPCODE_BASE && n <= 255)
+	            dwarf_line_op(s1, n);
+		else {
+	            dwarf_line_op(s1, DW_LNS_advance_line);
+		    dwarf_sleb128_op(s1, len_line);
+		}
+	    }
+	}
+	dwarf_line.last_pc = ind;
+	dwarf_line.last_line = f->line_num;
+    }
+    else
+    {
+	if (func_ind != -1) {
+            put_stabn(s1, N_SLINE, 0, f->line_num, ind - func_ind);
+        } else {
+            /* from tcc_assemble */
+            put_stabs_r(s1, NULL, N_SLINE, 0, f->line_num, ind, text_section, section_sym);
+        }
+    }
+}
+
+static void tcc_debug_stabs (TCCState *s1, const char *str, int type, unsigned long value,
+                             Section *sec, int sym_index, int info)
+{
+    struct debug_sym *s;
+
+    if (debug_info) {
+        debug_info->sym =
+            (struct debug_sym *)tcc_realloc (debug_info->sym,
+                                             sizeof(struct debug_sym) *
+                                             (debug_info->n_sym + 1));
+        s = debug_info->sym + debug_info->n_sym++;
+        s->type = type;
+        s->value = value;
+        s->str = tcc_strdup(str);
+        s->sec = sec;
+        s->sym_index = sym_index;
+        s->info = info;
+        s->file = dwarf_line.cur_file;
+        s->line = file->line_num;
+    }
+    else if (sec)
+        put_stabs_r (s1, str, type, 0, 0, value, sec, sym_index);
+    else
+        put_stabs (s1, str, type, 0, 0, value);
+}
+
+ST_FUNC void tcc_debug_stabn(TCCState *s1, int type, int value)
+{
+    if (!s1->do_debug)
+        return;
+    if (type == N_LBRAC) {
+        struct _debug_info *info =
+            (struct _debug_info *) tcc_mallocz(sizeof (*info));
+
+        info->start = value;
+        info->parent = debug_info;
+        if (debug_info) {
+            if (debug_info->child) {
+                if (debug_info->child->last)
+                    debug_info->child->last->next = info;
+                else
+                    debug_info->child->next = info;
+                debug_info->child->last = info;
+            }
+            else
+                debug_info->child = info;
+        }
+        else
+            debug_info_root = info;
+        debug_info = info;
+    }
+    else {
+        debug_info->end = value;
+        debug_info = debug_info->parent;
+    }
+}
+
+static int tcc_debug_find(TCCState *s1, Sym *t, int dwarf)
+{
+    int i;
+
+    if (!debug_info && dwarf &&
+	(t->type.t & VT_BTYPE) == VT_STRUCT && t->c == -1) {
+	for (i = 0; i < n_debug_anon_hash; i++)
+            if (t == debug_anon_hash[i].type)
+		return 0;
+	debug_anon_hash = (struct _debug_anon_hash *)
+            tcc_realloc (debug_anon_hash,
+                         (n_debug_anon_hash + 1) * sizeof(*debug_anon_hash));
+        debug_anon_hash[n_debug_anon_hash].n_debug_type = 0;
+        debug_anon_hash[n_debug_anon_hash].debug_type = NULL;
+        debug_anon_hash[n_debug_anon_hash++].type = t;
+	return 0;
+    }
+    for (i = 0; i < n_debug_hash; i++)
+        if (t == debug_hash[i].type)
+	    return debug_hash[i].debug_type;
+    return -1;
+}
+
+static int tcc_get_dwarf_info(TCCState *s1, Sym *s);
+
+static void tcc_debug_check_anon(TCCState *s1, Sym *t, int debug_type)
+{
+    int i;
+
+    if (!debug_info && (t->type.t & VT_BTYPE) == VT_STRUCT && t->type.ref->c == -1)
+	for (i = 0; i < n_debug_anon_hash; i++)
+            if (t->type.ref == debug_anon_hash[i].type) {
+		debug_anon_hash[i].debug_type =
+		    tcc_realloc(debug_anon_hash[i].debug_type,
+				(debug_anon_hash[i].n_debug_type + 1) * sizeof(int));
+		debug_anon_hash[i].debug_type[debug_anon_hash[i].n_debug_type++] =
+		    debug_type;
+            }
+}
+
+ST_FUNC void tcc_debug_fix_anon(TCCState *s1, CType *t)
+{
+    int i, j, debug_type;
+
+    if (!(s1->do_debug & 2) || !s1->dwarf || debug_info)
+	return;
+
+    if ((t->t & VT_BTYPE) == VT_STRUCT && t->ref->c != -1)
+	for (i = 0; i < n_debug_anon_hash; i++)
+	    if (t->ref == debug_anon_hash[i].type) {
+		Sym sym = {0}; sym .type = *t ;
+
+		/* Trick to not hash this struct */
+		debug_info = (struct _debug_info *) t;
+		debug_type = tcc_get_dwarf_info(s1, &sym);
+		debug_info = NULL;
+		for (j = 0; j < debug_anon_hash[i].n_debug_type; j++)
+		    write32le(dwarf_info_section->data +
+			      debug_anon_hash[i].debug_type[j],
+			      debug_type - dwarf_info.start);
+		tcc_free(debug_anon_hash[i].debug_type);
+		n_debug_anon_hash--;
+		for (; i < n_debug_anon_hash; i++)
+		    debug_anon_hash[i] = debug_anon_hash[i + 1];
+	    }
+}
+
+static int tcc_debug_add(TCCState *s1, Sym *t, int dwarf)
+{
+    int offset = dwarf ? dwarf_info_section->data_offset : ++debug_next_type;
+    debug_hash = (struct _debug_hash *)
+	tcc_realloc (debug_hash,
+		     (n_debug_hash + 1) * sizeof(*debug_hash));
+    debug_hash[n_debug_hash].debug_type = offset;
+    debug_hash[n_debug_hash++].type = t;
+    return offset;
+}
+
+static void tcc_debug_remove(TCCState *s1, Sym *t)
+{
+    int i;
+
+    for (i = 0; i < n_debug_hash; i++)
+        if (t == debug_hash[i].type) {
+	    n_debug_hash--;
+	    for (; i < n_debug_hash; i++)
+		debug_hash[i] = debug_hash[i+1];
+	}
+}
+
+#define	STRUCT_NODEBUG(s) 			       \
+    (s->a.nodebug ||                           \
+     ((s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM && \
+      ((s->type.t & VT_BTYPE) == VT_BYTE ||    \
+       (s->type.t & VT_BTYPE) == VT_BOOL ||    \
+       (s->type.t & VT_BTYPE) == VT_SHORT ||   \
+       (s->type.t & VT_BTYPE) == VT_INT ||     \
+       (s->type.t & VT_BTYPE) == VT_LLONG)))
+
+static void tcc_get_debug_info(TCCState *s1, Sym *s, CString *result)
+{
+    int type;
+    int n = 0;
+    int debug_type = -1;
+    Sym *t = s;
+    CString str;
+
+    for (;;) {
+        type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE | VT_VLA);
+        if ((type & VT_BTYPE) != VT_BYTE)
+            type &= ~VT_DEFSIGN;
+        if (type == VT_PTR || type == (VT_PTR | VT_ARRAY))
+            n++, t = t->type.ref;
+        else
+            break;
+    }
+    if ((type & VT_BTYPE) == VT_STRUCT) {
+	Sym *e = t;
+
+        t = t->type.ref;
+	debug_type = tcc_debug_find(s1, t, 0);
+        if (debug_type == -1) {
+            debug_type = tcc_debug_add(s1, t, 0);
+            cstr_new (&str);
+            cstr_printf (&str, "%s:T%d=%c%d",
+                         (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
+                         ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL),
+                         debug_type,
+                         IS_UNION (t->type.t) ? 'u' : 's',
+                         t->c);
+            while (t->next) {
+                int pos, size, align;
+
+                t = t->next;
+		if (STRUCT_NODEBUG(t))
+		    continue;
+                cstr_printf (&str, "%s:",
+                             get_tok_str(t->v & ~SYM_FIELD, NULL));
+                tcc_get_debug_info (s1, t, &str);
+                if (t->type.t & VT_BITFIELD) {
+                    pos = t->c * 8 + BIT_POS(t->type.t);
+                    size = BIT_SIZE(t->type.t);
+                }
+                else {
+                    pos = t->c * 8;
+                    size = type_size(&t->type, &align) * 8;
+                }
+                cstr_printf (&str, ",%d,%d;", pos, size);
+            }
+            cstr_printf (&str, ";");
+            tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0, 0);
+            cstr_free (&str);
+            if (debug_info)
+                tcc_debug_remove(s1, e);
+        }
+    }
+    else if (IS_ENUM(type)) {
+        Sym *e = t = t->type.ref;
+
+	debug_type = tcc_debug_find(s1, t, 0);
+	if (debug_type == -1) {
+	    debug_type = tcc_debug_add(s1, t, 0);
+            cstr_new (&str);
+            cstr_printf (&str, "%s:T%d=e",
+                         (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
+                         ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL),
+                         debug_type);
+            while (t->next) {
+                t = t->next;
+                cstr_printf (&str, "%s:",
+                             (t->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
+                             ? "" : get_tok_str(t->v & ~SYM_FIELD, NULL));
+                cstr_printf (&str, e->type.t & VT_UNSIGNED ? "%u," : "%d,",
+                             (int)t->enum_val);
+            }
+            cstr_printf (&str, ";");
+            tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0, 0);
+            cstr_free (&str);
+            if (debug_info)
+                tcc_debug_remove(s1, e);
+	}
+    }
+    else if ((type & VT_BTYPE) != VT_FUNC) {
+        type &= ~VT_STRUCT_MASK;
+        for (debug_type = 1; debug_type <= N_DEFAULT_DEBUG; debug_type++)
+            if (default_debug[debug_type - 1].type == type)
+                break;
+        if (debug_type > N_DEFAULT_DEBUG)
+            return;
+    }
+    if (n > 0)
+        cstr_printf (result, "%d=", ++debug_next_type);
+    t = s;
+    for (;;) {
+        type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE | VT_VLA);
+        if ((type & VT_BTYPE) != VT_BYTE)
+            type &= ~VT_DEFSIGN;
+        if (type == VT_PTR)
+            cstr_printf (result, "%d=*", ++debug_next_type);
+        else if (type == (VT_PTR | VT_ARRAY))
+            cstr_printf (result, "%d=ar1;0;%d;",
+                         ++debug_next_type, t->type.ref->c - 1);
+        else if (type == VT_FUNC) {
+            cstr_printf (result, "%d=f", ++debug_next_type);
+            tcc_get_debug_info (s1, t->type.ref, result);
+            return;
+        }
+        else
+            break;
+        t = t->type.ref;
+    }
+    cstr_printf (result, "%d", debug_type);
+}
+
+static int tcc_get_dwarf_info(TCCState *s1, Sym *s)
+{
+    int type;
+    int debug_type = -1;
+    Sym *e, *t = s;
+    int i;
+    int last_pos = -1;
+    int retval;
+
+    if (new_file)
+        put_new_file(s1);
+    for (;;) {
+        type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE | VT_VLA);
+        if ((type & VT_BTYPE) != VT_BYTE)
+            type &= ~VT_DEFSIGN;
+        if (type == VT_PTR || type == (VT_PTR | VT_ARRAY))
+            t = t->type.ref;
+        else
+            break;
+    }
+    if ((type & VT_BTYPE) == VT_STRUCT) {
+        t = t->type.ref;
+	debug_type = tcc_debug_find(s1, t, 1);
+	if (debug_type == -1) {
+	    int pos_sib = 0, i, *pos_type;
+
+	    debug_type = tcc_debug_add(s1, t, 1);
+	    e = t;
+	    i = 0;
+	    while (e->next) {
+		e = e->next;
+		if (STRUCT_NODEBUG(e))
+		    continue;
+		i++;
+	    }
+	    pos_type = (int *) tcc_malloc(i * sizeof(int));
+	    dwarf_data1(dwarf_info_section,
+			IS_UNION (t->type.t)
+		        ? t->next ? DWARF_ABBREV_UNION_TYPE
+				  : DWARF_ABBREV_UNION_EMPTY_TYPE
+		        : t->next ? DWARF_ABBREV_STRUCTURE_TYPE
+				  : DWARF_ABBREV_STRUCTURE_EMPTY_TYPE);
+	    dwarf_strp(dwarf_info_section,
+                       (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
+                       ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL));
+	    dwarf_uleb128(dwarf_info_section, t->c);
+	    dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+	    dwarf_uleb128(dwarf_info_section, file->line_num);
+	    if (t->next) {
+	        pos_sib = dwarf_info_section->data_offset;
+	        dwarf_data4(dwarf_info_section, 0);
+	    }
+	    e = t;
+	    i = 0;
+            while (e->next) {
+                e = e->next;
+		if (STRUCT_NODEBUG(e))
+		    continue;
+	        dwarf_data1(dwarf_info_section,
+			    e->type.t & VT_BITFIELD ? DWARF_ABBREV_MEMBER_BF
+						    : DWARF_ABBREV_MEMBER);
+		dwarf_strp(dwarf_info_section,
+			   get_tok_str(e->v & ~SYM_FIELD, NULL));
+		dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+		dwarf_uleb128(dwarf_info_section, file->line_num);
+		pos_type[i++] = dwarf_info_section->data_offset;
+		dwarf_data4(dwarf_info_section, 0);
+                if (e->type.t & VT_BITFIELD) {
+                    int pos = e->c * 8 + BIT_POS(e->type.t);
+                    int size = BIT_SIZE(e->type.t);
+
+		    dwarf_uleb128(dwarf_info_section, size);
+		    dwarf_uleb128(dwarf_info_section, pos);
+		}
+		else
+		    dwarf_uleb128(dwarf_info_section, e->c);
+	    }
+	    if (t->next) {
+	        dwarf_data1(dwarf_info_section, 0);
+	        write32le(dwarf_info_section->data + pos_sib,
+		          dwarf_info_section->data_offset - dwarf_info.start);
+	    }
+	    e = t;
+	    i = 0;
+	    while (e->next) {
+		e = e->next;
+		if (STRUCT_NODEBUG(e))
+		    continue;
+		type = tcc_get_dwarf_info(s1, e);
+		tcc_debug_check_anon(s1, e, pos_type[i]);
+		write32le(dwarf_info_section->data + pos_type[i++],
+			  type - dwarf_info.start);
+	    }
+	    tcc_free(pos_type);
+	    if (debug_info)
+		tcc_debug_remove(s1, t);
+        }
+    }
+    else if (IS_ENUM(type)) {
+        t = t->type.ref;
+	debug_type = tcc_debug_find(s1, t, 1);
+	if (debug_type == -1) {
+	    int pos_sib, pos_type;
+	    Sym sym = {0}; sym.type.t = VT_INT | (type & VT_UNSIGNED);
+
+	    pos_type = tcc_get_dwarf_info(s1, &sym);
+	    debug_type = tcc_debug_add(s1, t, 1);
+	    dwarf_data1(dwarf_info_section, DWARF_ABBREV_ENUMERATION_TYPE);
+	    dwarf_strp(dwarf_info_section,
+                       (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
+                       ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL));
+	    dwarf_data1(dwarf_info_section,
+		        type & VT_UNSIGNED ? DW_ATE_unsigned : DW_ATE_signed );
+	    dwarf_data1(dwarf_info_section, 4);
+	    dwarf_data4(dwarf_info_section, pos_type - dwarf_info.start);
+	    dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+	    dwarf_uleb128(dwarf_info_section, file->line_num);
+	    pos_sib = dwarf_info_section->data_offset;
+	    dwarf_data4(dwarf_info_section, 0);
+	    e = t;
+            while (e->next) {
+                e = e->next;
+	        dwarf_data1(dwarf_info_section,
+			type & VT_UNSIGNED ? DWARF_ABBREV_ENUMERATOR_UNSIGNED
+					   : DWARF_ABBREV_ENUMERATOR_SIGNED);
+	        dwarf_strp(dwarf_info_section,
+                           (e->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
+                           ? "" : get_tok_str(e->v & ~SYM_FIELD, NULL));
+		if (type & VT_UNSIGNED)
+	            dwarf_uleb128(dwarf_info_section, e->enum_val);
+		else
+	            dwarf_sleb128(dwarf_info_section, e->enum_val);
+            }
+	    dwarf_data1(dwarf_info_section, 0);
+	    write32le(dwarf_info_section->data + pos_sib,
+		      dwarf_info_section->data_offset - dwarf_info.start);
+	    if (debug_info)
+		tcc_debug_remove(s1, t);
+	}
+    }
+    else if ((type & VT_BTYPE) != VT_FUNC) {
+        type &= ~VT_STRUCT_MASK;
+        for (i = 1; i <= N_DEFAULT_DEBUG; i++)
+            if (default_debug[i - 1].type == type)
+                break;
+        if (i > N_DEFAULT_DEBUG)
+            return 0;
+	debug_type = dwarf_info.base_type_used[i - 1];
+	if (debug_type == 0) {
+	    char name[100];
+
+	    debug_type = dwarf_info_section->data_offset;
+	    dwarf_data1(dwarf_info_section, DWARF_ABBREV_BASE_TYPE);
+	    dwarf_uleb128(dwarf_info_section, default_debug[i - 1].size);
+	    dwarf_data1(dwarf_info_section, default_debug[i - 1].encoding);
+	    strncpy(name, default_debug[i - 1].name, sizeof(name) -1);
+	    *strchr(name, ':') = 0;
+	    dwarf_strp(dwarf_info_section, name);
+	    dwarf_info.base_type_used[i - 1] = debug_type;
+	}
+    }
+    retval = debug_type;
+    e = NULL;
+    t = s;
+    for (;;) {
+        type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE | VT_VLA);
+        if ((type & VT_BTYPE) != VT_BYTE)
+            type &= ~VT_DEFSIGN;
+        if (type == VT_PTR) {
+	    i = dwarf_info_section->data_offset;
+	    if (retval == debug_type)
+		retval = i;
+	    dwarf_data1(dwarf_info_section, DWARF_ABBREV_POINTER);
+	    dwarf_data1(dwarf_info_section, PTR_SIZE);
+	    if (last_pos != -1) {
+		tcc_debug_check_anon(s1, e, last_pos);
+		write32le(dwarf_info_section->data + last_pos,
+			  i - dwarf_info.start);
+	    }
+	    last_pos = dwarf_info_section->data_offset;
+	    e = t->type.ref;
+	    dwarf_data4(dwarf_info_section, 0);
+	}
+        else if (type == (VT_PTR | VT_ARRAY)) {
+	    int sib_pos, sub_type;
+#if LONG_SIZE == 4
+	    Sym sym = {0}; sym.type.t = VT_LONG | VT_INT | VT_UNSIGNED;
+#else
+	    Sym sym = {0}; sym.type.t = VT_LLONG | VT_LONG | VT_UNSIGNED;
+#endif
+
+	    sub_type = tcc_get_dwarf_info(s1, &sym);
+	    i = dwarf_info_section->data_offset;
+	    if (retval == debug_type)
+		retval = i;
+	    dwarf_data1(dwarf_info_section, DWARF_ABBREV_ARRAY_TYPE);
+	    if (last_pos != -1) {
+		tcc_debug_check_anon(s1, e, last_pos);
+		write32le(dwarf_info_section->data + last_pos,
+			  i - dwarf_info.start);
+	    }
+	    last_pos = dwarf_info_section->data_offset;
+	    e = t->type.ref;
+	    dwarf_data4(dwarf_info_section, 0);
+	    sib_pos = dwarf_info_section->data_offset;
+	    dwarf_data4(dwarf_info_section, 0);
+	    for (;;) {
+	        dwarf_data1(dwarf_info_section, DWARF_ABBREV_SUBRANGE_TYPE);
+	        dwarf_data4(dwarf_info_section, sub_type - dwarf_info.start);
+	        dwarf_uleb128(dwarf_info_section, t->type.ref->c - 1);
+		s = t->type.ref;
+		type = s->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE);
+		if (type != (VT_PTR | VT_ARRAY))
+		    break;
+		t = s;
+	    }
+	    dwarf_data1(dwarf_info_section, 0);
+	    write32le(dwarf_info_section->data + sib_pos,
+		      dwarf_info_section->data_offset - dwarf_info.start);
+	}
+        else if (type == VT_FUNC) {
+	    int sib_pos = 0, *pos_type;
+	    Sym *f;
+
+	    i = dwarf_info_section->data_offset;
+	    debug_type = tcc_get_dwarf_info(s1, t->type.ref);
+	    if (retval == debug_type)
+		retval = i;
+	    dwarf_data1(dwarf_info_section,
+			t->type.ref->next ? DWARF_ABBREV_SUBROUTINE_TYPE
+					  : DWARF_ABBREV_SUBROUTINE_EMPTY_TYPE);
+	    if (last_pos != -1) {
+		tcc_debug_check_anon(s1, e, last_pos);
+		write32le(dwarf_info_section->data + last_pos,
+			  i - dwarf_info.start);
+	    }
+	    last_pos = dwarf_info_section->data_offset;
+	    e = t->type.ref;
+	    dwarf_data4(dwarf_info_section, 0);
+	    if (t->type.ref->next) {
+	        sib_pos = dwarf_info_section->data_offset;
+	        dwarf_data4(dwarf_info_section, 0);
+	    }
+	    f = t->type.ref;
+	    i = 0;
+	    while (f->next) {
+		f = f->next;
+		i++;
+	    }
+	    pos_type = (int *) tcc_malloc(i * sizeof(int));
+	    f = t->type.ref;
+	    i = 0;
+	    while (f->next) {
+		f = f->next;
+	        dwarf_data1(dwarf_info_section, DWARF_ABBREV_FORMAL_PARAMETER2);
+		pos_type[i++] = dwarf_info_section->data_offset;
+	        dwarf_data4(dwarf_info_section, 0);
+	    }
+	    if (t->type.ref->next) {
+	        dwarf_data1(dwarf_info_section, 0);
+	        write32le(dwarf_info_section->data + sib_pos,
+		          dwarf_info_section->data_offset - dwarf_info.start);
+	    }
+	    f = t->type.ref;
+	    i = 0;
+	    while (f->next) {
+		f = f->next;
+		type = tcc_get_dwarf_info(s1, f);
+		tcc_debug_check_anon(s1, f, pos_type[i]);
+	        write32le(dwarf_info_section->data + pos_type[i++],
+                          type - dwarf_info.start);
+	    }
+	    tcc_free(pos_type);
+        }
+        else {
+	    if (last_pos != -1) {
+		tcc_debug_check_anon(s1, e, last_pos);
+		write32le(dwarf_info_section->data + last_pos,
+			  debug_type - dwarf_info.start);
+	    }
+            break;
+	}
+        t = t->type.ref;
+    }
+    return retval;
+}
+
+static void tcc_debug_finish (TCCState *s1, struct _debug_info *cur)
+{
+    while (cur) {
+        struct _debug_info *next = cur->next;
+        int i;
+
+        if (s1->dwarf) {
+
+            for (i = cur->n_sym - 1; i >= 0; i--) {
+                struct debug_sym *s = &cur->sym[i];
+
+		dwarf_data1(dwarf_info_section,
+                            s->type == N_PSYM
+			    ? DWARF_ABBREV_FORMAL_PARAMETER
+			    : s->type == N_GSYM
+                            ? DWARF_ABBREV_VARIABLE_EXTERNAL
+                            : s->type == N_STSYM
+			    ? DWARF_ABBREV_VARIABLE_STATIC
+			    : DWARF_ABBREV_VARIABLE_LOCAL);
+                dwarf_strp(dwarf_info_section, s->str);
+		if (s->type == N_GSYM || s->type == N_STSYM) {
+                    dwarf_uleb128(dwarf_info_section, s->file);
+                    dwarf_uleb128(dwarf_info_section, s->line);
+		}
+                dwarf_data4(dwarf_info_section, s->info - dwarf_info.start);
+		if (s->type == N_GSYM || s->type == N_STSYM) {
+		    /* global/static */
+		    if (s->type == N_GSYM)
+                        dwarf_data1(dwarf_info_section, 1);
+                    dwarf_data1(dwarf_info_section, PTR_SIZE + 1);
+                    dwarf_data1(dwarf_info_section, DW_OP_addr);
+		    if (s->type == N_STSYM)
+		        dwarf_reloc(dwarf_info_section, section_sym, R_DATA_PTR);
+#if PTR_SIZE == 4
+                    dwarf_data4(dwarf_info_section, s->value);
+#else
+                    dwarf_data8(dwarf_info_section, s->value);
+#endif
+		}
+		else {
+		    /* param/local */
+                    dwarf_data1(dwarf_info_section, dwarf_sleb128_size(s->value) + 1);
+                    dwarf_data1(dwarf_info_section, DW_OP_fbreg);
+                    dwarf_sleb128(dwarf_info_section, s->value);
+		}
+		tcc_free (s->str);
+            }
+            tcc_free (cur->sym);
+            dwarf_data1(dwarf_info_section,
+			cur->child ? DWARF_ABBREV_LEXICAL_BLOCK
+			           : DWARF_ABBREV_LEXICAL_EMPTY_BLOCK);
+            dwarf_reloc(dwarf_info_section, section_sym, R_DATA_PTR);
+#if PTR_SIZE == 4
+            dwarf_data4(dwarf_info_section, func_ind + cur->start);
+            dwarf_data4(dwarf_info_section, cur->end - cur->start);
+#else
+            dwarf_data8(dwarf_info_section, func_ind + cur->start);
+            dwarf_data8(dwarf_info_section, cur->end - cur->start);
+#endif
+            tcc_debug_finish (s1, cur->child);
+	    if (cur->child)
+                dwarf_data1(dwarf_info_section, 0);
+        }
+        else
+        {
+            for (i = 0; i < cur->n_sym; i++) {
+                struct debug_sym *s = &cur->sym[i];
+
+                if (s->sec)
+                    put_stabs_r(s1, s->str, s->type, 0, 0, s->value,
+                                s->sec, s->sym_index);
+                else
+                    put_stabs(s1, s->str, s->type, 0, 0, s->value);
+                tcc_free (s->str);
+            }
+            tcc_free (cur->sym);
+            put_stabn(s1, N_LBRAC, 0, 0, cur->start);
+            tcc_debug_finish (s1, cur->child);
+            put_stabn(s1, N_RBRAC, 0, 0, cur->end);
+        }
+        tcc_free (cur);
+        cur = next;
+    }
+}
+
+ST_FUNC void tcc_add_debug_info(TCCState *s1, int param, Sym *s, Sym *e)
+{
+    CString debug_str;
+
+    if (!(s1->do_debug & 2))
+        return;
+
+    cstr_new (&debug_str);
+    for (; s != e; s = s->prev) {
+        if (!s->v || (s->r & VT_VALMASK) != VT_LOCAL)
+            continue;
+	if (s1->dwarf) {
+	    tcc_debug_stabs(s1, get_tok_str(s->v, NULL),
+			    param ? N_PSYM : N_LSYM, s->c, NULL, 0,
+			    tcc_get_dwarf_info(s1, s));
+	}
+	else
+        {
+            cstr_reset (&debug_str);
+            cstr_printf (&debug_str, "%s:%s", get_tok_str(s->v, NULL),
+			 param ? "p" : "");
+            tcc_get_debug_info(s1, s, &debug_str);
+            tcc_debug_stabs(s1, debug_str.data, param ? N_PSYM : N_LSYM,
+			    s->c, NULL, 0, 0);
+	}
+    }
+    cstr_free (&debug_str);
+}
+
+/* put function symbol */
+ST_FUNC void tcc_debug_funcstart(TCCState *s1, Sym *sym)
+{
+    CString debug_str;
+    BufferedFile *f;
+
+    if (!s1->do_debug)
+        return;
+    debug_info_root = NULL;
+    debug_info = NULL;
+    tcc_debug_stabn(s1, N_LBRAC, ind - func_ind);
+    f = put_new_file(s1);
+    if (!f)
+	return;
+
+    if (s1->dwarf) {
+        tcc_debug_line(s1);
+        dwarf_info.func = sym;
+        dwarf_info.line = file->line_num;
+	if (s1->do_backtrace) {
+	    int i, len;
+
+	    dwarf_line_op(s1, 0); // extended
+	    dwarf_uleb128_op(s1, strlen(funcname) + 2);
+	    dwarf_line_op(s1, DW_LNE_hi_user - 1);
+	    len = strlen(funcname) + 1;
+	    for (i = 0; i < len; i++)
+		dwarf_line_op(s1, funcname[i]);
+	}
+    }
+    else
+    {
+        cstr_new (&debug_str);
+        cstr_printf(&debug_str, "%s:%c", funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
+        tcc_get_debug_info(s1, sym->type.ref, &debug_str);
+        put_stabs_r(s1, debug_str.data, N_FUN, 0, f->line_num, 0, cur_text_section, sym->c);
+        cstr_free (&debug_str);
+        tcc_debug_line(s1);
+    }
+}
+
+ST_FUNC void tcc_debug_prolog_epilog(TCCState *s1, int value)
+{
+    if (!s1->do_debug)
+        return;
+    if (s1->dwarf) {
+	dwarf_line_op(s1, value == 0 ? DW_LNS_set_prologue_end
+				     : DW_LNS_set_epilogue_begin);
+    }
+}
+
+/* put function size */
+ST_FUNC void tcc_debug_funcend(TCCState *s1, int size)
+{
+    /* lldb does not like function end and next function start at same pc */
+    int min_instr_len;
+
+    if (!s1->do_debug)
+        return;
+    min_instr_len = dwarf_line.last_pc == ind ? 0 : DWARF_MIN_INSTR_LEN;
+    ind -= min_instr_len;
+    tcc_debug_line(s1);
+    ind += min_instr_len;
+    tcc_debug_stabn(s1, N_RBRAC, size);
+    if (s1->dwarf) {
+        int func_sib = 0;
+	Sym *sym = dwarf_info.func;
+	int n_debug_info = tcc_get_dwarf_info(s1, sym->type.ref);
+
+        dwarf_data1(dwarf_info_section,
+	    sym->type.t & VT_STATIC ? DWARF_ABBREV_SUBPROGRAM_STATIC
+				    : DWARF_ABBREV_SUBPROGRAM_EXTERNAL);
+        if ((sym->type.t & VT_STATIC) == 0)
+            dwarf_data1(dwarf_info_section, 1);
+        dwarf_strp(dwarf_info_section, funcname);
+        dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+        dwarf_uleb128(dwarf_info_section, dwarf_info.line);
+	tcc_debug_check_anon(s1, sym->type.ref, dwarf_info_section->data_offset);
+        dwarf_data4(dwarf_info_section, n_debug_info - dwarf_info.start);
+        dwarf_reloc(dwarf_info_section, section_sym, R_DATA_PTR);
+#if PTR_SIZE == 4
+        dwarf_data4(dwarf_info_section, func_ind); // low_pc
+        dwarf_data4(dwarf_info_section, size); // high_pc
+#else
+        dwarf_data8(dwarf_info_section, func_ind); // low_pc
+        dwarf_data8(dwarf_info_section, size); // high_pc
+#endif
+        func_sib = dwarf_info_section->data_offset;
+        dwarf_data4(dwarf_info_section, 0); // sibling
+        dwarf_data1(dwarf_info_section, 1);
+#if defined(TCC_TARGET_I386)
+        dwarf_data1(dwarf_info_section, DW_OP_reg5); // ebp
+#elif defined(TCC_TARGET_X86_64)
+        dwarf_data1(dwarf_info_section, DW_OP_reg6); // rbp
+#elif defined TCC_TARGET_ARM
+        dwarf_data1(dwarf_info_section, DW_OP_reg13); // sp
+#elif defined TCC_TARGET_ARM64
+        dwarf_data1(dwarf_info_section, DW_OP_reg29); // reg 29
+#elif defined TCC_TARGET_RISCV64
+        dwarf_data1(dwarf_info_section, DW_OP_reg8); // r8(s0)
+#else
+        dwarf_data1(dwarf_info_section, DW_OP_call_frame_cfa);
+#endif
+        tcc_debug_finish (s1, debug_info_root);
+	dwarf_data1(dwarf_info_section, 0);
+        write32le(dwarf_info_section->data + func_sib,
+                  dwarf_info_section->data_offset - dwarf_info.start);
+    }
+    else
+    {
+        tcc_debug_finish (s1, debug_info_root);
+    }
+    debug_info_root = 0;
+}
+
+
+ST_FUNC void tcc_debug_extern_sym(TCCState *s1, Sym *sym, int sh_num, int sym_bind, int sym_type)
+{
+    if (!(s1->do_debug & 2))
+        return;
+
+    if (sym_type == STT_FUNC || sym->v >= SYM_FIRST_ANOM)
+        return;
+    if (s1->dwarf) {
+        int debug_type;
+
+        debug_type = tcc_get_dwarf_info(s1, sym);
+	dwarf_data1(dwarf_info_section,
+		    sym_bind == STB_GLOBAL
+		    ? DWARF_ABBREV_VARIABLE_EXTERNAL
+		    : DWARF_ABBREV_VARIABLE_STATIC);
+	dwarf_strp(dwarf_info_section, get_tok_str(sym->v, NULL));
+	dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+	dwarf_uleb128(dwarf_info_section, file->line_num);
+	tcc_debug_check_anon(s1, sym, dwarf_info_section->data_offset);
+	dwarf_data4(dwarf_info_section, debug_type - dwarf_info.start);
+	if (sym_bind == STB_GLOBAL)
+	    dwarf_data1(dwarf_info_section, 1);
+	dwarf_data1(dwarf_info_section, PTR_SIZE + 1);
+	dwarf_data1(dwarf_info_section, DW_OP_addr);
+	greloca(dwarf_info_section, sym, dwarf_info_section->data_offset,
+		R_DATA_PTR, 0);
+#if PTR_SIZE == 4
+	dwarf_data4(dwarf_info_section, 0);
+#else
+	dwarf_data8(dwarf_info_section, 0);
+#endif
+    }
+    else
+    {
+        Section *s = sh_num == SHN_COMMON ? common_section
+					  : s1->sections[sh_num];
+        CString str;
+
+        cstr_new (&str);
+        cstr_printf (&str, "%s:%c",
+                get_tok_str(sym->v, NULL),
+                sym_bind == STB_GLOBAL ? 'G' : func_ind != -1 ? 'V' : 'S'
+                );
+        tcc_get_debug_info(s1, sym, &str);
+        if (sym_bind == STB_GLOBAL)
+            tcc_debug_stabs(s1, str.data, N_GSYM, 0, NULL, 0, 0);
+        else
+            tcc_debug_stabs(s1, str.data,
+                (sym->type.t & VT_STATIC) && data_section == s
+                ? N_STSYM : N_LCSYM, 0, s, sym->c, 0);
+        cstr_free (&str);
+    }
+}
+
+ST_FUNC void tcc_debug_typedef(TCCState *s1, Sym *sym)
+{
+    if (!(s1->do_debug & 2))
+        return;
+
+    if (s1->dwarf) {
+	int debug_type;
+
+        debug_type = tcc_get_dwarf_info(s1, sym);
+	if (debug_type != -1) {
+	    dwarf_data1(dwarf_info_section, DWARF_ABBREV_TYPEDEF);
+	    dwarf_strp(dwarf_info_section, get_tok_str(sym->v & ~SYM_FIELD, NULL));
+	    dwarf_uleb128(dwarf_info_section, dwarf_line.cur_file);
+	    dwarf_uleb128(dwarf_info_section, file->line_num);
+	    tcc_debug_check_anon(s1, sym, dwarf_info_section->data_offset);
+	    dwarf_data4(dwarf_info_section, debug_type - dwarf_info.start);
+	}
+    }
+    else
+    {
+        CString str;
+        cstr_new (&str);
+        cstr_printf (&str, "%s:t",
+                     (sym->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
+                     ? "" : get_tok_str(sym->v & ~SYM_FIELD, NULL));
+        tcc_get_debug_info(s1, sym, &str);
+        tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0, 0);
+        cstr_free (&str);
+    }
+}
+
+/* ------------------------------------------------------------------------- */
+/* for section layout see lib/tcov.c */
+
+ST_FUNC void tcc_tcov_block_end(TCCState *s1, int line);
+
+ST_FUNC void tcc_tcov_block_begin(TCCState *s1)
+{
+    SValue sv;
+    void *ptr;
+    unsigned long last_offset = tcov_data.offset;
+
+    tcc_tcov_block_end (tcc_state, 0);
+    if (s1->test_coverage == 0 || nocode_wanted)
+	return;
+
+    if (tcov_data.last_file_name == 0 ||
+	strcmp ((const char *)(tcov_section->data + tcov_data.last_file_name),
+		file->true_filename) != 0) {
+	char wd[1024];
+	CString cstr;
+
+	if (tcov_data.last_func_name)
+	    section_ptr_add(tcov_section, 1);
+	if (tcov_data.last_file_name)
+	    section_ptr_add(tcov_section, 1);
+	tcov_data.last_func_name = 0;
+	cstr_new (&cstr);
+	if (file->true_filename[0] == '/') {
+	    tcov_data.last_file_name = tcov_section->data_offset;
+	    cstr_printf (&cstr, "%s", file->true_filename);
+	}
+	else {
+	    getcwd (wd, sizeof(wd));
+	    tcov_data.last_file_name = tcov_section->data_offset + strlen(wd) + 1;
+	    cstr_printf (&cstr, "%s/%s", wd, file->true_filename);
+	}
+	ptr = section_ptr_add(tcov_section, cstr.size + 1);
+	strcpy((char *)ptr, cstr.data);
+#ifdef _WIN32
+        normalize_slashes((char *)ptr);
+#endif
+	cstr_free (&cstr);
+    }
+    if (tcov_data.last_func_name == 0 ||
+	strcmp ((const char *)(tcov_section->data + tcov_data.last_func_name),
+		funcname) != 0) {
+	size_t len;
+
+	if (tcov_data.last_func_name)
+	    section_ptr_add(tcov_section, 1);
+	tcov_data.last_func_name = tcov_section->data_offset;
+	len = strlen (funcname);
+	ptr = section_ptr_add(tcov_section, len + 1);
+	strcpy((char *)ptr, funcname);
+	section_ptr_add(tcov_section, -tcov_section->data_offset & 7);
+	ptr = section_ptr_add(tcov_section, 8);
+	write64le (ptr, file->line_num);
+    }
+    if (ind == tcov_data.ind && tcov_data.line == file->line_num)
+        tcov_data.offset = last_offset;
+    else {
+        Sym label = {0};
+        label.type.t = VT_LLONG | VT_STATIC;
+
+        ptr = section_ptr_add(tcov_section, 16);
+        tcov_data.line = file->line_num;
+        write64le (ptr, (tcov_data.line << 8) | 0xff);
+        put_extern_sym(&label, tcov_section,
+		       ((unsigned char *)ptr - tcov_section->data) + 8, 0);
+        sv.type = label.type;
+        sv.r = VT_SYM | VT_LVAL | VT_CONST;
+        sv.r2 = VT_CONST;
+        sv.c.i = 0;
+        sv.sym = &label;
+#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || \
+    defined TCC_TARGET_ARM || defined TCC_TARGET_ARM64 || \
+    defined TCC_TARGET_RISCV64
+        gen_increment_tcov (&sv);
+#else
+        vpushv(&sv);
+        inc(0, TOK_INC);
+        vpop();
+#endif
+        tcov_data.offset = (unsigned char *)ptr - tcov_section->data;
+        tcov_data.ind = ind;
+    }
+}
+
+ST_FUNC void tcc_tcov_block_end(TCCState *s1, int line)
+{
+    if (s1->test_coverage == 0)
+	return;
+    if (line == -1)
+        line = tcov_data.line;
+    if (tcov_data.offset) {
+	void *ptr = tcov_section->data + tcov_data.offset;
+	unsigned long long nline = line ? line : file->line_num;
+
+	write64le (ptr, (read64le (ptr) & 0xfffffffffull) | (nline << 36));
+	tcov_data.offset = 0;
+    }
+}
+
+ST_FUNC void tcc_tcov_check_line(TCCState *s1, int start)
+{
+    if (s1->test_coverage == 0)
+	return;
+    if (tcov_data.line != file->line_num) {
+        if ((tcov_data.line + 1) != file->line_num) {
+	    tcc_tcov_block_end (s1, -1);
+	    if (start)
+                tcc_tcov_block_begin (s1);
+	}
+	else
+	    tcov_data.line = file->line_num;
+    }
+}
+
+ST_FUNC void tcc_tcov_start(TCCState *s1)
+{
+    if (s1->test_coverage == 0)
+	return;
+    if (!s1->dState)
+        s1->dState = tcc_mallocz(sizeof *s1->dState);
+    memset (&tcov_data, 0, sizeof (tcov_data));
+    if (tcov_section == NULL) {
+        tcov_section = new_section(tcc_state, ".tcov", SHT_PROGBITS,
+				   SHF_ALLOC | SHF_WRITE);
+	section_ptr_add(tcov_section, 4); // pointer to executable name
+    }
+}
+
+ST_FUNC void tcc_tcov_end(TCCState *s1)
+{
+    if (s1->test_coverage == 0)
+	return;
+    if (tcov_data.last_func_name)
+        section_ptr_add(tcov_section, 1);
+    if (tcov_data.last_file_name)
+        section_ptr_add(tcov_section, 1);
+}
+
+ST_FUNC void tcc_tcov_reset_ind(TCCState *s1)
+{
+    tcov_data.ind = 0;
+}
+
+/* ------------------------------------------------------------------------- */
+#undef last_line_num
+#undef new_file
+#undef section_sym
+#undef debug_next_type
+#undef debug_hash
+#undef n_debug_hash
+#undef debug_anon_hash
+#undef n_debug_anon_hash
+#undef debug_info
+#undef debug_info_root
+#undef dwarf_sym
+#undef dwarf_line
+#undef dwarf_info
+#undef tcov_data
diff --git a/tccelf.c b/tccelf.c
index 9e860b598..8f1d9642b 100644
--- a/tccelf.c
+++ b/tccelf.c
@@ -47,6 +47,14 @@ struct sym_version {
 /* section is dynsymtab_section */
 #define SHF_DYNSYM 0x40000000
 
+#ifdef TCC_TARGET_PE
+static const int shf_RELRO = SHF_ALLOC;
+static const char rdata[] = ".rdata";
+#else
+static const int shf_RELRO = SHF_ALLOC | SHF_WRITE;
+static const char rdata[] = ".data.ro";
+#endif
+
 /* ------------------------------------------------------------------------- */
 
 ST_FUNC void tccelf_new(TCCState *s)
@@ -58,12 +66,8 @@ ST_FUNC void tccelf_new(TCCState *s)
     /* create standard sections */
     text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
     data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
-#ifdef TCC_TARGET_PE
-    rodata_section = new_section(s, ".rdata", SHT_PROGBITS, SHF_ALLOC);
-#else
     /* create ro data section (make ro after relocation done with GNU_RELRO) */
-    rodata_section = new_section(s, ".data.ro", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
-#endif
+    rodata_section = new_section(s, rdata, SHT_PROGBITS, shf_RELRO);
     bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
     common_section = new_section(s, ".common", SHT_NOBITS, SHF_PRIVATE);
     common_section->sh_num = SHN_COMMON;
@@ -86,30 +90,11 @@ ST_FUNC void tccelf_bounds_new(TCCState *s)
 {
     TCCState *s1 = s;
     /* create bounds sections (make ro after relocation done with GNU_RELRO) */
-    bounds_section = new_section(s, ".bounds",
-                                 SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
-    lbounds_section = new_section(s, ".lbounds",
-                                  SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
+    bounds_section = new_section(s, ".bounds", SHT_PROGBITS, shf_RELRO);
+    lbounds_section = new_section(s, ".lbounds", SHT_PROGBITS, shf_RELRO);
 }
 #endif
 
-ST_FUNC void tccelf_stab_new(TCCState *s)
-{
-    TCCState *s1 = s;
-    int shf = 0;
-#ifdef CONFIG_TCC_BACKTRACE
-    /* include stab info with standalone backtrace support */
-    if (s->do_backtrace && s->output_type != TCC_OUTPUT_MEMORY)
-        shf = SHF_ALLOC | SHF_WRITE; // SHF_WRITE needed for musl/SELINUX
-#endif
-    stab_section = new_section(s, ".stab", SHT_PROGBITS, shf);
-    stab_section->sh_entsize = sizeof(Stab_Sym);
-    stab_section->sh_addralign = sizeof ((Stab_Sym*)0)->n_value;
-    stab_section->link = new_section(s, ".stabstr", SHT_STRTAB, shf);
-    /* put first entry */
-    put_stabs(s, "", 0, 0, 0, 0);
-}
-
 static void free_section(Section *s)
 {
     tcc_free(s->data);
@@ -191,6 +176,13 @@ ST_FUNC void tccelf_end_file(TCCState *s1)
         if (sym->st_shndx == SHN_UNDEF
             && ELFW(ST_BIND)(sym->st_info) == STB_LOCAL)
             sym->st_info = ELFW(ST_INFO)(STB_GLOBAL, ELFW(ST_TYPE)(sym->st_info));
+#ifndef TCC_TARGET_PE
+	/* An ELF relocatable file should have the types of its undefined global symbol set
+	   to STT_NOTYPE or it will confuse binutils bfd */
+        if (s1->output_format == TCC_OUTPUT_FORMAT_ELF && s1->output_type == TCC_OUTPUT_OBJ)
+            if (sym->st_shndx == SHN_UNDEF && ELFW(ST_BIND)(sym->st_info) == STB_GLOBAL)
+                sym->st_info = ELFW(ST_INFO)(STB_GLOBAL, ELFW(ST_TYPE)(STT_NOTYPE));
+#endif
         tr[i] = set_elf_sym(s, sym->st_value, sym->st_size, sym->st_info,
             sym->st_other, sym->st_shndx, (char*)s->link->data + sym->st_name);
     }
@@ -202,7 +194,8 @@ ST_FUNC void tccelf_end_file(TCCState *s1)
             ElfW_Rel *rel_end = (ElfW_Rel*)(sr->data + sr->data_offset);
             for (; rel < rel_end; ++rel) {
                 int n = ELFW(R_SYM)(rel->r_info) - first_sym;
-                //if (n < 0) tcc_error("internal: invalid symbol index in relocation");
+                if (n < 0) /* zero sym_index in reloc (can happen with asm) */
+                    continue;
                 rel->r_info = ELFW(R_INFO)(tr[n], ELFW(R_TYPE)(rel->r_info));
             }
         }
@@ -230,6 +223,7 @@ ST_FUNC Section *new_section(TCCState *s1, const char *name, int sh_type, int sh
         sec->sh_addralign = 2;
         break;
     case SHT_HASH:
+    case SHT_GNU_HASH:
     case SHT_REL:
     case SHT_RELA:
     case SHT_DYNSYM:
@@ -338,7 +332,7 @@ static void section_reserve(Section *sec, unsigned long size)
 }
 #endif
 
-static Section *find_section_create (TCCState *s1, const char *name, int create)
+static Section *have_section(TCCState *s1, const char *name)
 {
     Section *sec;
     int i;
@@ -347,15 +341,18 @@ static Section *find_section_create (TCCState *s1, const char *name, int create)
         if (!strcmp(name, sec->name))
             return sec;
     }
-    /* sections are created as PROGBITS */
-    return create ? new_section(s1, name, SHT_PROGBITS, SHF_ALLOC) : NULL;
+    return NULL;
 }
 
 /* return a reference to a section, and create it if it does not
    exists */
 ST_FUNC Section *find_section(TCCState *s1, const char *name)
 {
-    return find_section_create (s1, name, 1);
+    Section *sec = have_section(s1, name);
+    if (sec)
+        return sec;
+    /* sections are created as PROGBITS */
+    return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -373,9 +370,9 @@ ST_FUNC int put_elf_str(Section *s, const char *sym)
 }
 
 /* elf symbol hashing function */
-static unsigned long elf_hash(const unsigned char *name)
+static ElfW(Word) elf_hash(const unsigned char *name)
 {
-    unsigned long h = 0, g;
+    ElfW(Word) h = 0, g;
 
     while (*name) {
         h = (h << 4) + *name++;
@@ -516,7 +513,7 @@ ST_FUNC addr_t get_sym_addr(TCCState *s1, const char *name, int err, int forc)
     sym = &((ElfW(Sym) *)s1->symtab->data)[sym_index];
     if (!sym_index || sym->st_shndx == SHN_UNDEF) {
         if (err)
-            tcc_error("%s not defined", name);
+            tcc_error_noabort("%s not defined", name);
         return (addr_t)-1;
     }
     return sym->st_value;
@@ -582,9 +579,11 @@ version_add (TCCState *s1)
     symtab = s1->dynsym;
     end_sym = symtab->data_offset / sizeof (ElfSym);
     versym = section_ptr_add(versym_section, end_sym * sizeof(ElfW(Half)));
-    for (sym_index = 0; sym_index < end_sym; ++sym_index) {
+    for (sym_index = 1; sym_index < end_sym; ++sym_index) {
         int dllindex, verndx;
         sym = &((ElfW(Sym) *)symtab->data)[sym_index];
+        if (sym->st_shndx != SHN_UNDEF)
+            continue; /* defined symbol doesn't need library version */
         name = (char *) symtab->link->data + sym->st_name;
         dllindex = find_elf_sym(s1->dynsymtab_section, name);
         verndx = (dllindex && dllindex < nb_sym_to_version)
@@ -593,8 +592,7 @@ version_add (TCCState *s1)
             if (!sym_versions[verndx].out_index)
               sym_versions[verndx].out_index = nb_versions++;
             versym[sym_index] = sym_versions[verndx].out_index;
-        } else
-          versym[sym_index] = 0;
+        }
     }
     /* generate verneed section, but not when it will be empty.  Some
        dynamic linkers look at their contents even when DTVERNEEDNUM and
@@ -610,6 +608,14 @@ version_add (TCCState *s1)
             ElfW(Vernaux) *vna = 0;
             if (sv->out_index < 1)
               continue;
+
+            /* make sure that a DT_NEEDED tag is put */
+            /* abitest-tcc fails on older i386-linux with "ld-linux.so.2" DT_NEEDED
+               ret_int_test... Inconsistency detected by ld.so: dl-minimal.c: 148:
+               realloc: Assertion `ptr == alloc_last_block' failed! */
+            if (strcmp(sv->lib, "ld-linux.so.2"))
+                tcc_add_dllref(s1, sv->lib, 0);
+
             vnofs = section_add(verneed_section, sizeof(*vn), 1);
             vn = (ElfW(Verneed)*)(verneed_section->data + vnofs);
             vn->vn_version = 1;
@@ -642,7 +648,7 @@ version_add (TCCState *s1)
     }
     dt_verneednum = nb_entries;
 }
-#endif
+#endif /* ndef ELF_OBJ_ONLY */
 
 /* add an elf symbol : check if it is already defined and patch
    it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
@@ -681,7 +687,6 @@ ST_FUNC int set_elf_sym(Section *s, addr_t value, unsigned long size,
             }
             esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
                              | new_vis;
-            other = esym->st_other; /* in case we have to patch esym */
             if (shndx == SHN_UNDEF) {
                 /* ignore adding of undefined symbol if the
                    corresponding symbol is already defined */
@@ -716,13 +721,13 @@ ST_FUNC int set_elf_sym(Section *s, addr_t value, unsigned long size,
                 tcc_error_noabort("'%s' defined twice", name);
             }
         } else {
+            esym->st_other = other;
         do_patch:
             esym->st_info = ELFW(ST_INFO)(sym_bind, sym_type);
             esym->st_shndx = shndx;
             s1->new_undef_sym = 1;
             esym->st_value = value;
             esym->st_size = size;
-            esym->st_other = other;
         }
     } else {
     do_def:
@@ -761,7 +766,7 @@ ST_FUNC void put_elf_reloca(Section *symtab, Section *s, unsigned long offset,
     rel->r_addend = addend;
 #endif
     if (SHT_RELX != SHT_RELA && addend)
-        tcc_error("non-zero addend on REL architecture");
+        tcc_error_noabort("non-zero addend on REL architecture");
 }
 
 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
@@ -770,50 +775,6 @@ ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
     put_elf_reloca(symtab, s, offset, type, symbol, 0);
 }
 
-/* put stab debug information */
-ST_FUNC void put_stabs(TCCState *s1, const char *str, int type, int other, int desc,
-                      unsigned long value)
-{
-    Stab_Sym *sym;
-
-    unsigned offset;
-    if (type == N_SLINE
-        && (offset = stab_section->data_offset)
-        && (sym = (Stab_Sym*)(stab_section->data + offset) - 1)
-        && sym->n_type == type
-        && sym->n_value == value) {
-        /* just update line_number in previous entry */
-        sym->n_desc = desc;
-        return;
-    }
-
-    sym = section_ptr_add(stab_section, sizeof(Stab_Sym));
-    if (str) {
-        sym->n_strx = put_elf_str(stab_section->link, str);
-    } else {
-        sym->n_strx = 0;
-    }
-    sym->n_type = type;
-    sym->n_other = other;
-    sym->n_desc = desc;
-    sym->n_value = value;
-}
-
-ST_FUNC void put_stabs_r(TCCState *s1, const char *str, int type, int other, int desc,
-                        unsigned long value, Section *sec, int sym_index)
-{
-    put_elf_reloc(symtab_section, stab_section,
-                  stab_section->data_offset + 8,
-                  sizeof ((Stab_Sym*)0)->n_value == PTR_SIZE ? R_DATA_PTR : R_DATA_32,
-                  sym_index);
-    put_stabs(s1, str, type, other, desc, value);
-}
-
-ST_FUNC void put_stabn(TCCState *s1, int type, int other, int desc, int value)
-{
-    put_stabs(s1, NULL, type, other, desc, value);
-}
-
 ST_FUNC struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc)
 {
     int n;
@@ -835,6 +796,25 @@ ST_FUNC struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc)
     return &s1->sym_attrs[index];
 }
 
+static void modify_reloctions_old_to_new(TCCState *s1, Section *s, int *old_to_new_syms)
+{
+    int i, type, sym_index;
+    Section *sr;
+    ElfW_Rel *rel;
+
+    for(i = 1; i < s1->nb_sections; i++) {
+        sr = s1->sections[i];
+        if (sr->sh_type == SHT_RELX && sr->link == s) {
+            for_each_elem(sr, 0, rel, ElfW_Rel) {
+                sym_index = ELFW(R_SYM)(rel->r_info);
+                type = ELFW(R_TYPE)(rel->r_info);
+                sym_index = old_to_new_syms[sym_index];
+                rel->r_info = ELFW(R_INFO)(sym_index, type);
+            }
+        }
+    }
+}
+
 /* In an ELF file symbol table, the local symbols must appear below
    the global and weak ones. Since TCC cannot sort it while generating
    the code, we must do it after. All the relocation tables are also
@@ -845,9 +825,6 @@ static void sort_syms(TCCState *s1, Section *s)
     ElfW(Sym) *new_syms;
     int nb_syms, i;
     ElfW(Sym) *p, *q;
-    ElfW_Rel *rel;
-    Section *sr;
-    int type, sym_index;
 
     nb_syms = s->data_offset / sizeof(ElfW(Sym));
     new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
@@ -881,21 +858,178 @@ static void sort_syms(TCCState *s1, Section *s)
     memcpy(s->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
     tcc_free(new_syms);
 
-    /* now we modify all the relocations */
-    for(i = 1; i < s1->nb_sections; i++) {
-        sr = s1->sections[i];
-        if (sr->sh_type == SHT_RELX && sr->link == s) {
-            for_each_elem(sr, 0, rel, ElfW_Rel) {
-                sym_index = ELFW(R_SYM)(rel->r_info);
-                type = ELFW(R_TYPE)(rel->r_info);
-                sym_index = old_to_new_syms[sym_index];
-                rel->r_info = ELFW(R_INFO)(sym_index, type);
-            }
+    modify_reloctions_old_to_new(s1, s, old_to_new_syms);
+
+    tcc_free(old_to_new_syms);
+}
+
+#ifndef ELF_OBJ_ONLY
+/* See: https://flapenguin.me/elf-dt-gnu-hash */
+#define	ELFCLASS_BITS (PTR_SIZE * 8)
+
+static Section *create_gnu_hash(TCCState *s1)
+{
+    int nb_syms, i, ndef, nbuckets, symoffset, bloom_size, bloom_shift;
+    ElfW(Sym) *p;
+    Section *gnu_hash;
+    Section *dynsym = s1->dynsym;
+    Elf32_Word *ptr;
+
+    gnu_hash = new_section(s1, ".gnu.hash", SHT_GNU_HASH, SHF_ALLOC);
+    gnu_hash->link = dynsym->hash->link;
+
+    nb_syms = dynsym->data_offset / sizeof(ElfW(Sym));
+
+    /* count def symbols */
+    ndef = 0;
+    p = (ElfW(Sym) *)dynsym->data;
+    for(i = 0; i < nb_syms; i++, p++)
+        ndef += p->st_shndx != SHN_UNDEF;
+
+    /* calculate gnu hash sizes and fill header */
+    nbuckets = ndef / 4 + 1;
+    symoffset = nb_syms - ndef;
+    bloom_shift = PTR_SIZE == 8 ? 6 : 5;
+    bloom_size = 1; /* must be power of two */
+    while (ndef >= bloom_size * (1 << (bloom_shift - 3)))
+	bloom_size *= 2;
+    ptr = section_ptr_add(gnu_hash, 4 * 4 +
+				    PTR_SIZE * bloom_size +
+				    nbuckets * 4 +
+				    ndef * 4);
+    ptr[0] = nbuckets;
+    ptr[1] = symoffset;
+    ptr[2] = bloom_size;
+    ptr[3] = bloom_shift;
+    return gnu_hash;
+}
+
+static Elf32_Word elf_gnu_hash (const unsigned char *name)
+{
+    Elf32_Word h = 5381;
+    unsigned char c;
+
+    while ((c = *name++))
+        h = h * 33 + c;
+    return h;
+}
+
+static void update_gnu_hash(TCCState *s1, Section *gnu_hash)
+{
+    int *old_to_new_syms;
+    ElfW(Sym) *new_syms;
+    int nb_syms, i, nbuckets, bloom_size, bloom_shift;
+    ElfW(Sym) *p, *q;
+    Section *vs;
+    Section *dynsym = s1->dynsym;
+    Elf32_Word *ptr, *buckets, *chain, *hash;
+    unsigned int *nextbuck;
+    addr_t *bloom;
+    unsigned char *strtab;
+    struct { int first, last; } *buck;
+
+    strtab = dynsym->link->data;
+    nb_syms = dynsym->data_offset / sizeof(ElfW(Sym));
+    new_syms = tcc_malloc(nb_syms * sizeof(ElfW(Sym)));
+    old_to_new_syms = tcc_malloc(nb_syms * sizeof(int));
+    hash = tcc_malloc(nb_syms * sizeof(Elf32_Word));
+    nextbuck = tcc_malloc(nb_syms * sizeof(int));
+
+    /* calculate hashes and copy undefs */
+    p = (ElfW(Sym) *)dynsym->data;
+    q = new_syms;
+    for(i = 0; i < nb_syms; i++, p++) {
+        if (p->st_shndx == SHN_UNDEF) {
+            old_to_new_syms[i] = q - new_syms;
+            *q++ = *p;
         }
+	else
+	    hash[i] = elf_gnu_hash(strtab + p->st_name);
+    }
+
+    ptr = (Elf32_Word *) gnu_hash->data;
+    nbuckets = ptr[0];
+    bloom_size = ptr[2];
+    bloom_shift = ptr[3];
+    bloom = (addr_t *) (void *) &ptr[4];
+    buckets = (Elf32_Word*) (void *) &bloom[bloom_size];
+    chain = &buckets[nbuckets];
+    buck = tcc_malloc(nbuckets * sizeof(*buck));
+
+    if (gnu_hash->data_offset != 4 * 4 +
+				 PTR_SIZE * bloom_size +
+				 nbuckets * 4 +
+				 (nb_syms - (q - new_syms)) * 4)
+	tcc_error_noabort ("gnu_hash size incorrect");
+
+    /* find buckets */
+    for(i = 0; i < nbuckets; i++)
+	buck[i].first = -1;
+
+    p = (ElfW(Sym) *)dynsym->data;
+    for(i = 0; i < nb_syms; i++, p++)
+        if (p->st_shndx != SHN_UNDEF) {
+	    int bucket = hash[i] % nbuckets;
+
+	    if (buck[bucket].first == -1)
+		buck[bucket].first = buck[bucket].last = i;
+	    else {
+		nextbuck[buck[bucket].last] = i;
+		buck[bucket].last = i;
+	    }
+	}
+
+    /* fill buckets/chains/bloom and sort symbols */
+    p = (ElfW(Sym) *)dynsym->data;
+    for(i = 0; i < nbuckets; i++) {
+	int cur = buck[i].first;
+
+	if (cur != -1) {
+	    buckets[i] = q - new_syms;
+	    for (;;) {
+                old_to_new_syms[cur] = q - new_syms;
+                *q++ = p[cur];
+	        *chain++ = hash[cur] & ~1;
+		bloom[(hash[cur] / ELFCLASS_BITS) % bloom_size] |=
+		    (addr_t)1 << (hash[cur] % ELFCLASS_BITS) |
+		    (addr_t)1 << ((hash[cur] >> bloom_shift) % ELFCLASS_BITS);
+		if (cur == buck[i].last)
+		    break;
+		cur = nextbuck[cur];
+	    }
+	    chain[-1] |= 1;
+	}
+    }
+
+    memcpy(dynsym->data, new_syms, nb_syms * sizeof(ElfW(Sym)));
+    tcc_free(new_syms);
+    tcc_free(hash);
+    tcc_free(buck);
+    tcc_free(nextbuck);
+
+    modify_reloctions_old_to_new(s1, dynsym, old_to_new_syms);
+
+    /* modify the versions */
+    vs = versym_section;
+    if (vs) {
+	ElfW(Half) *newver, *versym = (ElfW(Half) *)vs->data;
+
+	if (1/*versym*/) {
+            newver = tcc_malloc(nb_syms * sizeof(*newver));
+	    for (i = 0; i < nb_syms; i++)
+	        newver[old_to_new_syms[i]] = versym[i];
+	    memcpy(vs->data, newver, nb_syms * sizeof(*newver));
+	    tcc_free(newver);
+	}
     }
 
     tcc_free(old_to_new_syms);
+
+    /* rebuild hash */
+    ptr = (Elf32_Word *) dynsym->hash->data;
+    rebuild_hash(dynsym, ptr[0]);
 }
+#endif /* ELF_OBJ_ONLY */
 
 /* relocate symbol table, resolve undefined symbols if do_resolve is
    true and output error if undefined symbol. */
@@ -908,13 +1042,15 @@ ST_FUNC void relocate_syms(TCCState *s1, Section *symtab, int do_resolve)
     for_each_elem(symtab, 1, sym, ElfW(Sym)) {
         sh_num = sym->st_shndx;
         if (sh_num == SHN_UNDEF) {
+            if (do_resolve == 2) /* relocating dynsym */
+                continue;
             name = (char *) s1->symtab->link->data + sym->st_name;
             /* Use ld.so to resolve symbol for us (for tcc -run) */
             if (do_resolve) {
 #if defined TCC_IS_NATIVE && !defined TCC_TARGET_PE
                 /* dlsym() needs the undecorated name.  */
                 void *addr = dlsym(RTLD_DEFAULT, &name[s1->leading_underscore]);
-#if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD
+#if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD || TARGETOS_ANDROID
 		if (addr == NULL) {
 		    int i;
 		    for (i = 0; i < s1->nb_loaded_dlls; i++)
@@ -944,6 +1080,7 @@ ST_FUNC void relocate_syms(TCCState *s1, Section *symtab, int do_resolve)
                 sym->st_value = 0;
             else
                 tcc_error_noabort("undefined symbol '%s'", name);
+
         } else if (sh_num < SHN_LORESERVE) {
             /* add section base */
             sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
@@ -961,6 +1098,7 @@ static void relocate_section(TCCState *s1, Section *s, Section *sr)
     int type, sym_index;
     unsigned char *ptr;
     addr_t tgt, addr;
+    int is_dwarf = s->sh_num >= s1->dwlo && s->sh_num < s1->dwhi;
 
     qrel = (ElfW_Rel *)sr->data;
     for_each_elem(sr, 0, rel, ElfW_Rel) {
@@ -972,6 +1110,12 @@ static void relocate_section(TCCState *s1, Section *s, Section *sr)
 #if SHT_RELX == SHT_RELA
         tgt += rel->r_addend;
 #endif
+        if (is_dwarf && type == R_DATA_32DW
+            && sym->st_shndx >= s1->dwlo && sym->st_shndx < s1->dwhi) {
+            /* dwarf section relocation to each other */
+            add32le(ptr, tgt - s1->sections[sym->st_shndx]->sh_addr);
+            continue;
+        }
         addr = s->sh_addr + rel->r_offset;
         relocate(s1, rel, type, ptr, addr, tgt);
     }
@@ -979,12 +1123,16 @@ static void relocate_section(TCCState *s1, Section *s, Section *sr)
     /* if the relocation is allocated, we change its symbol table */
     if (sr->sh_flags & SHF_ALLOC) {
         sr->link = s1->dynsym;
-        if (s1->output_type == TCC_OUTPUT_DLL) {
+        if (s1->output_type & TCC_OUTPUT_DYN) {
             size_t r = (uint8_t*)qrel - sr->data;
             if (sizeof ((Stab_Sym*)0)->n_value < PTR_SIZE
                 && 0 == strcmp(s->name, ".stab"))
                 r = 0; /* cannot apply 64bit relocation to 32bit value */
             sr->data_offset = sr->sh_size = r;
+#ifdef CONFIG_TCC_PIE
+            if (r && 0 == (s->sh_flags & SHF_WRITE))
+                tcc_warning("%d relocations to ro-section %s", (unsigned)(r / sizeof *qrel), s->name);
+#endif
         }
     }
 #endif
@@ -1064,7 +1212,6 @@ static int prepare_dynamic_rel(TCCState *s1, Section *sr)
         case R_X86_64_PC32:
 	{
 	    ElfW(Sym) *sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
-
             /* Hidden defined symbols can and must be resolved locally.
                We're misusing a PLT32 reloc for this, as that's always
                resolved to its address even in shared libs.  */
@@ -1077,6 +1224,8 @@ static int prepare_dynamic_rel(TCCState *s1, Section *sr)
 #elif defined(TCC_TARGET_ARM64)
         case R_AARCH64_PREL32:
 #endif
+            if (s1->output_type != TCC_OUTPUT_DLL)
+                break;
             if (get_sym_attr(s1, sym_index, 0)->dyn_index)
                 count++;
             break;
@@ -1089,16 +1238,16 @@ static int prepare_dynamic_rel(TCCState *s1, Section *sr)
 }
 #endif
 
-#if !defined(ELF_OBJ_ONLY) || (defined(TCC_TARGET_MACHO) && defined TCC_IS_NATIVE)
-static void build_got(TCCState *s1)
+#ifdef NEED_BUILD_GOT
+static int build_got(TCCState *s1)
 {
     /* if no got, then create it */
     s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
     s1->got->sh_entsize = 4;
-    set_elf_sym(symtab_section, 0, 4, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
-                0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
     /* keep space for _DYNAMIC pointer and two dummy got entries */
     section_ptr_add(s1->got, 3 * PTR_SIZE);
+    return set_elf_sym(symtab_section, 0, 0, ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT),
+        0, s1->got->sh_num, "_GLOBAL_OFFSET_TABLE_");
 }
 
 /* Create a GOT and (for function call) a PLT entry corresponding to a symbol
@@ -1113,7 +1262,7 @@ static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
     ElfW(Sym) *sym;
     struct sym_attr *attr;
     unsigned got_offset;
-    char plt_name[100];
+    char plt_name[200];
     int len;
     Section *s_rel;
 
@@ -1191,7 +1340,7 @@ static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
             len = sizeof plt_name - 5;
         memcpy(plt_name, name, len);
         strcpy(plt_name + len, "@plt");
-        attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, sym->st_size,
+        attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, 0,
             ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0, s1->plt->sh_num, plt_name);
     } else {
         attr->got_offset = got_offset;
@@ -1203,7 +1352,7 @@ static struct sym_attr * put_got_entry(TCCState *s1, int dyn_reloc_type,
 /* build GOT and PLT entries */
 /* Two passes because R_JMP_SLOT should become first. Some targets
    (arm, arm64) do not allow mixing R_JMP_SLOT and R_GLOB_DAT. */
-ST_FUNC void build_got_entries(TCCState *s1)
+ST_FUNC void build_got_entries(TCCState *s1, int got_sym)
 {
     Section *s;
     ElfW_Rel *rel;
@@ -1211,7 +1360,6 @@ ST_FUNC void build_got_entries(TCCState *s1)
     int i, type, gotplt_entry, reloc_type, sym_index;
     struct sym_attr *attr;
     int pass = 0;
-
 redo:
     for(i = 1; i < s1->nb_sections; i++) {
         s = s1->sections[i];
@@ -1223,8 +1371,10 @@ ST_FUNC void build_got_entries(TCCState *s1)
         for_each_elem(s, 0, rel, ElfW_Rel) {
             type = ELFW(R_TYPE)(rel->r_info);
             gotplt_entry = gotplt_entry_type(type);
-            if (gotplt_entry == -1)
-                tcc_error ("Unknown relocation type for got: %d", type);
+            if (gotplt_entry == -1) {
+                tcc_error_noabort ("Unknown relocation type for got: %d", type);
+                continue;
+            }
             sym_index = ELFW(R_SYM)(rel->r_info);
             sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
 
@@ -1240,7 +1390,8 @@ ST_FUNC void build_got_entries(TCCState *s1)
                 if (sym->st_shndx == SHN_UNDEF) {
                     ElfW(Sym) *esym;
 		    int dynindex;
-                    if (s1->output_type == TCC_OUTPUT_DLL && ! PCRELATIVE_DLLPLT)
+                    if (!PCRELATIVE_DLLPLT
+                        && (s1->output_type & TCC_OUTPUT_DYN))
                         continue;
 		    /* Relocations for UNDEF symbols would normally need
 		       to be transferred into the executable or shared object.
@@ -1280,7 +1431,7 @@ ST_FUNC void build_got_entries(TCCState *s1)
 		sym->st_shndx != SHN_UNDEF &&
                 (ELFW(ST_VISIBILITY)(sym->st_other) != STV_DEFAULT ||
 		 ELFW(ST_BIND)(sym->st_info) == STB_LOCAL ||
-		 s1->output_type == TCC_OUTPUT_EXE)) {
+		 s1->output_type & TCC_OUTPUT_EXE)) {
 		if (pass != 0)
 		    continue;
                 rel->r_info = ELFW(R_INFO)(sym_index, R_X86_64_PC32);
@@ -1288,8 +1439,10 @@ ST_FUNC void build_got_entries(TCCState *s1)
             }
 #endif
             reloc_type = code_reloc(type);
-            if (reloc_type == -1)
-                tcc_error ("Unknown relocation type: %d", type);
+            if (reloc_type == -1) {
+                tcc_error_noabort ("Unknown relocation type: %d", type);
+                continue;
+            }
 
             if (reloc_type != 0) {
         jmp_slot:
@@ -1303,7 +1456,7 @@ ST_FUNC void build_got_entries(TCCState *s1)
             }
 
             if (!s1->got)
-                build_got(s1);
+                got_sym = build_got(s1);
 
             if (gotplt_entry == BUILD_GOT_ONLY)
                 continue;
@@ -1316,13 +1469,13 @@ ST_FUNC void build_got_entries(TCCState *s1)
     }
     if (++pass < 2)
         goto redo;
-
     /* .rel.plt refers to .got actually */
     if (s1->plt && s1->plt->reloc)
         s1->plt->reloc->sh_info = s1->got->sh_num;
-
+    if (got_sym) /* set size */
+        ((ElfW(Sym)*)symtab_section->data)[got_sym].st_size = s1->got->data_offset;
 }
-#endif
+#endif /* def NEED_BUILD_GOT */
 
 ST_FUNC int set_global_sym(TCCState *s1, const char *name, Section *sec, addr_t offs)
 {
@@ -1338,8 +1491,8 @@ static void add_init_array_defines(TCCState *s1, const char *section_name)
     Section *s;
     addr_t end_offset;
     char buf[1024];
-    s = find_section_create(s1, section_name, 0);
-    if (!s) {
+    s = have_section(s1, section_name);
+    if (!s || !(s->sh_flags & SHF_ALLOC)) {
         end_offset = 0;
         s = data_section;
     } else {
@@ -1351,23 +1504,12 @@ static void add_init_array_defines(TCCState *s1, const char *section_name)
     set_global_sym(s1, buf, s, end_offset);
 }
 
-#ifndef TCC_TARGET_PE
-static void tcc_add_support(TCCState *s1, const char *filename)
-{
-    char buf[1024];
-    snprintf(buf, sizeof(buf), "%s/%s", s1->tcc_lib_path, filename);
-    tcc_add_file(s1, buf);
-}
-#endif
-
 ST_FUNC void add_array (TCCState *s1, const char *sec, int c)
 {
     Section *s;
     s = find_section(s1, sec);
-    s->sh_flags |= SHF_WRITE;
-#ifndef TCC_TARGET_PE
+    s->sh_flags = shf_RELRO;
     s->sh_type = sec[1] == 'i' ? SHT_INIT_ARRAY : SHT_FINI_ARRAY;
-#endif
     put_elf_reloc (s1->symtab, s, s->data_offset, R_DATA_PTR, c);
     section_ptr_add(s, PTR_SIZE);
 }
@@ -1394,6 +1536,19 @@ static void set_local_sym(TCCState *s1, const char *name, Section *s, int offset
     }
 }
 
+/* avoid generating debug/test_coverage code for stub functions */
+static void tcc_compile_string_no_debug(TCCState *s, const char *str)
+{
+    int save_do_debug = s->do_debug;
+    int save_test_coverage = s->test_coverage;
+
+    s->do_debug = 0;
+    s->test_coverage = 0;
+    tcc_compile_string(s, str);
+    s->do_debug = save_do_debug;
+    s->test_coverage = save_test_coverage;
+}
+
 #ifdef CONFIG_TCC_BACKTRACE
 static void put_ptr(TCCState *s1, Section *s, int offs)
 {
@@ -1415,12 +1570,31 @@ ST_FUNC void tcc_add_btstub(TCCState *s1)
     section_ptr_add(s, -s->data_offset & (PTR_SIZE - 1));
     o = s->data_offset;
     /* create (part of) a struct rt_context (see tccrun.c) */
-    put_ptr(s1, stab_section, 0);
-    put_ptr(s1, stab_section, -1);
-    put_ptr(s1, stab_section->link, 0);
+    if (s1->dwarf) {
+        put_ptr(s1, dwarf_line_section, 0);
+        put_ptr(s1, dwarf_line_section, -1);
+	if (s1->dwarf >= 5)
+            put_ptr(s1, dwarf_line_str_section, 0);
+	else
+            put_ptr(s1, dwarf_str_section, 0);
+    }
+    else
+    {
+        put_ptr(s1, stab_section, 0);
+        put_ptr(s1, stab_section, -1);
+        put_ptr(s1, stab_section->link, 0);
+    }
+    *(addr_t *)section_ptr_add(s, PTR_SIZE) = s1->dwarf;
+    /* skip esym_start/esym_end/elf_str (not loaded) */
     section_ptr_add(s, 3 * PTR_SIZE);
     /* prog_base : local nameless symbol with offset 0 at SHN_ABS */
     put_ptr(s1, NULL, 0);
+#if defined TCC_TARGET_MACHO
+    /* adjust for __PAGEZERO */
+    if (s1->dwarf == 0 && s1->output_type == TCC_OUTPUT_EXE)
+        write64le(data_section->data + data_section->data_offset - PTR_SIZE,
+	          (uint64_t)1 << 32);
+#endif
     n = 2 * PTR_SIZE;
 #ifdef CONFIG_TCC_BCHECK
     if (s1->do_bounds_check) {
@@ -1431,7 +1605,7 @@ ST_FUNC void tcc_add_btstub(TCCState *s1)
     section_ptr_add(s, n);
     cstr_new(&cstr);
     cstr_printf(&cstr,
-        "extern void __bt_init(),__bt_init_dll();"
+        "extern void __bt_init(),__bt_exit(),__bt_init_dll();"
         "static void *__rt_info[];"
         "__attribute__((constructor)) static void __bt_init_rt(){");
 #ifdef TCC_TARGET_PE
@@ -1444,11 +1618,15 @@ ST_FUNC void tcc_add_btstub(TCCState *s1)
 #endif
     cstr_printf(&cstr, "__bt_init(__rt_info,%d);}",
         s1->output_type == TCC_OUTPUT_DLL ? 0 : s1->rt_num_callers + 1);
-    tcc_compile_string(s1, cstr.data);
+    /* In case dlcose is called by application */
+    cstr_printf(&cstr,
+        "__attribute__((destructor)) static void __bt_exit_rt(){"
+        "__bt_exit(__rt_info);}");
+    tcc_compile_string_no_debug(s1, cstr.data);
     cstr_free(&cstr);
     set_local_sym(s1, &"___rt_info"[!s1->leading_underscore], s, o);
 }
-#endif
+#endif /* def CONFIG_TCC_BACKTRACE */
 
 static void tcc_tcov_add_file(TCCState *s1, const char *filename)
 {
@@ -1483,7 +1661,7 @@ static void tcc_tcov_add_file(TCCState *s1, const char *filename)
         "__attribute__((destructor)) static void __tcov_exit() {"
         "__store_test_coverage(__tcov_data);"
         "}");
-    tcc_compile_string(s1, cstr.data);
+    tcc_compile_string_no_debug(s1, cstr.data);
     cstr_free(&cstr);
     set_local_sym(s1, &"___tcov_data"[!s1->leading_underscore], tcov_section, 0);
 }
@@ -1493,71 +1671,79 @@ static void tcc_tcov_add_file(TCCState *s1, const char *filename)
 ST_FUNC void tcc_add_runtime(TCCState *s1)
 {
     s1->filetype = 0;
+
 #ifdef CONFIG_TCC_BCHECK
     tcc_add_bcheck(s1);
 #endif
     tcc_add_pragma_libs(s1);
+
     /* add libc */
     if (!s1->nostdlib) {
-        if (s1->option_pthread)
-            tcc_add_library_err(s1, "pthread");
-        tcc_add_library_err(s1, "c");
-#ifdef TCC_LIBGCC
-        if (!s1->static_link) {
-            if (TCC_LIBGCC[0] == '/')
-                tcc_add_file(s1, TCC_LIBGCC);
-            else
-                tcc_add_dll(s1, TCC_LIBGCC, 0);
-        }
-#endif
-#if TCC_TARGET_ARM && TARGETOS_FreeBSD
-        tcc_add_library_err(s1, "gcc_s"); // unwind code
-#endif
+        int lpthread = s1->option_pthread;
+
 #ifdef CONFIG_TCC_BCHECK
         if (s1->do_bounds_check && s1->output_type != TCC_OUTPUT_DLL) {
-            tcc_add_library_err(s1, "pthread");
-#if !TARGETOS_OpenBSD && !TARGETOS_NetBSD
-            tcc_add_library_err(s1, "dl");
-#endif
             tcc_add_support(s1, "bcheck.o");
-	    if (s1->static_link)
-                tcc_add_library_err(s1, "c");
+# if !(TARGETOS_OpenBSD || TARGETOS_NetBSD)
+            tcc_add_library_err(s1, "dl");
+# endif
+            lpthread = 1;
         }
 #endif
 #ifdef CONFIG_TCC_BACKTRACE
         if (s1->do_backtrace) {
-            if (s1->output_type == TCC_OUTPUT_EXE)
+            if (s1->output_type & TCC_OUTPUT_EXE)
                 tcc_add_support(s1, "bt-exe.o");
             if (s1->output_type != TCC_OUTPUT_DLL)
                 tcc_add_support(s1, "bt-log.o");
             if (s1->output_type != TCC_OUTPUT_MEMORY)
                 tcc_add_btstub(s1);
         }
+#endif
+        if (lpthread)
+            tcc_add_library_err(s1, "pthread");
+        tcc_add_library_err(s1, "c");
+#ifdef TCC_LIBGCC
+        if (!s1->static_link) {
+            if (TCC_LIBGCC[0] == '/')
+                tcc_add_file(s1, TCC_LIBGCC);
+            else
+                tcc_add_dll(s1, TCC_LIBGCC, 0);
+        }
+#endif
+#if defined TCC_TARGET_ARM && TARGETOS_FreeBSD
+        tcc_add_library_err(s1, "gcc_s"); // unwind code
 #endif
         if (TCC_LIBTCC1[0])
             tcc_add_support(s1, TCC_LIBTCC1);
 
-#if !defined TCC_TARGET_PE && !defined TCC_TARGET_MACHO
-#if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD
         /* add crt end if not memory output */
 	if (s1->output_type != TCC_OUTPUT_MEMORY) {
+#if defined TCC_TARGET_MACHO
+            /* nothing to do */
+#elif TARGETOS_FreeBSD || TARGETOS_NetBSD
+	    if (s1->output_type & TCC_OUTPUT_DYN)
+	        tcc_add_crt(s1, "crtendS.o");
+	    else
+	        tcc_add_crt(s1, "crtend.o");
+            tcc_add_crt(s1, "crtn.o");
+#elif TARGETOS_OpenBSD
 	    if (s1->output_type == TCC_OUTPUT_DLL)
 	        tcc_add_crt(s1, "crtendS.o");
 	    else
 	        tcc_add_crt(s1, "crtend.o");
-#if TARGETOS_FreeBSD || TARGETOS_NetBSD
+#elif TARGETOS_ANDROID
+	    if (s1->output_type == TCC_OUTPUT_DLL)
+                tcc_add_crt(s1, "crtend_so.o");
+            else
+                tcc_add_crt(s1, "crtend_android.o");
+#else
             tcc_add_crt(s1, "crtn.o");
 #endif
         }
-#elif !defined(TCC_TARGET_MACHO)
-        /* add crt end if not memory output */
-        if (s1->output_type != TCC_OUTPUT_MEMORY)
-            tcc_add_crt(s1, "crtn.o");
-#endif
-#endif
     }
 }
-#endif
+#endif /* ndef TCC_TARGET_PE */
 
 /* add various standard linker symbols (must be done after the
    sections are filled (for example after allocating common
@@ -1579,9 +1765,7 @@ static void tcc_add_linker_symbols(TCCState *s1)
     set_global_sym(s1, "__global_pointer$", data_section, 0x800);
 #endif
     /* horrible new standard ldscript defines */
-#ifndef TCC_TARGET_PE
     add_init_array_defines(s1, ".preinit_array");
-#endif
     add_init_array_defines(s1, ".init_array");
     add_init_array_defines(s1, ".fini_array");
     /* add start and stop symbols for sections whose name can be
@@ -1630,7 +1814,6 @@ ST_FUNC void resolve_common_syms(TCCState *s1)
 }
 
 #ifndef ELF_OBJ_ONLY
-
 ST_FUNC void fill_got_entry(TCCState *s1, ElfW_Rel *rel)
 {
     int sym_index = ELFW(R_SYM) (rel->r_info);
@@ -1690,7 +1873,7 @@ static void fill_local_got_entries(TCCState *s1)
 	    struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
 	    unsigned offset = attr->got_offset;
 	    if (offset != rel->r_offset - s1->got->sh_addr)
-	      tcc_error_noabort("huh");
+	        tcc_error_noabort("fill_local_got_entries: huh?");
 	    rel->r_info = ELFW(R_INFO)(0, R_RELATIVE);
 #if SHT_RELX == SHT_RELA
 	    rel->r_addend = sym->st_value;
@@ -1703,9 +1886,8 @@ static void fill_local_got_entries(TCCState *s1)
 }
 
 /* Bind symbols of executable: resolve undefined symbols from exported symbols
-   in shared libraries and export non local defined symbols to shared libraries
-   if -rdynamic switch was given on command line */
-static void bind_exe_dynsyms(TCCState *s1)
+   in shared libraries */
+static void bind_exe_dynsyms(TCCState *s1, int is_PIE)
 {
     const char *name;
     int sym_index, index;
@@ -1720,6 +1902,8 @@ static void bind_exe_dynsyms(TCCState *s1)
             name = (char *) symtab_section->link->data + sym->st_name;
             sym_index = find_elf_sym(s1->dynsymtab_section, name);
             if (sym_index) {
+                if (is_PIE)
+                    continue;
                 esym = &((ElfW(Sym) *)s1->dynsymtab_section->data)[sym_index];
                 type = ELFW(ST_TYPE)(esym->st_info);
                 if ((type == STT_FUNC) || (type == STT_GNU_IFUNC)) {
@@ -1777,11 +1961,6 @@ static void bind_exe_dynsyms(TCCState *s1)
                     tcc_error_noabort("undefined symbol '%s'", name);
                 }
             }
-        } else if (s1->rdynamic && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
-            /* if -rdynamic option, then export all non local symbols */
-            name = (char *) symtab_section->link->data + sym->st_name;
-            set_elf_sym(s1->dynsym, sym->st_value, sym->st_size, sym->st_info,
-                        0, sym->st_shndx, name);
         }
     }
 }
@@ -1790,25 +1969,28 @@ static void bind_exe_dynsyms(TCCState *s1)
    are referenced by shared libraries. The reason is that the dynamic loader
    search symbol first in executable and then in libraries. Therefore a
    reference to a symbol already defined by a library can still be resolved by
-   a symbol in the executable. */
+   a symbol in the executable.   With -rdynamic, export all defined symbols */
 static void bind_libs_dynsyms(TCCState *s1)
 {
     const char *name;
-    int sym_index;
+    int dynsym_index;
     ElfW(Sym) *sym, *esym;
 
-    for_each_elem(s1->dynsymtab_section, 1, esym, ElfW(Sym)) {
-        name = (char *) s1->dynsymtab_section->link->data + esym->st_name;
-        sym_index = find_elf_sym(symtab_section, name);
-        sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
-        if (sym_index && sym->st_shndx != SHN_UNDEF
-            && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
-            set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
-                sym->st_info, 0, sym->st_shndx, name);
-        } else if (esym->st_shndx == SHN_UNDEF) {
-            /* weak symbols can stay undefined */
-            if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
-                tcc_warning("undefined dynamic symbol '%s'", name);
+    for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
+        name = (char *)symtab_section->link->data + sym->st_name;
+        dynsym_index = find_elf_sym(s1->dynsymtab_section, name);
+        if (sym->st_shndx != SHN_UNDEF) {
+            if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL
+                && (dynsym_index || s1->rdynamic))
+                set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
+                            sym->st_info, 0, sym->st_shndx, name);
+        } else if (dynsym_index) {
+            esym = (ElfW(Sym) *)s1->dynsymtab_section->data + dynsym_index;
+            if (esym->st_shndx == SHN_UNDEF) {
+                /* weak symbols can stay undefined */
+                if (ELFW(ST_BIND)(esym->st_info) != STB_WEAK)
+                    tcc_warning("undefined dynamic symbol '%s'", name);
+            }
         }
     }
 }
@@ -1822,11 +2004,10 @@ static void export_global_syms(TCCState *s1)
     int dynindex, index;
     const char *name;
     ElfW(Sym) *sym;
-
     for_each_elem(symtab_section, 1, sym, ElfW(Sym)) {
         if (ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
 	    name = (char *) symtab_section->link->data + sym->st_name;
-	    dynindex = put_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
+	    dynindex = set_elf_sym(s1->dynsym, sym->st_value, sym->st_size,
 				   sym->st_info, 0, sym->st_shndx, name);
 	    index = sym - (ElfW(Sym) *) symtab_section->data;
             get_sym_attr(s1, index, 1)->dyn_index = dynindex;
@@ -1848,7 +2029,7 @@ static int set_sec_sizes(TCCState *s1)
         if (s->sh_type == SHT_RELX && !(s->sh_flags & SHF_ALLOC)) {
             /* when generating a DLL, we include relocations but
                we may patch them */
-            if (file_type == TCC_OUTPUT_DLL
+            if ((file_type & TCC_OUTPUT_DYN)
                 && (s1->sections[s->sh_info]->sh_flags & SHF_ALLOC)) {
                 int count = prepare_dynamic_rel(s1, s);
                 if (count) {
@@ -1856,7 +2037,7 @@ static int set_sec_sizes(TCCState *s1)
                     s->sh_flags |= SHF_ALLOC;
                     s->sh_size = count * sizeof(ElfW_Rel);
                     if (!(s1->sections[s->sh_info]->sh_flags & SHF_WRITE))
-                        textrel = 1;
+                        textrel += count;
                 }
             }
         } else if ((s->sh_flags & SHF_ALLOC)
@@ -1879,59 +2060,179 @@ static int set_sec_sizes(TCCState *s1)
     return textrel;
 }
 
-
-/* Info to be copied in dynamic section */
+/* various data used under elf_output_file() */
 struct dyn_inf {
     Section *dynamic;
     Section *dynstr;
-    unsigned long data_offset;
-    addr_t rel_addr;
-    addr_t rel_size;
-};
+    struct {
+        /* Info to be copied in dynamic section */
+        unsigned long data_offset;
+        addr_t rel_addr;
+        addr_t rel_size;
+    };
+
+    ElfW(Phdr) *phdr;
+    int phnum;
+    Section *interp;
+    Section *note;
+    Section *gnu_hash;
 
-/* Info for GNU_RELRO */
-struct ro_inf {
-   addr_t sh_offset;
-   addr_t sh_addr;
-   addr_t sh_size;
+    /* read only segment mapping for GNU_RELRO */
+    Section _roinf, *roinf;
 };
 
-static void alloc_sec_names(
-    TCCState *s1, int is_obj
-    );
+/* Decide the layout of sections loaded in memory. This must be done before
+   program headers are filled since they contain info about the layout.
+   We do the following ordering: interp, symbol tables, relocations, progbits,
+   nobits */
+static int sort_sections(TCCState *s1, int *sec_order, Section *interp)
+{
+    Section *s;
+    int i, j, k, f, f0, n;
+    int nb_sections = s1->nb_sections;
+    int *sec_cls = sec_order + nb_sections;
+
+    for (i = 1; i < nb_sections; i++) {
+        s = s1->sections[i];
+        if (s->sh_flags & SHF_ALLOC) {
+            j = 0x100;
+            if (s->sh_flags & SHF_WRITE)
+                j = 0x200;
+            if (s->sh_flags & SHF_TLS)
+                j += 0x200;
+        } else if (s->sh_name) {
+            j = 0x700;
+        } else {
+            j = 0x900; /* no sh_name: won't go to file */
+        }
+        if (s->sh_type == SHT_SYMTAB || s->sh_type == SHT_DYNSYM) {
+            k = 0x10;
+        } else if (s->sh_type == SHT_STRTAB && strcmp(s->name, ".stabstr")) {
+            k = 0x11;
+            if (i == nb_sections - 1) /* ".shstrtab" assumed to remain last */
+                k = 0xff;
+        } else if (s->sh_type == SHT_HASH || s->sh_type == SHT_GNU_HASH) {
+            k = 0x12;
+        } else if (s->sh_type == SHT_RELX) {
+            k = 0x20;
+            if (s1->plt && s == s1->plt->reloc)
+                k = 0x21;
+        } else if (s->sh_type == SHT_PREINIT_ARRAY) {
+            k = 0x41;
+        } else if (s->sh_type == SHT_INIT_ARRAY) {
+            k = 0x42;
+        } else if (s->sh_type == SHT_FINI_ARRAY) {
+            k = 0x43;
+#ifdef CONFIG_TCC_BCHECK
+        } else if (s == bounds_section || s == lbounds_section) {
+            k = 0x44;
+#endif
+        } else if (s == rodata_section || 0 == strcmp(s->name, ".data.rel.ro")) {
+            k = 0x45;
+        } else if (s->sh_type == SHT_DYNAMIC) {
+            k = 0x46;
+        } else if (s == s1->got) {
+            k = 0x47; /* .got as RELRO needs BIND_NOW in DT_FLAGS */
+        } else {
+            k = 0x50;
+            if (s->sh_type == SHT_NOTE)
+                k = 0x60;
+            if (s->sh_flags & SHF_EXECINSTR)
+                k = 0x70;
+            if (s->sh_type == SHT_NOBITS)
+                k = 0x80;
+            if (s == interp)
+                k = 0x00;
+        }
+        k += j;
 
-static int layout_any_sections(
-    TCCState *s1, int file_offset, int *sec_order, int is_obj
-    );
+        for (n = i; n > 1 && k < (f = sec_cls[n - 1]); --n)
+            sec_cls[n] = f, sec_order[n] = sec_order[n - 1];
+        sec_cls[n] = k, sec_order[n] = i;
+    }
+    sec_order[0] = 0;
+
+    /* count PT_LOAD headers needed */
+    n = f0 = 0;
+    for (i = 1; i < nb_sections; i++) {
+        s = s1->sections[sec_order[i]];
+        k = sec_cls[i];
+        f = 0;
+        if (k < 0x700) {
+            f = s->sh_flags & (SHF_ALLOC|SHF_WRITE|SHF_EXECINSTR|SHF_TLS);
+#if TARGETOS_NetBSD
+	    /* NetBSD only supports 2 PT_LOAD sections.
+	       See: https://blog.netbsd.org/tnf/entry/the_first_report_on_lld */
+	    if ((f & SHF_WRITE) == 0) f |= SHF_EXECINSTR;
+#else
+            if ((k & 0xfff0) == 0x240) /* RELRO sections */
+                f |= 1<<4;
+#endif
+            if (f != f0) /* start new header when flags changed or relro */
+                f0 = f, ++n, f |= 1<<8;
+        }
+        sec_cls[i] = f;
+        //printf("ph %d sec %02d : %3X %3X  %8.2X  %04X  %s\n", !!f * n, i, f, k, s->sh_type, s->sh_size, s->name);
+    }
+    return n;
+}
+
+static ElfW(Phdr) *fill_phdr(ElfW(Phdr) *ph, int type, Section *s)
+{
+    if (s) {
+        ph->p_offset = s->sh_offset;
+        ph->p_vaddr = s->sh_addr;
+        ph->p_filesz = s->sh_size;
+        ph->p_align = s->sh_addralign;
+    }
+    ph->p_type = type;
+    ph->p_flags = PF_R;
+    ph->p_paddr = ph->p_vaddr;
+    ph->p_memsz = ph->p_filesz;
+    return ph;
+}
 
 /* Assign sections to segments and decide how are sections laid out when loaded
    in memory. This function also fills corresponding program headers. */
-static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr,
-			   int phnum, int phfill,
-                           Section *interp,
-                           struct ro_inf *roinf, int *sec_order)
+static int layout_sections(TCCState *s1, int *sec_order, struct dyn_inf *d)
 {
-    int i, file_offset;
     Section *s;
+    addr_t addr, tmp, align, s_align, base;
+    ElfW(Phdr) *ph = NULL;
+    int i, f, n, phnum, phfill;
+    int file_offset;
+
+    /* compute number of program headers */
+    phnum = sort_sections(s1, sec_order, d->interp);
+    phfill = 0; /* set to 1 to have dll's with a PT_PHDR */
+    if (d->interp)
+        phfill = 2;
+    phnum += phfill;
+    if (d->note)
+        ++phnum;
+    if (d->dynamic)
+        ++phnum;
+    if (d->roinf)
+        ++phnum;
+    d->phnum = phnum;
+    d->phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
 
     file_offset = 0;
     if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
         file_offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
 
-    {
-        unsigned long s_align;
-        long long tmp;
-        addr_t addr;
-        ElfW(Phdr) *ph;
-        int j, k, f, file_type = s1->output_type;
+    s_align = ELF_PAGE_SIZE;
+    if (s1->section_align)
+        s_align = s1->section_align;
 
-        s_align = ELF_PAGE_SIZE;
-        if (s1->section_align)
-            s_align = s1->section_align;
+    addr = ELF_START_ADDR;
+    if (s1->output_type & TCC_OUTPUT_DYN)
+        addr = 0;
 
-        if (s1->has_text_addr) {
+    if (s1->has_text_addr) {
+        addr = s1->text_addr;
+        if (0) {
             int a_offset, p_offset;
-            addr = s1->text_addr;
             /* we ensure that (addr % ELF_PAGE_SIZE) == file_offset %
                ELF_PAGE_SIZE */
             a_offset = (int) (addr & (s_align - 1));
@@ -1939,151 +2240,109 @@ static int layout_sections(TCCState *s1, ElfW(Phdr) *phdr,
             if (a_offset < p_offset)
                 a_offset += s_align;
             file_offset += (a_offset - p_offset);
-        } else {
-            if (file_type == TCC_OUTPUT_DLL)
-                addr = 0;
-            else
-                addr = ELF_START_ADDR;
-            /* compute address after headers */
-            addr += (file_offset & (s_align - 1));
         }
+    }
+    base = addr;
+    /* compute address after headers */
+    addr = addr + (file_offset & (s_align - 1));
 
-        ph = &phdr[0];
-        /* Leave one program headers for the program interpreter and one for
-           the program header table itself if needed. These are done later as
-           they require section layout to be done first. */
-        if (interp)
-            ph += 2;
-
-        /* read only segment mapping for GNU_RELRO */
-	roinf->sh_offset = roinf->sh_addr = roinf->sh_size = 0;
-
-        for(j = 0; j < phfill; j++) {
-            ph->p_type = j == 2 ? PT_TLS : PT_LOAD;
-            if (j == 0)
-                ph->p_flags = PF_R | PF_X;
-            else
-                ph->p_flags = PF_R | PF_W;
-            ph->p_align = j == 2 ? 4 : s_align;
-
-            /* Decide the layout of sections loaded in memory. This must
-               be done before program headers are filled since they contain
-               info about the layout. We do the following ordering: interp,
-               symbol tables, relocations, progbits, nobits */
-            /* XXX: do faster and simpler sorting */
-	    f = -1;
-            for(k = 0; k < 7; k++) {
-                for(i = 1; i < s1->nb_sections; i++) {
-                    s = s1->sections[i];
-                    /* compute if section should be included */
-                    if (j == 0) {
-                        if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_TLS)) !=
-                            SHF_ALLOC)
-                            continue;
-                    } else if (j == 1) {
-                        if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_TLS)) !=
-                            (SHF_ALLOC | SHF_WRITE))
-                            continue;
-                    } else  {
-                        if ((s->sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_TLS)) !=
-                            (SHF_ALLOC | SHF_WRITE | SHF_TLS))
-                            continue;
-                    }
-                    if (s == interp) {
-                        if (k != 0)
-                            continue;
-                    } else if ((s->sh_type == SHT_DYNSYM ||
-                                s->sh_type == SHT_STRTAB ||
-                                s->sh_type == SHT_HASH)
-                               && !strstr(s->name, ".stab"))  {
-                        if (k != 1)
-                            continue;
-                    } else if (s->sh_type == SHT_RELX) {
-                        if (s1->plt && s == s1->plt->reloc) {
-                            if (k != 3)
-                                continue;
-                        } else {
-                            if (k != 2)
-                                continue;
-                        }
-                    } else if (s->sh_type == SHT_NOBITS) {
-                        if (k != 6)
-                            continue;
-                    } else if ((s == rodata_section
-#ifdef CONFIG_TCC_BCHECK
-		                || s == bounds_section
-                                || s == lbounds_section
-#endif
-                                ) && (s->sh_flags & SHF_WRITE)) {
-                        if (k != 4)
-                            continue;
-			/* Align next section on page size.
-			   This is needed to remap roinf section ro. */
-			f = 1;
-                    } else {
-                        if (k != 5)
-                            continue;
-		    }
-                    *sec_order++ = i;
-
-                    /* section matches: we align it and add its size */
-                    tmp = addr;
-		    if (f-- == 0)
-			s->sh_addralign = PAGESIZE;
-                    addr = (addr + s->sh_addralign - 1) &
-                        ~(s->sh_addralign - 1);
-                    file_offset += (int) ( addr - tmp );
-                    s->sh_offset = file_offset;
-                    s->sh_addr = addr;
-
-                    /* update program header infos */
-                    if (ph->p_offset == 0) {
-                        ph->p_offset = file_offset;
-                        ph->p_vaddr = addr;
-                        ph->p_paddr = ph->p_vaddr;
-                    }
+    n = 0;
+    for(i = 1; i < s1->nb_sections; i++) {
+        s = s1->sections[sec_order[i]];
+        f = sec_order[i + s1->nb_sections];
+        align = s->sh_addralign - 1;
+
+        if (f == 0) { /* no alloc */
+            file_offset = (file_offset + align) & ~align;
+            s->sh_offset = file_offset;
+            if (s->sh_type != SHT_NOBITS)
+                file_offset += s->sh_size;
+            continue;
+        }
 
-                    if (k == 4) {
-                        if (roinf->sh_size == 0) {
-                            roinf->sh_offset = s->sh_offset;
-                            roinf->sh_addr = s->sh_addr;
-			}
-                        roinf->sh_size = (addr - roinf->sh_addr) + s->sh_size;
-		    }
+        if ((f & 1<<8) && n) {
+            /* different rwx section flags */
+            if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
+                /* if in the middle of a page, w e duplicate the page in
+                   memory so that one copy is RX and the other is RW */
+                if ((addr & (s_align - 1)) != 0)
+                    addr += s_align;
+            } else {
+                align = s_align - 1;
+            }
+        }
 
-                    addr += s->sh_size;
-                    if (s->sh_type != SHT_NOBITS)
-                        file_offset += s->sh_size;
-                }
+        tmp = addr;
+        addr = (addr + align) & ~align;
+        file_offset += (int)(addr - tmp);
+        s->sh_offset = file_offset;
+        s->sh_addr = addr;
+
+        if (f & 1<<8) {
+            /* set new program header */
+            ph = &d->phdr[phfill + n];
+            ph->p_type = PT_LOAD;
+            ph->p_align = s_align;
+            ph->p_flags = PF_R;
+            if (f & SHF_WRITE)
+                ph->p_flags |= PF_W;
+            if (f & SHF_EXECINSTR)
+                ph->p_flags |= PF_X;
+            if (f & SHF_TLS) {
+                ph->p_type = PT_TLS;
+                ph->p_align = align + 1;
             }
-	    if (j == 0) {
+
+            ph->p_offset = file_offset;
+            ph->p_vaddr = addr;
+            if (n == 0) {
 		/* Make the first PT_LOAD segment include the program
 		   headers itself (and the ELF header as well), it'll
 		   come out with same memory use but will make various
 		   tools like binutils strip work better.  */
-		ph->p_offset &= ~(ph->p_align - 1);
-		ph->p_vaddr &= ~(ph->p_align - 1);
-		ph->p_paddr &= ~(ph->p_align - 1);
-	    }
-            ph->p_filesz = file_offset - ph->p_offset;
-            ph->p_memsz = addr - ph->p_vaddr;
-            ph++;
-            if (j == 0) {
-                if (s1->output_format == TCC_OUTPUT_FORMAT_ELF) {
-                    /* if in the middle of a page, we duplicate the page in
-                       memory so that one copy is RX and the other is RW */
-                    if ((addr & (s_align - 1)) != 0)
-                        addr += s_align;
-                } else {
-                    addr = (addr + s_align - 1) & ~(s_align - 1);
-                    file_offset = (file_offset + s_align - 1) & ~(s_align - 1);
-                }
+		ph->p_offset = 0;
+		ph->p_vaddr = base;
             }
+            ph->p_paddr = ph->p_vaddr;
+            ++n;
         }
-    }
 
-    /* all other sections come after */
-    return layout_any_sections(s1, file_offset, sec_order, 0);
+        if (f & 1<<4) {
+            Section *roinf = &d->_roinf;
+            if (roinf->sh_size == 0) {
+                roinf->sh_offset = s->sh_offset;
+                roinf->sh_addr = s->sh_addr;
+                roinf->sh_addralign = 1;
+	    }
+            roinf->sh_size = (addr - roinf->sh_addr) + s->sh_size;
+        }
+
+        addr += s->sh_size;
+        if (s->sh_type != SHT_NOBITS)
+            file_offset += s->sh_size;
+
+        ph->p_filesz = file_offset - ph->p_offset;
+        ph->p_memsz = addr - ph->p_vaddr;
+    }
+
+    /* Fill other headers */
+    if (d->note)
+        fill_phdr(++ph, PT_NOTE, d->note);
+    if (d->dynamic)
+        fill_phdr(++ph, PT_DYNAMIC, d->dynamic)->p_flags |= PF_W;
+    if (d->roinf)
+        fill_phdr(++ph, PT_GNU_RELRO, d->roinf)->p_flags |= PF_W;
+    if (d->interp)
+        fill_phdr(&d->phdr[1], PT_INTERP, d->interp);
+    if (phfill) {
+        ph = &d->phdr[0];
+        ph->p_offset = sizeof(ElfW(Ehdr));
+        ph->p_vaddr = base + ph->p_offset;
+        ph->p_filesz = phnum * sizeof(ElfW(Phdr));
+        ph->p_align = 4;
+        fill_phdr(ph, PT_PHDR, NULL);
+    }
+    return file_offset;
 }
 
 /* put dynamic tag */
@@ -2095,75 +2354,6 @@ static void put_dt(Section *dynamic, int dt, addr_t val)
     dyn->d_un.d_val = val;
 }
 
-static void fill_unloadable_phdr(ElfW(Phdr) *phdr, int phnum, Section *interp,
-                                 Section *dynamic, Section *note, struct ro_inf *roinf)
-{
-    ElfW(Phdr) *ph;
-
-    /* if interpreter, then add corresponding program header */
-    if (interp) {
-        ph = &phdr[0];
-
-        ph->p_type = PT_PHDR;
-        ph->p_offset = sizeof(ElfW(Ehdr));
-        ph->p_filesz = ph->p_memsz = phnum * sizeof(ElfW(Phdr));
-        ph->p_vaddr = interp->sh_addr - ph->p_filesz;
-        ph->p_paddr = ph->p_vaddr;
-        ph->p_flags = PF_R | PF_X;
-        ph->p_align = 4; /* interp->sh_addralign; */
-        ph++;
-
-        ph->p_type = PT_INTERP;
-        ph->p_offset = interp->sh_offset;
-        ph->p_vaddr = interp->sh_addr;
-        ph->p_paddr = ph->p_vaddr;
-        ph->p_filesz = interp->sh_size;
-        ph->p_memsz = interp->sh_size;
-        ph->p_flags = PF_R;
-        ph->p_align = interp->sh_addralign;
-    }
-
-    if (note) {
-        ph = &phdr[phnum - 2 - (roinf != NULL)];
-
-        ph->p_type = PT_NOTE;
-        ph->p_offset = note->sh_offset;
-        ph->p_vaddr = note->sh_addr;
-        ph->p_paddr = ph->p_vaddr;
-        ph->p_filesz = note->sh_size;
-        ph->p_memsz = note->sh_size;
-        ph->p_flags = PF_R;
-        ph->p_align = note->sh_addralign;
-    }
-
-    /* if dynamic section, then add corresponding program header */
-    if (dynamic) {
-        ph = &phdr[phnum - 1 - (roinf != NULL)];
-
-        ph->p_type = PT_DYNAMIC;
-        ph->p_offset = dynamic->sh_offset;
-        ph->p_vaddr = dynamic->sh_addr;
-        ph->p_paddr = ph->p_vaddr;
-        ph->p_filesz = dynamic->sh_size;
-        ph->p_memsz = dynamic->sh_size;
-        ph->p_flags = PF_R | PF_W;
-        ph->p_align = dynamic->sh_addralign;
-    }
-
-    if (roinf) {
-        ph = &phdr[phnum - 1];
-
-        ph->p_type = PT_GNU_RELRO;
-        ph->p_offset = roinf->sh_offset;
-        ph->p_vaddr = roinf->sh_addr;
-        ph->p_paddr = ph->p_vaddr;
-        ph->p_filesz = roinf->sh_size;
-        ph->p_memsz = roinf->sh_size;
-        ph->p_flags = PF_R;
-        ph->p_align = 1;
-    }
-}
-
 /* Fill the dynamic section with tags describing the address and size of
    sections */
 static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
@@ -2173,6 +2363,7 @@ static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
 
     /* put dynamic section entries */
     put_dt(dynamic, DT_HASH, s1->dynsym->hash->sh_addr);
+    put_dt(dynamic, DT_GNU_HASH, dyninf->gnu_hash->sh_addr);
     put_dt(dynamic, DT_STRTAB, dyninf->dynstr->sh_addr);
     put_dt(dynamic, DT_SYMTAB, s1->dynsym->sh_addr);
     put_dt(dynamic, DT_STRSZ, dyninf->dynstr->data_offset);
@@ -2206,26 +2397,26 @@ static void fill_dynamic(TCCState *s1, struct dyn_inf *dyninf)
         put_dt(dynamic, DT_VERNEED, verneed_section->sh_addr);
         put_dt(dynamic, DT_VERNEEDNUM, dt_verneednum);
     }
-    s = find_section_create (s1, ".preinit_array", 0);
+    s = have_section(s1, ".preinit_array");
     if (s && s->data_offset) {
         put_dt(dynamic, DT_PREINIT_ARRAY, s->sh_addr);
         put_dt(dynamic, DT_PREINIT_ARRAYSZ, s->data_offset);
     }
-    s = find_section_create (s1, ".init_array", 0);
+    s = have_section(s1, ".init_array");
     if (s && s->data_offset) {
         put_dt(dynamic, DT_INIT_ARRAY, s->sh_addr);
         put_dt(dynamic, DT_INIT_ARRAYSZ, s->data_offset);
     }
-    s = find_section_create (s1, ".fini_array", 0);
+    s = have_section(s1, ".fini_array");
     if (s && s->data_offset) {
         put_dt(dynamic, DT_FINI_ARRAY, s->sh_addr);
         put_dt(dynamic, DT_FINI_ARRAYSZ, s->data_offset);
     }
-    s = find_section_create (s1, ".init", 0);
+    s = have_section(s1, ".init");
     if (s && s->data_offset) {
         put_dt(dynamic, DT_INIT, s->sh_addr);
     }
-    s = find_section_create (s1, ".fini", 0);
+    s = have_section(s1, ".fini");
     if (s && s->data_offset) {
         put_dt(dynamic, DT_FINI, s->sh_addr);
     }
@@ -2265,11 +2456,12 @@ static void update_reloc_sections(TCCState *s1, struct dyn_inf *dyninf)
     }
 }
 
+static int tidy_section_headers(TCCState *s1, int *sec_order);
 #endif /* ndef ELF_OBJ_ONLY */
 
 /* Create an ELF file on disk.
    This function handle ELF specific layout requirements */
-static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
+static int tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
                            int file_offset, int *sec_order)
 {
     int i, shnum, offset, size, file_type;
@@ -2286,6 +2478,9 @@ static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
         ehdr.e_phentsize = sizeof(ElfW(Phdr));
         ehdr.e_phnum = phnum;
         ehdr.e_phoff = sizeof(ElfW(Ehdr));
+#ifndef ELF_OBJ_ONLY
+        shnum = tidy_section_headers(s1, sec_order);
+#endif
     }
 
     /* align to 4 */
@@ -2299,45 +2494,37 @@ static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
     ehdr.e_ident[4] = ELFCLASSW;
     ehdr.e_ident[5] = ELFDATA2LSB;
     ehdr.e_ident[6] = EV_CURRENT;
+
 #if TARGETOS_FreeBSD || TARGETOS_FreeBSD_kernel
     ehdr.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
-#endif
-#ifdef TCC_TARGET_ARM
-#ifdef TCC_ARM_EABI
-    ehdr.e_ident[EI_OSABI] = 0;
-    ehdr.e_flags = EF_ARM_EABI_VER4;
-    if (file_type == TCC_OUTPUT_EXE || file_type == TCC_OUTPUT_DLL)
-        ehdr.e_flags |= EF_ARM_HASENTRY;
-    if (s1->float_abi == ARM_HARD_FLOAT)
-        ehdr.e_flags |= EF_ARM_VFP_FLOAT;
-    else
-        ehdr.e_flags |= EF_ARM_SOFT_FLOAT;
-#else
+#elif defined TCC_TARGET_ARM && defined TCC_ARM_EABI
+    ehdr.e_flags = EF_ARM_EABI_VER5;
+    ehdr.e_flags |= s1->float_abi == ARM_HARD_FLOAT
+        ? EF_ARM_VFP_FLOAT : EF_ARM_SOFT_FLOAT;
+#elif defined TCC_TARGET_ARM
     ehdr.e_ident[EI_OSABI] = ELFOSABI_ARM;
-#endif
 #elif defined TCC_TARGET_RISCV64
+    /* XXX should be configurable */
     ehdr.e_flags = EF_RISCV_FLOAT_ABI_DOUBLE;
 #endif
-    switch(file_type) {
-    default:
-    case TCC_OUTPUT_EXE:
-        ehdr.e_type = ET_EXEC;
-        ehdr.e_entry = get_sym_addr(s1,
-                                    s1->elf_entryname ?
-                                        s1->elf_entryname : "_start",
-                                    1, 0);
-        break;
-    case TCC_OUTPUT_DLL:
-        ehdr.e_type = ET_DYN;
-        ehdr.e_entry = s1->elf_entryname ?
-                            get_sym_addr(s1,s1->elf_entryname,1,0) :
-                            text_section->sh_addr;
-                            /* XXX: is it correct ? */
-        break;
-    case TCC_OUTPUT_OBJ:
+
+    if (file_type == TCC_OUTPUT_OBJ) {
         ehdr.e_type = ET_REL;
-        break;
+    } else {
+        if (file_type & TCC_OUTPUT_DYN)
+            ehdr.e_type = ET_DYN;
+        else
+            ehdr.e_type = ET_EXEC;
+        if (s1->elf_entryname)
+            ehdr.e_entry = get_sym_addr(s1, s1->elf_entryname, 1, 0);
+        else
+            ehdr.e_entry = get_sym_addr(s1, "_start", !!(file_type & TCC_OUTPUT_EXE), 0);
+        if (ehdr.e_entry == (addr_t)-1)
+            ehdr.e_entry = text_section->sh_addr;
+        if (s1->nb_errors)
+            return -1;
     }
+
     ehdr.e_machine = EM_TCC_TARGET;
     ehdr.e_version = EV_CURRENT;
     ehdr.e_shoff = file_offset;
@@ -2352,8 +2539,9 @@ static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
     offset = sizeof(ElfW(Ehdr)) + phnum * sizeof(ElfW(Phdr));
 
     sort_syms(s1, symtab_section);
-    for(i = 1; i < s1->nb_sections; i++) {
-        s = s1->sections[sec_order[i]];
+
+    for(i = 1; i < shnum; i++) {
+        s = s1->sections[sec_order ? sec_order[i] : i];
         if (s->sh_type != SHT_NOBITS) {
             while (offset < s->sh_offset) {
                 fputc(0, f);
@@ -2372,7 +2560,7 @@ static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
         offset++;
     }
 
-    for(i = 0; i < s1->nb_sections; i++) {
+    for(i = 0; i < shnum; i++) {
         sh = &shdr;
         memset(sh, 0, sizeof(ElfW(Shdr)));
         s = s1->sections[i];
@@ -2391,9 +2579,10 @@ static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
         }
         fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
     }
+    return 0;
 }
 
-static void tcc_output_binary(TCCState *s1, FILE *f,
+static int tcc_output_binary(TCCState *s1, FILE *f,
                               const int *sec_order)
 {
     Section *s;
@@ -2413,13 +2602,14 @@ static void tcc_output_binary(TCCState *s1, FILE *f,
             offset += size;
         }
     }
+    return 0;
 }
 
 /* Write an elf, coff or "binary" file */
 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
                               ElfW(Phdr) *phdr, int file_offset, int *sec_order)
 {
-    int fd, mode, file_type;
+    int fd, mode, file_type, ret;
     FILE *f;
 
     file_type = s1->output_type;
@@ -2429,31 +2619,28 @@ static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
         mode = 0777;
     unlink(filename);
     fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
-    if (fd < 0 || (f = fdopen(fd, "wb")) == NULL) {
-        tcc_error_noabort("could not write '%s: %s'", filename, strerror(errno));
-        return -1;
-    }
+    if (fd < 0 || (f = fdopen(fd, "wb")) == NULL)
+        return tcc_error_noabort("could not write '%s: %s'", filename, strerror(errno));
     if (s1->verbose)
         printf("<- %s\n", filename);
-
 #ifdef TCC_TARGET_COFF
     if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
         tcc_output_coff(s1, f);
     else
 #endif
     if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
-        tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
+        ret = tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
     else
-        tcc_output_binary(s1, f, sec_order);
+        ret = tcc_output_binary(s1, f, sec_order);
     fclose(f);
 
-    return 0;
+    return ret;
 }
 
 #ifndef ELF_OBJ_ONLY
 /* Sort section headers by assigned sh_addr, remove sections
    that we aren't going to output.  */
-static void tidy_section_headers(TCCState *s1, int *sec_order)
+static int tidy_section_headers(TCCState *s1, int *sec_order)
 {
     int i, nnew, l, *backmap;
     Section **snew, *s;
@@ -2493,8 +2680,8 @@ static void tidy_section_headers(TCCState *s1, int *sec_order)
 	sec_order[i] = i;
     tcc_free(s1->sections);
     s1->sections = snew;
-    s1->nb_sections = nnew;
     tcc_free(backmap);
+    return nnew;
 }
 
 #ifdef TCC_TARGET_ARM
@@ -2554,44 +2741,45 @@ static Section *create_bsd_note_section(TCCState *s1,
 }
 #endif
 
+static void alloc_sec_names(TCCState *s1, int is_obj);
+
 /* Output an elf, coff or binary file */
 /* XXX: suppress unneeded sections */
 static int elf_output_file(TCCState *s1, const char *filename)
 {
-    int i, ret, phnum, phfill, shnum, file_type, file_offset, *sec_order;
+    int i, ret, file_type, file_offset, *sec_order;
     struct dyn_inf dyninf = {0};
-    struct ro_inf roinf;
-    ElfW(Phdr) *phdr;
-    Section *interp, *dynamic, *dynstr, *note;
-    struct ro_inf *roinf_use = NULL;
-    int textrel;
+    Section *interp, *dynstr, *dynamic;
+    int textrel, got_sym, dt_flags_1;
 
     file_type = s1->output_type;
     s1->nb_errors = 0;
     ret = -1;
-    phdr = NULL;
+    interp = dynstr = dynamic = NULL;
     sec_order = NULL;
-    interp = dynamic = dynstr = note = NULL;
+    dyninf.roinf = &dyninf._roinf;
 
 #ifdef TCC_TARGET_ARM
     create_arm_attribute_section (s1);
 #endif
 
 #if TARGETOS_OpenBSD
-    note = create_bsd_note_section (s1, ".note.openbsd.ident", "OpenBSD");
+    dyninf.note = create_bsd_note_section (s1, ".note.openbsd.ident", "OpenBSD");
 #endif
 
 #if TARGETOS_NetBSD
-    note = create_bsd_note_section (s1, ".note.netbsd.ident", "NetBSD");
+    dyninf.note = create_bsd_note_section (s1, ".note.netbsd.ident", "NetBSD");
 #endif
 
-    {
+#if TARGETOS_FreeBSD || TARGETOS_NetBSD
+    dyninf.roinf = NULL;
+#endif
         /* if linking, also link in runtime libraries (libc, libgcc, etc.) */
         tcc_add_runtime(s1);
 	resolve_common_syms(s1);
 
         if (!s1->static_link) {
-            if (file_type == TCC_OUTPUT_EXE) {
+            if (file_type & TCC_OUTPUT_EXE) {
                 char *ptr;
                 /* allow override the dynamic loader */
                 const char *elfint = getenv("LD_SO");
@@ -2602,6 +2790,7 @@ static int elf_output_file(TCCState *s1, const char *filename)
                 interp->sh_addralign = 1;
                 ptr = section_ptr_add(interp, 1 + strlen(elfint));
                 strcpy(ptr, elfint);
+                dyninf.interp = interp;
             }
 
             /* add dynamic symbol table */
@@ -2617,27 +2806,29 @@ static int elf_output_file(TCCState *s1, const char *filename)
             dynamic->link = dynstr;
             dynamic->sh_entsize = sizeof(ElfW(Dyn));
 
-            build_got(s1);
-
-            if (file_type == TCC_OUTPUT_EXE) {
-                bind_exe_dynsyms(s1);
+            got_sym = build_got(s1);
+            if (file_type & TCC_OUTPUT_EXE) {
+                bind_exe_dynsyms(s1, file_type & TCC_OUTPUT_DYN);
                 if (s1->nb_errors)
                     goto the_end;
+            }
+            build_got_entries(s1, got_sym);
+            if (file_type & TCC_OUTPUT_EXE) {
                 bind_libs_dynsyms(s1);
             } else {
                 /* shared library case: simply export all global symbols */
                 export_global_syms(s1);
             }
+	    dyninf.gnu_hash = create_gnu_hash(s1);
+        } else {
+            build_got_entries(s1, 0);
         }
-        build_got_entries(s1);
 	version_add (s1);
-    }
 
     textrel = set_sec_sizes(s1);
     alloc_sec_names(s1, 0);
 
     if (!s1->static_link) {
-        int i;
         /* add a list of needed dlls */
         for(i = 0; i < s1->nb_loaded_dlls; i++) {
             DLLReference *dllref = s1->loaded_dlls[i];
@@ -2649,15 +2840,19 @@ static int elf_output_file(TCCState *s1, const char *filename)
             put_dt(dynamic, s1->enable_new_dtags ? DT_RUNPATH : DT_RPATH,
                    put_elf_str(dynstr, s1->rpath));
 
-        if (file_type == TCC_OUTPUT_DLL) {
+        dt_flags_1 = DF_1_NOW;
+        if (file_type & TCC_OUTPUT_DYN) {
             if (s1->soname)
                 put_dt(dynamic, DT_SONAME, put_elf_str(dynstr, s1->soname));
             /* XXX: currently, since we do not handle PIC code, we
                must relocate the readonly segments */
             if (textrel)
                 put_dt(dynamic, DT_TEXTREL, 0);
+            if (file_type & TCC_OUTPUT_EXE)
+                dt_flags_1 = DF_1_NOW | DF_1_PIE;
         }
-
+        put_dt(dynamic, DT_FLAGS, DF_BIND_NOW);
+        put_dt(dynamic, DT_FLAGS_1, dt_flags_1);
         if (s1->symbolic)
             put_dt(dynamic, DT_SYMBOLIC, 0);
 
@@ -2670,62 +2865,24 @@ static int elf_output_file(TCCState *s1, const char *filename)
         dynstr->sh_size = dynstr->data_offset;
     }
 
-    for (i = 1; i < s1->nb_sections &&
-                !(s1->sections[i]->sh_flags & SHF_TLS); i++);
-    phfill = 2 + (i < s1->nb_sections);
-
-    /* compute number of program headers */
-    if (file_type == TCC_OUTPUT_DLL)
-        phnum = 3;
-    else if (s1->static_link)
-        phnum = 3;
-    else {
-        phnum = 5 + (i < s1->nb_sections);
-    }
-
-    phnum += note != NULL;
-#if !TARGETOS_FreeBSD && !TARGETOS_NetBSD
-    /* GNU_RELRO */
-    phnum++, roinf_use = &roinf;
-#endif
-
-    /* allocate program segment headers */
-    phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));
-    /* compute number of sections */
-    shnum = s1->nb_sections;
     /* this array is used to reorder sections in the output file */
-    sec_order = tcc_malloc(sizeof(int) * shnum);
-    sec_order[0] = 0;
-
+    sec_order = tcc_malloc(sizeof(int) * 2 * s1->nb_sections);
     /* compute section to program header mapping */
-    file_offset = layout_sections(s1, phdr, phnum, phfill, interp, &roinf, sec_order + 1);
+    file_offset = layout_sections(s1, sec_order, &dyninf);
 
-    /* Fill remaining program header and finalize relocation related to dynamic
-       linking. */
-    {
-        fill_unloadable_phdr(phdr, phnum, interp, dynamic, note, roinf_use);
         if (dynamic) {
-            ElfW(Sym) *sym;
-
             /* put in GOT the dynamic section address and relocate PLT */
             write32le(s1->got->data, dynamic->sh_addr);
             if (file_type == TCC_OUTPUT_EXE
-                || (RELOCATE_DLLPLT && file_type == TCC_OUTPUT_DLL))
+                || (RELOCATE_DLLPLT && (file_type & TCC_OUTPUT_DYN)))
                 relocate_plt(s1);
-
             /* relocate symbols in .dynsym now that final addresses are known */
-            for_each_elem(s1->dynsym, 1, sym, ElfW(Sym)) {
-                if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE) {
-                    /* do symbol relocation */
-                    sym->st_value += s1->sections[sym->st_shndx]->sh_addr;
-                }
-            }
+            relocate_syms(s1, s1->dynsym, 2);
         }
 
         /* if building executable or DLL, then relocate each section
            except the GOT which is already relocated */
         relocate_syms(s1, s1->symtab, 0);
-        ret = -1;
         if (s1->nb_errors != 0)
             goto the_end;
         relocate_sections(s1);
@@ -2734,21 +2891,20 @@ static int elf_output_file(TCCState *s1, const char *filename)
             dynamic->data_offset = dyninf.data_offset;
             fill_dynamic(s1, &dyninf);
 	}
-	tidy_section_headers(s1, sec_order);
-
         /* Perform relocation to GOT or PLT entries */
         if (file_type == TCC_OUTPUT_EXE && s1->static_link)
             fill_got(s1);
         else if (s1->got)
             fill_local_got_entries(s1);
-    }
-    /* Create the ELF file with name 'filename' */
-    ret = tcc_write_elf_file(s1, filename, phnum, phdr, file_offset, sec_order);
-    s1->nb_sections = shnum;
 
+    if (dyninf.gnu_hash)
+        update_gnu_hash(s1, dyninf.gnu_hash);
+
+    /* Create the ELF file with name 'filename' */
+    ret = tcc_write_elf_file(s1, filename, dyninf.phnum, dyninf.phdr, file_offset, sec_order);
  the_end:
     tcc_free(sec_order);
-    tcc_free(phdr);
+    tcc_free(dyninf.phdr);
     return ret;
 }
 #endif /* ndef ELF_OBJ_ONLY */
@@ -2771,42 +2927,24 @@ static void alloc_sec_names(TCCState *s1, int is_obj)
     strsec->sh_size = strsec->data_offset;
 }
 
-static int layout_any_sections(TCCState *s1, int file_offset, int *sec_order, int is_obj)
+/* Output an elf .o file */
+static int elf_output_obj(TCCState *s1, const char *filename)
 {
-    int i;
     Section *s;
+    int i, ret, file_offset;
+    s1->nb_errors = 0;
+    /* Allocate strings for section names */
+    alloc_sec_names(s1, 1);
+    file_offset = sizeof (ElfW(Ehdr));
     for(i = 1; i < s1->nb_sections; i++) {
         s = s1->sections[i];
-        if (!is_obj && (s->sh_flags & SHF_ALLOC))
-            continue;
-        *sec_order++ = i;
-        file_offset = (file_offset + s->sh_addralign - 1) &
-            ~(s->sh_addralign - 1);
+        file_offset = (file_offset + 15) & -16;
         s->sh_offset = file_offset;
         if (s->sh_type != SHT_NOBITS)
             file_offset += s->sh_size;
     }
-    return file_offset;
-}
-
-/* Output an elf .o file */
-static int elf_output_obj(TCCState *s1, const char *filename)
-{
-    int ret, file_offset;
-    int *sec_order;
-    s1->nb_errors = 0;
-
-    /* Allocate strings for section names */
-    alloc_sec_names(s1, 1);
-
-    /* this array is used to reorder sections in the output file */
-    sec_order = tcc_malloc(sizeof(int) * s1->nb_sections);
-    sec_order[0] = 0;
-    file_offset = layout_any_sections(s1, sizeof (ElfW(Ehdr)), sec_order + 1, 1);
-
     /* Create the ELF file with name 'filename' */
-    ret = tcc_write_elf_file(s1, filename, 0, NULL, file_offset, sec_order);
-    tcc_free(sec_order);
+    ret = tcc_write_elf_file(s1, filename, 0, NULL, file_offset, NULL);
     return ret;
 }
 
@@ -2880,7 +3018,8 @@ ST_FUNC int tcc_load_object_file(TCCState *s1,
 {
     ElfW(Ehdr) ehdr;
     ElfW(Shdr) *shdr, *sh;
-    int size, i, j, offset, offseti, nb_syms, sym_index, ret, seencompressed;
+    unsigned long size, offset, offseti;
+    int i, j, nb_syms, sym_index, ret, seencompressed;
     char *strsec, *strtab;
     int stab_index, stabstr_index;
     int *old_to_new_syms;
@@ -2892,13 +3031,12 @@ ST_FUNC int tcc_load_object_file(TCCState *s1,
 
     lseek(fd, file_offset, SEEK_SET);
     if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
-        goto fail1;
+        goto invalid;
     /* test CPU specific stuff */
     if (ehdr.e_ident[5] != ELFDATA2LSB ||
         ehdr.e_machine != EM_TCC_TARGET) {
-    fail1:
-        tcc_error_noabort("invalid object file");
-        return -1;
+invalid:
+        return tcc_error_noabort("invalid object file");
     }
     /* read sections */
     shdr = load_data(fd, file_offset + ehdr.e_shoff,
@@ -2916,14 +3054,13 @@ ST_FUNC int tcc_load_object_file(TCCState *s1,
     nb_syms = 0;
     seencompressed = 0;
     stab_index = stabstr_index = 0;
+    ret = -1;
 
     for(i = 1; i < ehdr.e_shnum; i++) {
         sh = &shdr[i];
         if (sh->sh_type == SHT_SYMTAB) {
             if (symtab) {
                 tcc_error_noabort("object must contain only one symtab");
-            fail:
-                ret = -1;
                 goto the_end;
             }
             nb_syms = sh->sh_size / sizeof(ElfW(Sym));
@@ -2963,8 +3100,7 @@ ST_FUNC int tcc_load_object_file(TCCState *s1,
             strcmp(strsec + sh->sh_name, ".stabstr")
             )
             continue;
-	if (seencompressed
-	    && !strncmp(strsec + sh->sh_name, ".debug_", sizeof(".debug_")-1))
+	if (seencompressed && 0 == strncmp(strsec + sh->sh_name, ".debug_", 7))
 	  continue;
 
 	sh = &shdr[i];
@@ -3001,14 +3137,13 @@ ST_FUNC int tcc_load_object_file(TCCState *s1,
         s->sh_entsize = sh->sh_entsize;
         sm_table[i].new_section = 1;
     found:
-        if (sh->sh_type != s->sh_type) {
+        if (sh->sh_type != s->sh_type
 #if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD
-            if (strcmp (s->name, ".eh_frame"))
+            && strcmp (s->name, ".eh_frame")
 #endif
-            {
-                tcc_error_noabort("invalid section type");
-                goto fail;
-	    }
+            ) {
+            tcc_error_noabort("invalid section type");
+            goto the_end;
         }
         /* align start of section */
         s->data_offset += -s->data_offset & (sh->sh_addralign - 1);
@@ -3132,7 +3267,7 @@ ST_FUNC int tcc_load_object_file(TCCState *s1,
                 invalid_reloc:
                     tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
                         i, strsec + sh->sh_name, (int)rel->r_offset);
-                    goto fail;
+                    goto the_end;
                 }
                 rel->r_info = ELFW(R_INFO)(sym_index, type);
                 /* offset the relocation offset */
@@ -3268,10 +3403,8 @@ ST_FUNC int tcc_load_archive(TCCState *s1, int fd, int alacarte)
         len = read_ar_header(fd, file_offset, &hdr);
         if (len == 0)
             return 0;
-        if (len < 0) {
-            tcc_error_noabort("invalid archive");
-            return -1;
-        }
+        if (len < 0)
+            return tcc_error_noabort("invalid archive");
         file_offset += len;
         size = strtol(hdr.ar_size, NULL, 0);
         /* align to even */
@@ -3424,21 +3557,20 @@ static void store_version(TCCState *s1, struct versym_info *v, char *dynstr)
 #endif
 }
 
-/* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
-   is referenced by the user (so it should be added as DT_NEEDED in
-   the generated ELF file) */
+/* load a library / DLL
+   'level = 0' means that the DLL is referenced by the user
+   (so it should be added as DT_NEEDED in the generated ELF file) */
 ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
 {
     ElfW(Ehdr) ehdr;
     ElfW(Shdr) *shdr, *sh, *sh1;
-    int i, j, nb_syms, nb_dts, sym_bind, ret;
+    int i, nb_syms, nb_dts, sym_bind, ret = -1;
     ElfW(Sym) *sym, *dynsym;
     ElfW(Dyn) *dt, *dynamic;
 
     char *dynstr;
     int sym_index;
     const char *name, *soname;
-    DLLReference *dllref;
     struct versym_info v;
 
     full_read(fd, &ehdr, sizeof(ehdr));
@@ -3446,8 +3578,7 @@ ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
     /* test CPU specific stuff */
     if (ehdr.e_ident[5] != ELFDATA2LSB ||
         ehdr.e_machine != EM_TCC_TARGET) {
-        tcc_error_noabort("bad architecture");
-        return -1;
+        return tcc_error_noabort("bad architecture");
     }
 
     /* read sections */
@@ -3488,37 +3619,24 @@ ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
         }
     }
 
+    if (!dynamic)
+        goto the_end;
+
     /* compute the real library name */
     soname = tcc_basename(filename);
-
-    for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
-        if (dt->d_tag == DT_SONAME) {
+    for(i = 0, dt = dynamic; i < nb_dts; i++, dt++)
+        if (dt->d_tag == DT_SONAME)
             soname = dynstr + dt->d_un.d_val;
-        } else if (dt->d_tag == DT_RPATH) {
-            tcc_add_library_path(s1, dynstr + dt->d_un.d_val);
-        }
-    }
 
     /* if the dll is already loaded, do not load it */
-    for(i = 0; i < s1->nb_loaded_dlls; i++) {
-        dllref = s1->loaded_dlls[i];
-        if (!strcmp(soname, dllref->name)) {
-            /* but update level if needed */
-            if (level < dllref->level)
-                dllref->level = level;
-            ret = 0;
-            goto the_end;
-        }
-    }
+    if (tcc_add_dllref(s1, soname, level)->found)
+        goto ret_success;
 
     if (v.nb_versyms != nb_syms)
         tcc_free (v.versym), v.versym = NULL;
     else
         store_version(s1, &v, dynstr);
 
-    /* add the dll and its level */
-    tcc_add_dllref(s1, soname)->level = level;
-
     /* add dynamic symbols in dynsym_section */
     for(i = 1, sym = dynsym + 1; i < nb_syms; i++, sym++) {
         sym_bind = ELFW(ST_BIND)(sym->st_info);
@@ -3534,25 +3652,34 @@ ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
         }
     }
 
+    /* do not load all referenced libraries
+       (recursive loading can break linking of libraries) */
+    /* following DT_NEEDED is needed for the dynamic loader (libdl.so),
+       but it is no longer needed, when linking a library or a program.
+       When tcc output mode is OUTPUT_MEM,
+       tcc calls dlopen, which handles DT_NEEDED for us */
+
+#if 0
+    for(i = 0, dt = dynamic; i < nb_dts; i++, dt++)
+        if (dt->d_tag == DT_RPATH)
+            tcc_add_library_path(s1, dynstr + dt->d_un.d_val);
+
     /* load all referenced DLLs */
     for(i = 0, dt = dynamic; i < nb_dts; i++, dt++) {
         switch(dt->d_tag) {
         case DT_NEEDED:
             name = dynstr + dt->d_un.d_val;
-            for(j = 0; j < s1->nb_loaded_dlls; j++) {
-                dllref = s1->loaded_dlls[j];
-                if (!strcmp(name, dllref->name))
-                    goto already_loaded;
-            }
+            if (tcc_add_dllref(s1, name, -1))
+                continue;
             if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
-                tcc_error_noabort("referenced dll '%s' not found", name);
-                ret = -1;
+                ret = tcc_error_noabort("referenced dll '%s' not found", name);
                 goto the_end;
             }
-        already_loaded:
-            break;
         }
     }
+#endif
+
+ ret_success:
     ret = 0;
  the_end:
     tcc_free(dynstr);
@@ -3712,7 +3839,7 @@ static int ld_add_file(TCCState *s1, const char filename[])
 
 static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
 {
-    char filename[1024], libname[1016];
+    char filename[1024], libname[1024];
     int t, group, nblibs = 0, ret = 0;
     char **libs = NULL;
 
@@ -3721,24 +3848,21 @@ static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
         s1->new_undef_sym = 0;
     t = ld_next(s1, filename, sizeof(filename));
     if (t != '(') {
-        tcc_error_noabort("( expected");
-        ret = -1;
+        ret = tcc_error_noabort("( expected");
         goto lib_parse_error;
     }
     t = ld_next(s1, filename, sizeof(filename));
     for(;;) {
         libname[0] = '\0';
         if (t == LD_TOK_EOF) {
-            tcc_error_noabort("unexpected end of file");
-            ret = -1;
+            ret = tcc_error_noabort("unexpected end of file");
             goto lib_parse_error;
         } else if (t == ')') {
             break;
         } else if (t == '-') {
             t = ld_next(s1, filename, sizeof(filename));
             if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
-                tcc_error_noabort("library name expected");
-                ret = -1;
+                ret = tcc_error_noabort("library name expected");
                 goto lib_parse_error;
             }
             pstrcpy(libname, sizeof libname, &filename[1]);
@@ -3748,8 +3872,7 @@ static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
                 snprintf(filename, sizeof filename, "lib%s.so", libname);
             }
         } else if (t != LD_TOK_NAME) {
-            tcc_error_noabort("filename expected");
-            ret = -1;
+            ret = tcc_error_noabort("filename expected");
             goto lib_parse_error;
         }
         if (!strcmp(filename, "AS_NEEDED")) {
@@ -3757,8 +3880,9 @@ static int ld_add_file_list(TCCState *s1, const char *cmd, int as_needed)
             if (ret)
                 goto lib_parse_error;
         } else {
-            /* TODO: Implement AS_NEEDED support. Ignore it for now */
-            if (!as_needed) {
+            /* TODO: Implement AS_NEEDED support. */
+	    /*       DT_NEEDED is not used any more so ignore as_needed */
+            if (1 || !as_needed) {
                 ret = ld_add_file(s1, filename);
                 if (ret)
                     goto lib_parse_error;
@@ -3813,15 +3937,12 @@ ST_FUNC int tcc_load_ldscript(TCCState *s1, int fd)
                    !strcmp(cmd, "TARGET")) {
             /* ignore some commands */
             t = ld_next(s1, cmd, sizeof(cmd));
-            if (t != '(') {
-                tcc_error_noabort("( expected");
-                return -1;
-            }
+            if (t != '(')
+                return tcc_error_noabort("( expected");
             for(;;) {
                 t = ld_next(s1, filename, sizeof(filename));
                 if (t == LD_TOK_EOF) {
-                    tcc_error_noabort("unexpected end of file");
-                    return -1;
+                    return tcc_error_noabort("unexpected end of file");
                 } else if (t == ')') {
                     break;
                 }
diff --git a/tccgen.c b/tccgen.c
index d1e0823ae..602afa3fb 100644
--- a/tccgen.c
+++ b/tccgen.c
@@ -1,6 +1,6 @@
 /*
  *  TCC - Tiny C Compiler
- * 
+ *
  *  Copyright (c) 2001-2004 Fabrice Bellard
  *
  * This library is free software; you can redistribute it and/or
@@ -44,44 +44,36 @@ static int nb_sym_pools;
 static Sym *all_cleanups, *pending_gotos;
 static int local_scope;
 static int in_sizeof;
-static int in_generic;
-static int section_sym;
+static int constant_p;
 ST_DATA char debug_modes;
 
 ST_DATA SValue *vtop;
 static SValue _vstack[1 + VSTACK_SIZE];
 #define vstack (_vstack + 1)
 
-ST_DATA int const_wanted; /* true if constant wanted */
 ST_DATA int nocode_wanted; /* no code generation wanted */
-#define unevalmask 0xffff /* unevaluated subexpression */
 #define NODATA_WANTED (nocode_wanted > 0) /* no static data output wanted either */
-#define STATIC_DATA_WANTED (nocode_wanted & 0xC0000000) /* only static data output */
-
-/* Automagical code suppression ----> */
-#define CODE_OFF() (nocode_wanted |= 0x20000000)
-#define CODE_ON() (nocode_wanted &= ~0x20000000)
+#define DATA_ONLY_WANTED 0x80000000 /* ON outside of functions and for static initializers */
 
-static void tcc_tcov_block_begin(void);
+/* no code output after unconditional jumps such as with if (0) ... */
+#define CODE_OFF_BIT 0x20000000
+#define CODE_OFF() if(!nocode_wanted)(nocode_wanted |= CODE_OFF_BIT)
+#define CODE_ON() (nocode_wanted &= ~CODE_OFF_BIT)
 
-/* Clear 'nocode_wanted' at label if it was used */
-ST_FUNC void gsym(int t) { if (t) { gsym_addr(t, ind); CODE_ON(); }}
-static int gind(void) { int t = ind; CODE_ON(); if (debug_modes) tcc_tcov_block_begin(); return t; }
+/* no code output when parsing sizeof()/typeof() etc. (using nocode_wanted++/--) */
+#define NOEVAL_MASK 0x0000FFFF
+#define NOEVAL_WANTED (nocode_wanted & NOEVAL_MASK)
 
-/* Set 'nocode_wanted' after unconditional jumps */
-static void gjmp_addr_acs(int t) { gjmp_addr(t); CODE_OFF(); }
-static int gjmp_acs(int t) { t = gjmp(t); CODE_OFF(); return t; }
-
-/* These are #undef'd at the end of this file */
-#define gjmp_addr gjmp_addr_acs
-#define gjmp gjmp_acs
-/* <---- */
+/* no code output when parsing constant expressions */
+#define CONST_WANTED_BIT  0x00010000
+#define CONST_WANTED_MASK 0x0FFF0000
+#define CONST_WANTED  (nocode_wanted & CONST_WANTED_MASK)
 
 ST_DATA int global_expr;  /* true if compound literals must be allocated globally (used during initializers parsing */
 ST_DATA CType func_vt; /* current function return type (used by return instruction) */
 ST_DATA int func_var; /* true if current function is variadic (used by return instruction) */
 ST_DATA int func_vc;
-static int last_line_num, new_file, func_ind; /* debug info control */
+ST_DATA int func_ind;
 ST_DATA const char *funcname;
 ST_DATA CType int_type, func_old_type, char_type, char_pointer_type;
 static CString initstr;
@@ -103,6 +95,7 @@ static struct switch_t {
 	int sym;
     } **p; int n; /* list of case ranges */
     int def_sym; /* default symbol */
+    int nocode_wanted;
     int *bsym;
     struct scope *scope;
     struct switch_t *prev;
@@ -137,102 +130,18 @@ typedef struct {
 static void init_prec(void);
 #endif
 
-/********************************************************/
-/* stab debug support */
-
-static const struct {
-  int type;
-  const char *name;
-} default_debug[] = {
-    {   VT_INT, "int:t1=r1;-2147483648;2147483647;" },
-    {   VT_BYTE, "char:t2=r2;0;127;" },
-#if LONG_SIZE == 4
-    {   VT_LONG | VT_INT, "long int:t3=r3;-2147483648;2147483647;" },
-#else
-    {   VT_LLONG | VT_LONG, "long int:t3=r3;-9223372036854775808;9223372036854775807;" },
-#endif
-    {   VT_INT | VT_UNSIGNED, "unsigned int:t4=r4;0;037777777777;" },
-#if LONG_SIZE == 4
-    {   VT_LONG | VT_INT | VT_UNSIGNED, "long unsigned int:t5=r5;0;037777777777;" },
-#else
-    /* use octal instead of -1 so size_t works (-gstabs+ in gcc) */
-    {   VT_LLONG | VT_LONG | VT_UNSIGNED, "long unsigned int:t5=r5;0;01777777777777777777777;" },
-#endif
-    {   VT_QLONG, "__int128:t6=r6;0;-1;" },
-    {   VT_QLONG | VT_UNSIGNED, "__int128 unsigned:t7=r7;0;-1;" },
-    {   VT_LLONG, "long long int:t8=r8;-9223372036854775808;9223372036854775807;" },
-    {   VT_LLONG | VT_UNSIGNED, "long long unsigned int:t9=r9;0;01777777777777777777777;" },
-    {   VT_SHORT, "short int:t10=r10;-32768;32767;" },
-    {   VT_SHORT | VT_UNSIGNED, "short unsigned int:t11=r11;0;65535;" },
-    {   VT_BYTE | VT_DEFSIGN, "signed char:t12=r12;-128;127;" },
-    {   VT_BYTE | VT_DEFSIGN | VT_UNSIGNED, "unsigned char:t13=r13;0;255;" },
-    {   VT_FLOAT, "float:t14=r1;4;0;" },
-    {   VT_DOUBLE, "double:t15=r1;8;0;" },
-#ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
-    {   VT_DOUBLE | VT_LONG, "long double:t16=r1;8;0;" },
-#else
-    {   VT_LDOUBLE, "long double:t16=r1;16;0;" },
-#endif
-    {   -1, "_Float32:t17=r1;4;0;" },
-    {   -1, "_Float64:t18=r1;8;0;" },
-    {   -1, "_Float128:t19=r1;16;0;" },
-    {   -1, "_Float32x:t20=r1;8;0;" },
-    {   -1, "_Float64x:t21=r1;16;0;" },
-    {   -1, "_Decimal32:t22=r1;4;0;" },
-    {   -1, "_Decimal64:t23=r1;8;0;" },
-    {   -1, "_Decimal128:t24=r1;16;0;" },
-    /* if default char is unsigned */
-    {   VT_BYTE | VT_UNSIGNED, "unsigned char:t25=r25;0;255;" },
-    /* boolean type */
-    {   VT_BOOL, "bool:t26=r26;0;255;" },
-    {   VT_VOID, "void:t27=27" },
-};
-
-static int debug_next_type;
-
-static struct debug_hash {
-    int debug_type;
-    Sym *type;
-} *debug_hash;
-
-static int n_debug_hash;
-
-static struct debug_info {
-    int start;
-    int end;
-    int n_sym;
-    struct debug_sym {
-        int type;
-        unsigned long value;
-        char *str;
-        Section *sec;
-        int sym_index;
-    } *sym;
-    struct debug_info *child, *next, *last, *parent;
-} *debug_info, *debug_info_root;
-
-static struct {
-    unsigned long offset;
-    unsigned long last_file_name;
-    unsigned long last_func_name;
-    int ind;
-    int line;
-} tcov_data;
-
-/********************************************************/
 static void gen_cast(CType *type);
 static void gen_cast_s(int t);
 static inline CType *pointed_type(CType *type);
 static int is_compatible_types(CType *type1, CType *type2);
-static int parse_btype(CType *type, AttributeDef *ad);
+static int parse_btype(CType *type, AttributeDef *ad, int ignore_label);
 static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td);
 static void parse_expr_type(CType *type);
 static void init_putv(init_params *p, CType *type, unsigned long c);
 static void decl_initializer(init_params *p, CType *type, unsigned long c, int flags);
 static void block(int is_expr);
 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
-static void decl(int l);
-static int decl0(int l, int is_for_loop_init, Sym *);
+static int decl(int l);
 static void expr_eq(void);
 static void vpush_type_size(CType *type, int *a);
 static int is_compatible_unqualified_types(CType *type1, CType *type2);
@@ -248,6 +157,48 @@ static int get_temp_local_var(int size,int align);
 static void clear_temp_local_var_list();
 static void cast_error(CType *st, CType *dt);
 
+/* ------------------------------------------------------------------------- */
+/* Automagical code suppression */
+
+/* Clear 'nocode_wanted' at forward label if it was used */
+ST_FUNC void gsym(int t)
+{
+  if (t) {
+    gsym_addr(t, ind);
+    CODE_ON();
+  }
+}
+
+/* Clear 'nocode_wanted' if current pc is a label */
+static int gind()
+{
+  int t = ind;
+  CODE_ON();
+  if (debug_modes)
+    tcc_tcov_block_begin(tcc_state);
+  return t;
+}
+
+/* Set 'nocode_wanted' after unconditional (backwards) jump */
+static void gjmp_addr_acs(int t)
+{
+  gjmp_addr(t);
+  CODE_OFF();
+}
+
+/* Set 'nocode_wanted' after unconditional (forwards) jump */
+static int gjmp_acs(int t)
+{
+  t = gjmp(t);
+  CODE_OFF();
+  return t;
+}
+
+/* These are #undef'd at the end of this file */
+#define gjmp_addr gjmp_addr_acs
+#define gjmp gjmp_acs
+/* ------------------------------------------------------------------------- */
+
 ST_INLN int is_float(int t)
 {
     int bt = t & VT_BTYPE;
@@ -388,9 +339,7 @@ ST_FUNC void check_vstack(void)
                   (int)(vtop - vstack + 1));
 }
 
-/* ------------------------------------------------------------------------- */
 /* vstack debugging aid */
-
 #if 0
 void pv (const char *lbl, int a, int b)
 {
@@ -403,541 +352,6 @@ void pv (const char *lbl, int a, int b)
 }
 #endif
 
-/* ------------------------------------------------------------------------- */
-/* start of translation unit info */
-ST_FUNC void tcc_debug_start(TCCState *s1)
-{
-    if (s1->do_debug) {
-        int i;
-        char buf[512];
-
-        /* file info: full path + filename */
-        section_sym = put_elf_sym(symtab_section, 0, 0,
-                                  ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
-                                  text_section->sh_num, NULL);
-        getcwd(buf, sizeof(buf));
-#ifdef _WIN32
-        normalize_slashes(buf);
-#endif
-        pstrcat(buf, sizeof(buf), "/");
-        put_stabs_r(s1, buf, N_SO, 0, 0,
-                    text_section->data_offset, text_section, section_sym);
-        put_stabs_r(s1, file->prev ? file->prev->filename : file->filename,
-                    N_SO, 0, 0,
-                    text_section->data_offset, text_section, section_sym);
-        for (i = 0; i < sizeof (default_debug) / sizeof (default_debug[0]); i++)
-            put_stabs(s1, default_debug[i].name, N_LSYM, 0, 0, 0);
-
-        new_file = last_line_num = 0;
-        func_ind = -1;
-        debug_next_type = sizeof(default_debug) / sizeof(default_debug[0]);
-        debug_hash = NULL;
-        n_debug_hash = 0;
-
-        /* we're currently 'including' the <command line> */
-        tcc_debug_bincl(s1);
-    }
-
-    /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
-       symbols can be safely used */
-    put_elf_sym(symtab_section, 0, 0,
-                ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
-                SHN_ABS, file->filename);
-}
-
-/* put end of translation unit info */
-ST_FUNC void tcc_debug_end(TCCState *s1)
-{
-    if (!s1->do_debug)
-        return;
-    put_stabs_r(s1, NULL, N_SO, 0, 0,
-        text_section->data_offset, text_section, section_sym);
-    tcc_free(debug_hash);
-}
-
-static BufferedFile* put_new_file(TCCState *s1)
-{
-    BufferedFile *f = file;
-    /* use upper file if from inline ":asm:" */
-    if (f->filename[0] == ':')
-        f = f->prev;
-    if (f && new_file) {
-        put_stabs_r(s1, f->filename, N_SOL, 0, 0, ind, text_section, section_sym);
-        new_file = last_line_num = 0;
-    }
-    return f;
-}
-
-/* put alternative filename */
-ST_FUNC void tcc_debug_putfile(TCCState *s1, const char *filename)
-{
-    if (0 == strcmp(file->filename, filename))
-        return;
-    pstrcpy(file->filename, sizeof(file->filename), filename);
-    new_file = 1;
-}
-
-/* begin of #include */
-ST_FUNC void tcc_debug_bincl(TCCState *s1)
-{
-    if (!s1->do_debug)
-        return;
-    put_stabs(s1, file->filename, N_BINCL, 0, 0, 0);
-    new_file = 1;
-}
-
-/* end of #include */
-ST_FUNC void tcc_debug_eincl(TCCState *s1)
-{
-    if (!s1->do_debug)
-        return;
-    put_stabn(s1, N_EINCL, 0, 0, 0);
-    new_file = 1;
-}
-
-/* generate line number info */
-static void tcc_debug_line(TCCState *s1)
-{
-    BufferedFile *f;
-    if (!s1->do_debug
-        || cur_text_section != text_section
-        || !(f = put_new_file(s1))
-        || last_line_num == f->line_num)
-        return;
-    if (func_ind != -1) {
-        put_stabn(s1, N_SLINE, 0, f->line_num, ind - func_ind);
-    } else {
-        /* from tcc_assemble */
-        put_stabs_r(s1, NULL, N_SLINE, 0, f->line_num, ind, text_section, section_sym);
-    }
-    last_line_num = f->line_num;
-}
-
-static void tcc_debug_stabs (TCCState *s1, const char *str, int type, unsigned long value,
-                             Section *sec, int sym_index)
-{
-    struct debug_sym *s;
-
-    if (debug_info) {
-        debug_info->sym =
-            (struct debug_sym *)tcc_realloc (debug_info->sym,
-                                             sizeof(struct debug_sym) *
-                                             (debug_info->n_sym + 1));
-        s = debug_info->sym + debug_info->n_sym++;
-        s->type = type;
-        s->value = value;
-        s->str = tcc_strdup(str);
-        s->sec = sec;
-        s->sym_index = sym_index;
-    }
-    else if (sec)
-        put_stabs_r (s1, str, type, 0, 0, value, sec, sym_index);
-    else
-        put_stabs (s1, str, type, 0, 0, value);
-}
-
-static void tcc_debug_stabn(TCCState *s1, int type, int value)
-{
-    if (!s1->do_debug)
-        return;
-    if (type == N_LBRAC) {
-        struct debug_info *info =
-            (struct debug_info *) tcc_mallocz(sizeof (*info));
-
-        info->start = value;
-        info->parent = debug_info;
-        if (debug_info) {
-            if (debug_info->child) {
-                if (debug_info->child->last)
-                    debug_info->child->last->next = info;
-                else
-                    debug_info->child->next = info;
-                debug_info->child->last = info;
-            }
-            else
-                debug_info->child = info;
-        }
-        else
-            debug_info_root = info;
-        debug_info = info;
-    }
-    else {
-        debug_info->end = value;
-        debug_info = debug_info->parent;
-    }
-}
-
-static void tcc_get_debug_info(TCCState *s1, Sym *s, CString *result)
-{
-    int type;
-    int n = 0;
-    int debug_type = -1;
-    Sym *t = s;
-    CString str;
-
-    for (;;) {
-        type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE);
-        if ((type & VT_BTYPE) != VT_BYTE)
-            type &= ~VT_DEFSIGN;
-        if (type == VT_PTR || type == (VT_PTR | VT_ARRAY))
-            n++, t = t->type.ref;
-        else
-            break;
-    }
-    if ((type & VT_BTYPE) == VT_STRUCT) {
-        int i;
-
-        t = t->type.ref;
-        for (i = 0; i < n_debug_hash; i++) {
-            if (t == debug_hash[i].type) {
-                debug_type = debug_hash[i].debug_type;
-                break;
-            }
-        }
-        if (debug_type == -1) {
-            debug_type = ++debug_next_type;
-            debug_hash = (struct debug_hash *)
-                tcc_realloc (debug_hash,
-                             (n_debug_hash + 1) * sizeof(*debug_hash));
-            debug_hash[n_debug_hash].debug_type = debug_type;
-            debug_hash[n_debug_hash++].type = t;
-            cstr_new (&str);
-            cstr_printf (&str, "%s:T%d=%c%d",
-                         (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
-                         ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL),
-                         debug_type,
-                         IS_UNION (t->type.t) ? 'u' : 's',
-                         t->c);
-            while (t->next) {
-                int pos, size, align;
-
-                t = t->next;
-                cstr_printf (&str, "%s:",
-                             (t->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
-                             ? "" : get_tok_str(t->v & ~SYM_FIELD, NULL));
-                tcc_get_debug_info (s1, t, &str);
-                if (t->type.t & VT_BITFIELD) {
-                    pos = t->c * 8 + BIT_POS(t->type.t);
-                    size = BIT_SIZE(t->type.t);
-                }
-                else {
-                    pos = t->c * 8;
-                    size = type_size(&t->type, &align) * 8;
-                }
-                cstr_printf (&str, ",%d,%d;", pos, size);
-            }
-            cstr_printf (&str, ";");
-            tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0);
-            cstr_free (&str);
-        }
-    }
-    else if (IS_ENUM(type)) {
-        Sym *e = t = t->type.ref;
-
-        debug_type = ++debug_next_type;
-        cstr_new (&str);
-        cstr_printf (&str, "%s:T%d=e",
-                     (t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
-                     ? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL),
-                     debug_type);
-        while (t->next) {
-            t = t->next;
-            cstr_printf (&str, "%s:",
-                         (t->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
-                         ? "" : get_tok_str(t->v & ~SYM_FIELD, NULL));
-            cstr_printf (&str, e->type.t & VT_UNSIGNED ? "%u," : "%d,",
-                         (int)t->enum_val);
-        }
-        cstr_printf (&str, ";");
-        tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0);
-        cstr_free (&str);
-    }
-    else if ((type & VT_BTYPE) != VT_FUNC) {
-        type &= ~VT_STRUCT_MASK;
-        for (debug_type = 1;
-             debug_type <= sizeof(default_debug) / sizeof(default_debug[0]);
-             debug_type++)
-            if (default_debug[debug_type - 1].type == type)
-                break;
-        if (debug_type > sizeof(default_debug) / sizeof(default_debug[0]))
-            return;
-    }
-    if (n > 0)
-        cstr_printf (result, "%d=", ++debug_next_type);
-    t = s;
-    for (;;) {
-        type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE);
-        if ((type & VT_BTYPE) != VT_BYTE)
-            type &= ~VT_DEFSIGN;
-        if (type == VT_PTR)
-            cstr_printf (result, "%d=*", ++debug_next_type);
-        else if (type == (VT_PTR | VT_ARRAY))
-            cstr_printf (result, "%d=ar1;0;%d;",
-                         ++debug_next_type, t->type.ref->c - 1);
-        else if (type == VT_FUNC) {
-            cstr_printf (result, "%d=f", ++debug_next_type);
-            tcc_get_debug_info (s1, t->type.ref, result);
-            return;
-        }
-        else
-            break;
-        t = t->type.ref;
-    }
-    cstr_printf (result, "%d", debug_type);
-}
-
-static void tcc_debug_finish (TCCState *s1, struct debug_info *cur)
-{
-    while (cur) {
-        int i;
-        struct debug_info *next = cur->next;
-
-        for (i = 0; i < cur->n_sym; i++) {
-            struct debug_sym *s = &cur->sym[i];
-
-            if (s->sec)
-                put_stabs_r(s1, s->str, s->type, 0, 0, s->value,
-                            s->sec, s->sym_index);
-            else
-                put_stabs(s1, s->str, s->type, 0, 0, s->value);
-            tcc_free (s->str);
-        }
-        tcc_free (cur->sym);
-        put_stabn(s1, N_LBRAC, 0, 0, cur->start);
-        tcc_debug_finish (s1, cur->child);
-        put_stabn(s1, N_RBRAC, 0, 0, cur->end);
-        tcc_free (cur);
-        cur = next;
-    }
-}
-
-static void tcc_add_debug_info(TCCState *s1, int param, Sym *s, Sym *e)
-{
-    CString debug_str;
-    if (!s1->do_debug)
-        return;
-    cstr_new (&debug_str);
-    for (; s != e; s = s->prev) {
-        if (!s->v || (s->r & VT_VALMASK) != VT_LOCAL)
-            continue;
-        cstr_reset (&debug_str);
-        cstr_printf (&debug_str, "%s:%s", get_tok_str(s->v, NULL), param ? "p" : "");
-        tcc_get_debug_info(s1, s, &debug_str);
-        tcc_debug_stabs(s1, debug_str.data, param ? N_PSYM : N_LSYM, s->c, NULL, 0);
-    }
-    cstr_free (&debug_str);
-}
-
-/* put function symbol */
-static void tcc_debug_funcstart(TCCState *s1, Sym *sym)
-{
-    CString debug_str;
-    BufferedFile *f;
-    if (!s1->do_debug)
-        return;
-    debug_info_root = NULL;
-    debug_info = NULL;
-    tcc_debug_stabn(s1, N_LBRAC, ind - func_ind);
-    if (!(f = put_new_file(s1)))
-        return;
-    cstr_new (&debug_str);
-    cstr_printf(&debug_str, "%s:%c", funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
-    tcc_get_debug_info(s1, sym->type.ref, &debug_str);
-    put_stabs_r(s1, debug_str.data, N_FUN, 0, f->line_num, 0, cur_text_section, sym->c);
-    cstr_free (&debug_str);
-
-    tcc_debug_line(s1);
-}
-
-/* put function size */
-static void tcc_debug_funcend(TCCState *s1, int size)
-{
-    if (!s1->do_debug)
-        return;
-    tcc_debug_stabn(s1, N_RBRAC, size);
-    tcc_debug_finish (s1, debug_info_root);
-}
-
-
-static void tcc_debug_extern_sym(TCCState *s1, Sym *sym, int sh_num, int sym_bind, int sym_type)
-{
-    Section *s;
-    CString str;
-
-    if (!s1->do_debug)
-        return;
-    if (sym_type == STT_FUNC || sym->v >= SYM_FIRST_ANOM)
-        return;
-    s = s1->sections[sh_num];
-
-    cstr_new (&str);
-    cstr_printf (&str, "%s:%c",
-        get_tok_str(sym->v, NULL),
-        sym_bind == STB_GLOBAL ? 'G' : local_scope ? 'V' : 'S'
-        );
-    tcc_get_debug_info(s1, sym, &str);
-    if (sym_bind == STB_GLOBAL)
-        tcc_debug_stabs(s1, str.data, N_GSYM, 0, NULL, 0);
-    else
-        tcc_debug_stabs(s1, str.data,
-            (sym->type.t & VT_STATIC) && data_section == s
-            ? N_STSYM : N_LCSYM, 0, s, sym->c);
-    cstr_free (&str);
-}
-
-static void tcc_debug_typedef(TCCState *s1, Sym *sym)
-{
-    CString str;
-
-    if (!s1->do_debug)
-        return;
-    cstr_new (&str);
-    cstr_printf (&str, "%s:t",
-                 (sym->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
-                 ? "" : get_tok_str(sym->v & ~SYM_FIELD, NULL));
-    tcc_get_debug_info(s1, sym, &str);
-    tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0);
-    cstr_free (&str);
-}
-
-/* ------------------------------------------------------------------------- */
-/* for section layout see lib/tcov.c */
-
-static void tcc_tcov_block_end(int line);
-
-static void tcc_tcov_block_begin(void)
-{
-    SValue sv;
-    void *ptr;
-    unsigned long last_offset = tcov_data.offset;
-
-    tcc_tcov_block_end (0);
-    if (tcc_state->test_coverage == 0 || nocode_wanted)
-	return;
-
-    if (tcov_data.last_file_name == 0 ||
-	strcmp ((const char *)(tcov_section->data + tcov_data.last_file_name),
-		file->true_filename) != 0) {
-	char wd[1024];
-	CString cstr;
-
-	if (tcov_data.last_func_name)
-	    section_ptr_add(tcov_section, 1);
-	if (tcov_data.last_file_name)
-	    section_ptr_add(tcov_section, 1);
-	tcov_data.last_func_name = 0;
-	cstr_new (&cstr);
-	if (file->true_filename[0] == '/') {
-	    tcov_data.last_file_name = tcov_section->data_offset;
-	    cstr_printf (&cstr, "%s", file->true_filename);
-	}
-	else {
-	    getcwd (wd, sizeof(wd));
-	    tcov_data.last_file_name = tcov_section->data_offset + strlen(wd) + 1;
-	    cstr_printf (&cstr, "%s/%s", wd, file->true_filename);
-	}
-	ptr = section_ptr_add(tcov_section, cstr.size + 1);
-	strcpy((char *)ptr, cstr.data);
-#ifdef _WIN32
-        normalize_slashes((char *)ptr);
-#endif
-	cstr_free (&cstr);
-    }
-    if (tcov_data.last_func_name == 0 ||
-	strcmp ((const char *)(tcov_section->data + tcov_data.last_func_name),
-		funcname) != 0) {
-	size_t len;
-
-	if (tcov_data.last_func_name)
-	    section_ptr_add(tcov_section, 1);
-	tcov_data.last_func_name = tcov_section->data_offset;
-	len = strlen (funcname);
-	ptr = section_ptr_add(tcov_section, len + 1);
-	strcpy((char *)ptr, funcname);
-	section_ptr_add(tcov_section, -tcov_section->data_offset & 7);
-	ptr = section_ptr_add(tcov_section, 8);
-	write64le (ptr, file->line_num);
-    }
-    if (ind == tcov_data.ind && tcov_data.line == file->line_num)
-        tcov_data.offset = last_offset;
-    else {
-        Sym label = {0};
-        label.type.t = VT_LLONG | VT_STATIC;
-
-        ptr = section_ptr_add(tcov_section, 16);
-        tcov_data.line = file->line_num;
-        write64le (ptr, (tcov_data.line << 8) | 0xff);
-        put_extern_sym(&label, tcov_section,
-		       ((unsigned char *)ptr - tcov_section->data) + 8, 0);
-        sv.type = label.type;
-        sv.r = VT_SYM | VT_LVAL | VT_CONST;
-        sv.r2 = VT_CONST;
-        sv.c.i = 0;
-        sv.sym = &label;
-#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || \
-    defined TCC_TARGET_ARM || defined TCC_TARGET_ARM64 || \
-    defined TCC_TARGET_RISCV64
-        gen_increment_tcov (&sv);
-#else
-        vpushv(&sv);
-        inc(0, TOK_INC);
-        vpop();
-#endif
-        tcov_data.offset = (unsigned char *)ptr - tcov_section->data;
-        tcov_data.ind = ind;
-    }
-}
-
-static void tcc_tcov_block_end(int line)
-{
-    if (tcc_state->test_coverage == 0)
-	return;
-    if (tcov_data.offset) {
-	void *ptr = tcov_section->data + tcov_data.offset;
-	unsigned long long nline = line ? line : file->line_num;
-
-	write64le (ptr, (read64le (ptr) & 0xfffffffffull) | (nline << 36));
-	tcov_data.offset = 0;
-    }
-}
-
-static void tcc_tcov_check_line(int start)
-{
-    if (tcc_state->test_coverage == 0)
-	return;
-    if (tcov_data.line != file->line_num) {
-        if ((tcov_data.line + 1) != file->line_num) {
-	    tcc_tcov_block_end (tcov_data.line);
-	    if (start)
-                tcc_tcov_block_begin ();
-	}
-	else
-	    tcov_data.line = file->line_num;
-    }
-}
-
-static void tcc_tcov_start(void)
-{
-    if (tcc_state->test_coverage == 0)
-	return;
-    memset (&tcov_data, 0, sizeof (tcov_data));
-    if (tcov_section == NULL) {
-        tcov_section = new_section(tcc_state, ".tcov", SHT_PROGBITS,
-				   SHF_ALLOC | SHF_WRITE);
-	section_ptr_add(tcov_section, 4); // pointer to executable name
-    }
-}
-
-static void tcc_tcov_end(void)
-{
-    if (tcc_state->test_coverage == 0)
-	return;
-    if (tcov_data.last_func_name)
-        section_ptr_add(tcov_section, 1);
-    if (tcov_data.last_file_name)
-        section_ptr_add(tcov_section, 1);
-}
-
 /* ------------------------------------------------------------------------- */
 /* initialize vstack and types.  This must be done also for tcc -E */
 ST_FUNC void tccgen_init(TCCState *s1)
@@ -968,15 +382,14 @@ ST_FUNC int tccgen_compile(TCCState *s1)
 {
     cur_text_section = NULL;
     funcname = "";
+    func_ind = -1;
     anon_sym = SYM_FIRST_ANOM;
-    section_sym = 0;
-    const_wanted = 0;
-    nocode_wanted = 0x80000000;
+    nocode_wanted = DATA_ONLY_WANTED; /* no code outside of functions */
     local_scope = 0;
-    debug_modes = s1->do_debug | s1->test_coverage << 1;
+    debug_modes = (s1->do_debug ? 1 : 0) | s1->test_coverage << 1;
 
     tcc_debug_start(s1);
-    tcc_tcov_start ();
+    tcc_tcov_start (s1);
 #ifdef TCC_TARGET_ARM
     arm_init(s1);
 #endif
@@ -990,13 +403,13 @@ ST_FUNC int tccgen_compile(TCCState *s1)
     check_vstack();
     /* end of translation unit info */
     tcc_debug_end(s1);
-    tcc_tcov_end ();
+    tcc_tcov_end(s1);
     return 0;
 }
 
 ST_FUNC void tccgen_finish(TCCState *s1)
 {
-    cstr_free(&initstr);
+    tcc_debug_end(s1); /* just in case of errors: free memory */
     free_inline_functions(s1);
     sym_pop(&global_stack, NULL, 0);
     sym_pop(&local_stack, NULL, 0);
@@ -1005,6 +418,9 @@ ST_FUNC void tccgen_finish(TCCState *s1)
     /* free sym_pools */
     dynarray_reset(&sym_pools, &nb_sym_pools);
     sym_free_first = NULL;
+    global_label_stack = local_label_stack = NULL;
+    cstr_free(&initstr);
+    dynarray_reset(&stk_data, &nb_stk_data);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -1130,11 +546,11 @@ ST_FUNC void put_extern_sym2(Sym *sym, int sh_num,
     update_storage(sym);
 }
 
-ST_FUNC void put_extern_sym(Sym *sym, Section *section,
-                           addr_t value, unsigned long size)
+ST_FUNC void put_extern_sym(Sym *sym, Section *s, addr_t value, unsigned long size)
 {
-    int sh_num = section ? section->sh_num : SHN_UNDEF;
-    put_extern_sym2(sym, sh_num, value, size, 1);
+    if (nocode_wanted && (NODATA_WANTED || (s && s == cur_text_section)))
+        return;
+    put_extern_sym2(sym, s ? s->sh_num : SHN_UNDEF, value, size, 1);
 }
 
 /* add a new relocation entry to symbol 'sym' in section 's' */
@@ -1346,6 +762,63 @@ ST_FUNC void sym_pop(Sym **ptop, Sym *b, int keep)
 	*ptop = b;
 }
 
+/* label lookup */
+ST_FUNC Sym *label_find(int v)
+{
+    v -= TOK_IDENT;
+    if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
+        return NULL;
+    return table_ident[v]->sym_label;
+}
+
+ST_FUNC Sym *label_push(Sym **ptop, int v, int flags)
+{
+    Sym *s, **ps;
+    s = sym_push2(ptop, v, VT_STATIC, 0);
+    s->r = flags;
+    ps = &table_ident[v - TOK_IDENT]->sym_label;
+    if (ptop == &global_label_stack) {
+        /* modify the top most local identifier, so that
+           sym_identifier will point to 's' when popped */
+        while (*ps != NULL)
+            ps = &(*ps)->prev_tok;
+    }
+    s->prev_tok = *ps;
+    *ps = s;
+    return s;
+}
+
+/* pop labels until element last is reached. Look if any labels are
+   undefined. Define symbols if '&&label' was used. */
+ST_FUNC void label_pop(Sym **ptop, Sym *slast, int keep)
+{
+    Sym *s, *s1;
+    for(s = *ptop; s != slast; s = s1) {
+        s1 = s->prev;
+        if (s->r == LABEL_DECLARED) {
+            tcc_warning_c(warn_all)("label '%s' declared but not used", get_tok_str(s->v, NULL));
+        } else if (s->r == LABEL_FORWARD) {
+                tcc_error("label '%s' used but not defined",
+                      get_tok_str(s->v, NULL));
+        } else {
+            if (s->c) {
+                /* define corresponding symbol. A size of
+                   1 is put. */
+                put_extern_sym(s, cur_text_section, s->jnext, 1);
+            }
+        }
+        /* remove label */
+        if (s->r != LABEL_GONE)
+            table_ident[s->v - TOK_IDENT]->sym_label = s->prev_tok;
+        if (!keep)
+            sym_free(s);
+        else
+            s->r = LABEL_GONE;
+    }
+    if (!keep)
+        *ptop = slast;
+}
+
 /* ------------------------------------------------------------------------- */
 static void vcheck_cmp(void)
 {
@@ -1361,7 +834,13 @@ static void vcheck_cmp(void)
        again, so that the VT_CMP/VT_JMP value will be in vtop
        when code is unsuppressed again. */
 
-    if (vtop->r == VT_CMP && !nocode_wanted)
+    /* However if it's just automatic suppression via CODE_OFF/ON()
+       then it seems that we better let things work undisturbed.
+       How can it work at all under nocode_wanted?  Well, gv() will
+       actually clear it at the gsym() in load()/VT_JMP in the
+       generator backends */
+
+    if (vtop->r == VT_CMP && 0 == (nocode_wanted & ~CODE_OFF_BIT))
         gv(RC_INT);
 }
 
@@ -1526,9 +1005,11 @@ static void vset_VT_JMP(void)
     int op = vtop->cmp_op;
 
     if (vtop->jtrue || vtop->jfalse) {
+        int origt = vtop->type.t;
         /* we need to jump to 'mov $0,%R' or 'mov $1,%R' */
         int inv = op & (op < 2); /* small optimization */
         vseti(VT_JMP+inv, gvtst(inv, 0));
+        vtop->type.t |= origt & (VT_UNSIGNED | VT_DEFSIGN);
     } else {
         /* otherwise convert flags (rsp. 0/1) to register */
         vtop->c.i = op;
@@ -1663,6 +1144,7 @@ static void merge_symattr(struct SymAttr *sa, struct SymAttr *sa1)
       sa->aligned = sa1->aligned;
     sa->packed |= sa1->packed;
     sa->weak |= sa1->weak;
+    sa->nodebug |= sa1->nodebug;
     if (sa1->visibility != STV_DEFAULT) {
 	int vis = sa->visibility;
 	if (vis == STV_DEFAULT
@@ -2205,14 +1687,22 @@ static void pop_local_syms(Sym *b, int keep)
     sym_pop(&local_stack, b, keep);
 }
 
-static void incr_bf_adr(int o)
+/* increment an lvalue pointer */
+static void incr_offset(int offset)
 {
-    vtop->type = char_pointer_type;
-    gaddrof();
-    vpushs(o);
+    int t = vtop->type.t;
+    gaddrof(); /* remove VT_LVAL */
+    vtop->type.t = VT_PTRDIFF_T; /* set scalar type */
+    vpushs(offset);
     gen_op('+');
-    vtop->type.t = VT_BYTE | VT_UNSIGNED;
     vtop->r |= VT_LVAL;
+    vtop->type.t = t;
+}
+
+static void incr_bf_adr(int o)
+{
+    vtop->type.t = VT_BYTE | VT_UNSIGNED;
+    incr_offset(o);
 }
 
 /* single-byte load mode for packed or otherwise unaligned bitfields */
@@ -2378,8 +1868,18 @@ ST_FUNC int gv(int rc)
         r2_ok = !rc2 || ((vtop->r2 < VT_CONST) && (reg_classes[vtop->r2] & rc2));
 
         if (!r_ok || !r2_ok) {
-            if (!r_ok)
-                r = get_reg(rc);
+
+            if (!r_ok) {
+                if (1 /* we can 'mov (r),r' in cases */
+                    && r < VT_CONST
+                    && (reg_classes[r] & rc)
+                    && !rc2
+                    )
+                    save_reg_upstack(r, 1);
+                else
+                    r = get_reg(rc);
+            }
+
             if (rc2) {
                 int load_type = (bt == VT_QFLOAT) ? VT_DOUBLE : VT_PTRDIFF_T;
                 int original_type = vtop->type.t;
@@ -2403,12 +1903,7 @@ ST_FUNC int gv(int rc)
                     vdup();
                     vtop[-1].r = r; /* save register value */
                     /* increment pointer to get second word */
-                    vtop->type.t = VT_PTRDIFF_T;
-                    gaddrof();
-                    vpushs(PTR_SIZE);
-                    gen_op('+');
-                    vtop->r |= VT_LVAL;
-                    vtop->type.t = load_type;
+                    incr_offset(PTR_SIZE);
                 } else {
                     /* move registers */
                     if (!r_ok)
@@ -2803,6 +2298,7 @@ static void gen_opic(int op)
     uint64_t l1 = c1 ? v1->c.i : 0;
     uint64_t l2 = c2 ? v2->c.i : 0;
     int shm = (t1 == VT_LLONG) ? 63 : 31;
+    int r;
 
     if (t1 != VT_LLONG && (PTR_SIZE != 8 || t1 != VT_PTR))
         l1 = ((uint32_t)l1 |
@@ -2827,7 +2323,7 @@ static void gen_opic(int op)
         case TOK_UMOD:
             /* if division by zero, generate explicit division */
             if (l2 == 0) {
-                if (const_wanted && !(nocode_wanted & unevalmask))
+                if (CONST_WANTED && !NOEVAL_WANTED)
                     tcc_error("division by zero in constant");
                 goto general_case;
             }
@@ -2864,6 +2360,7 @@ static void gen_opic(int op)
 	    l1 = ((uint32_t)l1 |
 		(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000)));
         v1->c.i = l1;
+        v1->r |= v2->r & VT_NONCONST;
         vtop--;
     } else {
         /* if commutative ops, put c2 as constant */
@@ -2873,14 +2370,12 @@ static void gen_opic(int op)
             c2 = c1; //c = c1, c1 = c2, c2 = c;
             l2 = l1; //l = l1, l1 = l2, l2 = l;
         }
-        if (!const_wanted &&
-            c1 && ((l1 == 0 &&
+        if (c1 && ((l1 == 0 &&
                     (op == TOK_SHL || op == TOK_SHR || op == TOK_SAR)) ||
                    (l1 == -1 && op == TOK_SAR))) {
             /* treat (0 << x), (0 >> x) and (-1 >> x) as constant */
-            vtop--;
-        } else if (!const_wanted &&
-                   c2 && ((l2 == 0 && (op == '&' || op == '*')) ||
+            vpop();
+        } else if (c2 && ((l2 == 0 && (op == '&' || op == '*')) ||
                           (op == '|' &&
                             (l2 == -1 || (l2 == 0xFFFFFFFF && t2 != VT_LLONG))) ||
                           (l2 == 1 && (op == '%' || op == TOK_UMOD)))) {
@@ -2917,8 +2412,8 @@ static void gen_opic(int op)
             }
             goto general_case;
         } else if (c2 && (op == '+' || op == '-') &&
-                   (((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM))
-                    || (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) {
+                   (r = vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM),
+                    r == (VT_CONST | VT_SYM) || r == VT_LOCAL)) {
             /* symbol + constant case */
             if (op == '-')
                 l2 = -l2;
@@ -2938,6 +2433,8 @@ static void gen_opic(int op)
                 else
                     gen_opi(op);
         }
+        if (vtop->r == VT_CONST)
+            vtop->r |= VT_NONCONST; /* is const, but only by optimization */
     }
 }
 
@@ -2977,7 +2474,7 @@ void gen_negf(int op)
 /* generate a floating point operation with constant propagation */
 static void gen_opif(int op)
 {
-    int c1, c2;
+    int c1, c2, i, bt;
     SValue *v1, *v2;
 #if defined _MSC_VER && defined __x86_64__
     /* avoid bad optimization with f1 -= f2 for f1:-0.0, f2:0.0 */
@@ -2989,15 +2486,16 @@ static void gen_opif(int op)
     v2 = vtop;
     if (op == TOK_NEG)
         v1 = v2;
+    bt = v1->type.t & VT_BTYPE;
 
     /* currently, we cannot do computations with forward symbols */
     c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
     c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
     if (c1 && c2) {
-        if (v1->type.t == VT_FLOAT) {
+        if (bt == VT_FLOAT) {
             f1 = v1->c.f;
             f2 = v2->c.f;
-        } else if (v1->type.t == VT_DOUBLE) {
+        } else if (bt == VT_DOUBLE) {
             f1 = v1->c.d;
             f2 = v2->c.d;
         } else {
@@ -3006,7 +2504,7 @@ static void gen_opif(int op)
         }
         /* NOTE: we only do constant propagation if finite number (not
            NaN or infinity) (ANSI spec) */
-        if (!(ieee_finite(f1) || !ieee_finite(f2)) && !const_wanted)
+        if (!(ieee_finite(f1) || !ieee_finite(f2)) && !CONST_WANTED)
             goto general_case;
         switch(op) {
         case '+': f1 += f2; break;
@@ -3017,7 +2515,7 @@ static void gen_opif(int op)
                 union { float f; unsigned u; } x1, x2, y;
 		/* If not in initializer we need to potentially generate
 		   FP exceptions at runtime, otherwise we want to fold.  */
-                if (!const_wanted)
+                if (!CONST_WANTED)
                     goto general_case;
                 /* the run-time result of 0.0/0.0 on x87, also of other compilers
                    when used to compile the f1 /= f2 below, would be -nan */
@@ -3035,16 +2533,36 @@ static void gen_opif(int op)
         case TOK_NEG:
             f1 = -f1;
             goto unary_result;
-            /* XXX: also handles tests ? */
+        case TOK_EQ:
+            i = f1 == f2;
+	make_int:
+            vtop -= 2;
+            vpushi(i);
+            return;
+        case TOK_NE:
+            i = f1 != f2;
+	    goto make_int;
+        case TOK_LT:
+            i = f1 < f2;
+	    goto make_int;
+        case TOK_GE:
+            i = f1 >= f2;
+	    goto make_int;
+        case TOK_LE:
+            i = f1 <= f2;
+	    goto make_int;
+        case TOK_GT:
+            i = f1 > f2;
+	    goto make_int;
         default:
             goto general_case;
         }
         vtop--;
     unary_result:
         /* XXX: overflow test ? */
-        if (v1->type.t == VT_FLOAT) {
+        if (bt == VT_FLOAT) {
             v1->c.f = f1;
-        } else if (v1->type.t == VT_DOUBLE) {
+        } else if (bt == VT_DOUBLE) {
             v1->c.d = f1;
         } else {
             v1->c.ld = f1;
@@ -3222,7 +2740,7 @@ static int pointed_size(CType *type)
 
 static inline int is_null_pointer(SValue *p)
 {
-    if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
+    if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM | VT_NONCONST)) != VT_CONST)
         return 0;
     return ((p->type.t & VT_BTYPE) == VT_INT && (uint32_t)p->c.i == 0) ||
         ((p->type.t & VT_BTYPE) == VT_LLONG && p->c.i == 0) ||
@@ -3452,8 +2970,7 @@ ST_FUNC void gen_op(int op)
 	}
 	goto redo;
     } else if (!combine_types(&combtype, vtop - 1, vtop, op)) {
-        tcc_error_noabort("invalid operand types for binary operation");
-        vpop();
+        tcc_error("invalid operand types for binary operation");
     } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
         /* at least one operand is a pointer */
         /* relational op: must be both pointers */
@@ -3488,7 +3005,7 @@ ST_FUNC void gen_op(int op)
             vpush_type_size(pointed_type(&vtop[-1].type), &align);
             gen_op('*');
 #ifdef CONFIG_TCC_BCHECK
-            if (tcc_state->do_bounds_check && !const_wanted) {
+            if (tcc_state->do_bounds_check && !CONST_WANTED) {
                 /* if bounded pointers, we generate a special code to
                    test bounds */
                 if (op == '-') {
@@ -3671,7 +3188,10 @@ static void gen_cast(CType *type)
 
         c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
 #if !defined TCC_IS_NATIVE && !defined TCC_IS_NATIVE_387
-        c &= (dbt != VT_LDOUBLE) | !!nocode_wanted;
+        /* don't try to convert to ldouble when cross-compiling
+           (except when it's '0' which is needed for arm:gen_negf()) */
+        if (dbt_bt == VT_LDOUBLE && !nocode_wanted && (sf || vtop->c.i != 0))
+            c = 0;
 #endif
         if (c) {
             /* constant case: we can do it now */
@@ -3735,7 +3255,7 @@ static void gen_cast(CType *type)
         }
 
         /* cannot generate code for global or static initializers */
-        if (STATIC_DATA_WANTED)
+        if (nocode_wanted & DATA_ONLY_WANTED)
             goto done;
 
         /* non constant case: generate code */
@@ -4089,25 +3609,42 @@ ST_FUNC void vstore(void)
     ft = vtop[-1].type.t;
     sbt = vtop->type.t & VT_BTYPE;
     dbt = ft & VT_BTYPE;
-
     verify_assign_cast(&vtop[-1].type);
 
     if (sbt == VT_STRUCT) {
         /* if structure, only generate pointer */
         /* structure assignment : generate memcpy */
-        /* XXX: optimize if small size */
-            size = type_size(&vtop->type, &align);
-
-            /* destination */
-            vswap();
+        size = type_size(&vtop->type, &align);
+        /* destination, keep on stack() as result */
+        vpushv(vtop - 1);
 #ifdef CONFIG_TCC_BCHECK
-            if (vtop->r & VT_MUSTBOUND)
-                gbound(); /* check would be wrong after gaddrof() */
+        if (vtop->r & VT_MUSTBOUND)
+            gbound(); /* check would be wrong after gaddrof() */
 #endif
-            vtop->type.t = VT_PTR;
-            gaddrof();
+        vtop->type.t = VT_PTR;
+        gaddrof();
+        /* source */
+        vswap();
+#ifdef CONFIG_TCC_BCHECK
+        if (vtop->r & VT_MUSTBOUND)
+            gbound();
+#endif
+        vtop->type.t = VT_PTR;
+        gaddrof();
 
-            /* address of memcpy() */
+#ifdef TCC_TARGET_NATIVE_STRUCT_COPY
+        if (1
+#ifdef CONFIG_TCC_BCHECK
+            && !tcc_state->do_bounds_check
+#endif
+            ) {
+            gen_struct_copy(size);
+        } else
+#endif
+        {
+            /* type size */
+            vpushi(size);
+            /* Use memmove, rather than memcpy, as dest and src may be same: */
 #ifdef TCC_ARM_EABI
             if(!(align & 7))
                 vpush_helper_func(TOK_memmove8);
@@ -4115,22 +3652,10 @@ ST_FUNC void vstore(void)
                 vpush_helper_func(TOK_memmove4);
             else
 #endif
-            /* Use memmove, rather than memcpy, as dest and src may be same: */
             vpush_helper_func(TOK_memmove);
-
-            vswap();
-            /* source */
-            vpushv(vtop - 2);
-#ifdef CONFIG_TCC_BCHECK
-            if (vtop->r & VT_MUSTBOUND)
-                gbound();
-#endif
-            vtop->type.t = VT_PTR;
-            gaddrof();
-            /* type size */
-            vpushi(size);
+            vrott(4);
             gfunc_call(3);
-        /* leave source on stack */
+        }
 
     } else if (ft & VT_BITFIELD) {
         /* bitfield store handling */
@@ -4235,14 +3760,8 @@ ST_FUNC void vstore(void)
                 vtop[-1].type.t = load_type;
                 store(r, vtop - 1);
                 vswap();
-                /* convert to int to increment easily */
-                vtop->type.t = VT_PTRDIFF_T;
-                gaddrof();
-                vpushs(PTR_SIZE);
-                gen_op('+');
-                vtop->r |= VT_LVAL;
+                incr_offset(PTR_SIZE);
                 vswap();
-                vtop[-1].type.t = load_type;
                 /* XXX: it works because r2 is spilled last ! */
                 store(vtop->r2, vtop - 1);
             } else {
@@ -4272,18 +3791,19 @@ ST_FUNC void inc(int post, int c)
         vpop(); /* if post op, return saved value */
 }
 
-ST_FUNC void parse_mult_str (CString *astr, const char *msg)
+ST_FUNC CString* parse_mult_str (const char *msg)
 {
     /* read the string */
     if (tok != TOK_STR)
         expect(msg);
-    cstr_new(astr);
+    cstr_reset(&initstr);
     while (tok == TOK_STR) {
         /* XXX: add \0 handling too ? */
-        cstr_cat(astr, tokc.str.data, -1);
+        cstr_cat(&initstr, tokc.str.data, -1);
         next();
     }
-    cstr_ccat(astr, '\0');
+    cstr_ccat(&initstr, '\0');
+    return &initstr;
 }
 
 /* If I is >= 1 and a power of two, returns log2(i)+1.
@@ -4308,7 +3828,7 @@ ST_FUNC int exact_log2p1(int i)
 static void parse_attribute(AttributeDef *ad)
 {
     int t, n;
-    CString astr;
+    char *astr;
     
 redo:
     if (tok != TOK_ATTRIBUTE1 && tok != TOK_ATTRIBUTE2)
@@ -4355,37 +3875,33 @@ static void parse_attribute(AttributeDef *ad)
         case TOK_SECTION1:
         case TOK_SECTION2:
             skip('(');
-	    parse_mult_str(&astr, "section name");
-            ad->section = find_section(tcc_state, (char *)astr.data);
+	    astr = parse_mult_str("section name")->data;
+            ad->section = find_section(tcc_state, astr);
             skip(')');
-	    cstr_free(&astr);
             break;
         case TOK_ALIAS1:
         case TOK_ALIAS2:
             skip('(');
-	    parse_mult_str(&astr, "alias(\"target\")");
-            ad->alias_target = /* save string as token, for later */
-                tok_alloc((char*)astr.data, astr.size-1)->tok;
+	    astr = parse_mult_str("alias(\"target\")")->data;
+            /* save string as token, for later */
+            ad->alias_target = tok_alloc_const(astr);
             skip(')');
-	    cstr_free(&astr);
             break;
 	case TOK_VISIBILITY1:
 	case TOK_VISIBILITY2:
             skip('(');
-	    parse_mult_str(&astr,
-			   "visibility(\"default|hidden|internal|protected\")");
-	    if (!strcmp (astr.data, "default"))
+	    astr = parse_mult_str("visibility(\"default|hidden|internal|protected\")")->data;
+	    if (!strcmp (astr, "default"))
 	        ad->a.visibility = STV_DEFAULT;
-	    else if (!strcmp (astr.data, "hidden"))
+	    else if (!strcmp (astr, "hidden"))
 	        ad->a.visibility = STV_HIDDEN;
-	    else if (!strcmp (astr.data, "internal"))
+	    else if (!strcmp (astr, "internal"))
 	        ad->a.visibility = STV_INTERNAL;
-	    else if (!strcmp (astr.data, "protected"))
+	    else if (!strcmp (astr, "protected"))
 	        ad->a.visibility = STV_PROTECTED;
 	    else
                 expect("visibility(\"default|hidden|internal|protected\")");
             skip(')');
-	    cstr_free(&astr);
             break;
         case TOK_ALIGNED1:
         case TOK_ALIGNED2:
@@ -4410,6 +3926,10 @@ static void parse_attribute(AttributeDef *ad)
         case TOK_WEAK2:
             ad->a.weak = 1;
             break;
+        case TOK_NODEBUG1:
+        case TOK_NODEBUG2:
+            ad->a.nodebug = 1;
+            break;
         case TOK_UNUSED1:
         case TOK_UNUSED2:
             /* currently, no need to handle it because tcc does not
@@ -4507,20 +4027,33 @@ static void parse_attribute(AttributeDef *ad)
 static Sym * find_field (CType *type, int v, int *cumofs)
 {
     Sym *s = type->ref;
-    v |= SYM_FIELD;
+    int v1 = v | SYM_FIELD;
+    if (!(v & SYM_FIELD)) { /* top-level call */
+        if ((type->t & VT_BTYPE) != VT_STRUCT)
+            expect("struct or union");
+        if (v < TOK_UIDENT)
+            expect("field name");
+        if (s->c < 0)
+            tcc_error("dereferencing incomplete type '%s'",
+                get_tok_str(s->v & ~SYM_STRUCT, 0));
+    }
     while ((s = s->next) != NULL) {
-	if ((s->v & SYM_FIELD) &&
-	    (s->type.t & VT_BTYPE) == VT_STRUCT &&
-	    (s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
-	    Sym *ret = find_field (&s->type, v, cumofs);
-	    if (ret) {
+        if (s->v == v1) {
+            *cumofs = s->c;
+            return s;
+        }
+        if ((s->type.t & VT_BTYPE) == VT_STRUCT
+          && s->v >= (SYM_FIRST_ANOM | SYM_FIELD)) {
+            /* try to find field in anonymous sub-struct/union */
+            Sym *ret = find_field (&s->type, v1, cumofs);
+            if (ret) {
                 *cumofs += s->c;
-	        return ret;
+                return ret;
             }
-	}
-	if (s->v == v)
-	  break;
+        }
     }
+    if (!(v & SYM_FIELD))
+        tcc_error("field not found: %s", get_tok_str(v, NULL));
     return s;
 }
 
@@ -4789,6 +4322,8 @@ static void struct_layout(CType *type, AttributeDef *ad)
     }
 }
 
+static void do_Static_assert(void);
+
 /* enum/struct/union declaration. u is VT_ENUM/VT_STRUCT/VT_UNION */
 static void struct_decl(CType *type, int u)
 {
@@ -4898,7 +4433,11 @@ static void struct_decl(CType *type, int u)
             c = 0;
             flexible = 0;
             while (tok != '}') {
-                if (!parse_btype(&btype, &ad1)) {
+                if (tok == TOK_STATIC_ASSERT) {
+                    do_Static_assert();
+                    continue;
+                }
+                if (!parse_btype(&btype, &ad1, 0)) {
 		    skip(';');
 		    continue;
 		}
@@ -5005,6 +4544,8 @@ static void struct_decl(CType *type, int u)
 	    check_fields(type, 1);
 	    check_fields(type, 0);
             struct_layout(type, &ad);
+	    if (debug_modes)
+		tcc_debug_fix_anon(tcc_state, type);
         }
     }
 }
@@ -5029,7 +4570,7 @@ static void parse_btype_qualify(CType *type, int qualifiers)
 /* return 0 if no type declaration. otherwise, return the basic type
    and skip it. 
  */
-static int parse_btype(CType *type, AttributeDef *ad)
+static int parse_btype(CType *type, AttributeDef *ad, int ignore_label)
 {
     int t, u, bt, st, type_found, typespec_found, g, n;
     Sym *s;
@@ -5083,7 +4624,7 @@ static int parse_btype(CType *type, AttributeDef *ad)
               next();
               skip('(');
               memset(&ad1, 0, sizeof(AttributeDef));
-              if (parse_btype(&type1, &ad1)) {
+              if (parse_btype(&type1, &ad1, 0)) {
                   type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
                   if (ad1.a.aligned)
                     n = 1 << (ad1.a.aligned - 1);
@@ -5091,7 +4632,7 @@ static int parse_btype(CType *type, AttributeDef *ad)
                     type_size(&type1, &n);
               } else {
                   n = expr_const();
-                  if (n <= 0 || (n & (n - 1)) != 0)
+                  if (n < 0 || (n & (n - 1)) != 0)
                     tcc_error("alignment must be a positive power of two");
               }
               skip(')');
@@ -5119,6 +4660,8 @@ static int parse_btype(CType *type, AttributeDef *ad)
         case TOK_BOOL:
             u = VT_BOOL;
             goto basic_type;
+        case TOK_COMPLEX:
+            tcc_error("_Complex is not yet supported");
         case TOK_FLOAT:
             u = VT_FLOAT;
             goto basic_type;
@@ -5245,6 +4788,8 @@ static int parse_btype(CType *type, AttributeDef *ad)
 	    if (type1.ref)
                 sym_to_attr(ad, type1.ref);
             goto basic_type2;
+        case TOK_THREAD_LOCAL:
+            tcc_error("_Thread_local is not implemented");
         default:
             if (typespec_found)
                 goto the_end;
@@ -5253,7 +4798,7 @@ static int parse_btype(CType *type, AttributeDef *ad)
                 goto the_end;
 
             n = tok, next();
-            if (tok == ':' && !in_generic) {
+            if (tok == ':' && ignore_label) {
                 /* ignore if it's a label */
                 unget_tok(n);
                 goto the_end;
@@ -5305,32 +4850,31 @@ static inline void convert_parameter_type(CType *pt)
     }
 }
 
-ST_FUNC void parse_asm_str(CString *astr)
+ST_FUNC CString* parse_asm_str(void)
 {
     skip('(');
-    parse_mult_str(astr, "string constant");
+    return parse_mult_str("string constant");
 }
 
 /* Parse an asm label and return the token */
 static int asm_label_instr(void)
 {
     int v;
-    CString astr;
+    char *astr;
 
     next();
-    parse_asm_str(&astr);
+    astr = parse_asm_str()->data;
     skip(')');
 #ifdef ASM_DEBUG
-    printf("asm_alias: \"%s\"\n", (char *)astr.data);
+    printf("asm_alias: \"%s\"\n", astr);
 #endif
-    v = tok_alloc(astr.data, astr.size - 1)->tok;
-    cstr_free(&astr);
+    v = tok_alloc_const(astr);
     return v;
 }
 
 static int post_type(CType *type, AttributeDef *ad, int storage, int td)
 {
-    int n, l, t1, arg_size, align, unused_align;
+    int n, l, t1, arg_size, align;
     Sym **plast, *s, *first;
     AttributeDef ad1;
     CType pt;
@@ -5344,7 +4888,7 @@ static int post_type(CType *type, AttributeDef *ad, int storage, int td)
 	  return 0;
 	if (tok == ')')
 	  l = 0;
-	else if (parse_btype(&pt, &ad1))
+	else if (parse_btype(&pt, &ad1, 0))
 	  l = FUNC_NEW;
 	else if (td & (TYPE_DIRECT|TYPE_ABSTRACT)) {
 	    merge_attr (ad, &ad1);
@@ -5377,7 +4921,10 @@ static int post_type(CType *type, AttributeDef *ad, int storage, int td)
                     expect("identifier");
                 convert_parameter_type(&pt);
                 arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE;
-                s = sym_push(n, &pt, 0, 0);
+                /* these symbols may be evaluated for VLArrays (see below, under
+                   nocode_wanted) which is why we push them here as normal symbols
+                   temporarily.  Example: int func(int a, int b[++a]); */
+                s = sym_push(n, &pt, VT_LOCAL|VT_LVAL, 0);
                 *plast = s;
                 plast = &s->next;
                 if (tok == ')')
@@ -5388,7 +4935,7 @@ static int post_type(CType *type, AttributeDef *ad, int storage, int td)
                     next();
                     break;
                 }
-		if (l == FUNC_NEW && !parse_btype(&pt, &ad1))
+		if (l == FUNC_NEW && !parse_btype(&pt, &ad1, 0))
 		    tcc_error("invalid type");
             }
         } else
@@ -5444,26 +4991,11 @@ static int post_type(CType *type, AttributeDef *ad, int storage, int td)
 		break;
 	    }
             if (tok != ']') {
-		int nest = 1;
-
 		/* Code generation is not done now but has to be done
 		   at start of function. Save code here for later use. */
 	        nocode_wanted = 1;
-		vla_array_tok = tok_str_alloc();
-		for (;;) {
-		    if (tok == ']') {
-			nest--;
-			if (nest == 0)
-			    break;
-		    }
-		    if (tok == '[')
-			nest++;
-		    tok_str_add_tok(vla_array_tok);
-		    next();
-		}
+		skip_or_save_block(&vla_array_tok);
 		unget_tok(0);
-		tok_str_add(vla_array_tok, -1);
-		tok_str_add(vla_array_tok, 0);
 		vla_array_str = vla_array_tok->str;
 		begin_macro(vla_array_tok, 2);
 		next();
@@ -5504,7 +5036,7 @@ static int post_type(CType *type, AttributeDef *ad, int storage, int td)
         if ((type->t & VT_BTYPE) == VT_FUNC)
             tcc_error("declaration of an array of functions");
         if ((type->t & VT_BTYPE) == VT_VOID
-            || type_size(type, &unused_align) < 0)
+            || type_size(type, &align) < 0)
             tcc_error("declaration of an array of incomplete type elements");
 
         t1 |= type->t & VT_VLA;
@@ -5535,7 +5067,8 @@ static int post_type(CType *type, AttributeDef *ad, int storage, int td)
         s = sym_push(SYM_FIELD, type, 0, n);
         type->t = (t1 ? VT_VLA : VT_ARRAY) | VT_PTR;
         type->ref = s;
-	if (vla_array_str) {
+
+        if (vla_array_str) {
 	    if (t1 & VT_VLA)
 	        s->vla_array_str = vla_array_str;
 	    else
@@ -5620,7 +5153,8 @@ static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td)
 	  expect("identifier");
 	*v = 0;
     }
-    post_type(post, ad, storage, td & ~(TYPE_DIRECT|TYPE_ABSTRACT));
+    post_type(post, ad, post != ret ? 0 : storage,
+              td & ~(TYPE_DIRECT|TYPE_ABSTRACT));
     parse_attribute(ad);
     type->t |= storage;
     return ret;
@@ -5695,7 +5229,7 @@ static void parse_expr_type(CType *type)
     AttributeDef ad;
 
     skip('(');
-    if (parse_btype(type, &ad)) {
+    if (parse_btype(type, &ad, 0)) {
         type_decl(type, &ad, &n, TYPE_ABSTRACT);
     } else {
         expr_type(type, gexpr);
@@ -5708,7 +5242,7 @@ static void parse_type(CType *type)
     AttributeDef ad;
     int n;
 
-    if (!parse_btype(type, &ad)) {
+    if (!parse_btype(type, &ad, 0)) {
         expect("type");
     }
     type_decl(type, &ad, &n, TYPE_ABSTRACT);
@@ -5767,8 +5301,9 @@ static void parse_builtin_params(int nc, const char *args)
 
 static void parse_atomic(int atok)
 {
-    int size, align, arg;
+    int size, align, arg, t, save = 0;
     CType *atom, *atom_ptr, ct = {0};
+    SValue store;
     char buf[40];
     static const char *const templates[] = {
         /*
@@ -5781,19 +5316,28 @@ static void parse_atomic(int atok)
          * A read-only atomic
          * p pointer to memory
          * v value
+         * l load pointer
+         * s save pointer
          * m memory model
          */
 
         /* keep in order of appearance in tcctok.h: */
-        /* __atomic_store */            "avm.?",
-        /* __atomic_load */             "Am.v",
-        /* __atomic_exchange */         "avm.v",
-        /* __atomic_compare_exchange */ "apvbmm.b",
+        /* __atomic_store */            "alm.?",
+        /* __atomic_load */             "Asm.v",
+        /* __atomic_exchange */         "alsm.v",
+        /* __atomic_compare_exchange */ "aplbmm.b",
         /* __atomic_fetch_add */        "avm.v",
         /* __atomic_fetch_sub */        "avm.v",
         /* __atomic_fetch_or */         "avm.v",
         /* __atomic_fetch_xor */        "avm.v",
-        /* __atomic_fetch_and */        "avm.v"
+        /* __atomic_fetch_and */        "avm.v",
+        /* __atomic_fetch_nand */       "avm.v",
+        /* __atomic_and_fetch */        "avm.v",
+        /* __atomic_sub_fetch */        "avm.v",
+        /* __atomic_or_fetch */         "avm.v",
+        /* __atomic_xor_fetch */        "avm.v",
+        /* __atomic_and_fetch */        "avm.v",
+        /* __atomic_nand_fetch */       "avm.v"
     };
     const char *template = templates[(atok - TOK___atomic_store)];
 
@@ -5831,6 +5375,16 @@ static void parse_atomic(int atok)
         case 'v':
             gen_assign_cast(atom);
             break;
+        case 'l':
+            indir();
+            gen_assign_cast(atom);
+            break;
+        case 's':
+            save = 1;
+            indir();
+            store = *vtop;
+            vpop();
+            break;
         case 'm':
             gen_assign_cast(&int_type);
             break;
@@ -5857,18 +5411,26 @@ static void parse_atomic(int atok)
 
     sprintf(buf, "%s_%d", get_tok_str(atok, 0), size);
     vpush_helper_func(tok_alloc_const(buf));
-    vrott(arg + 1);
-    gfunc_call(arg);
+    vrott(arg - save + 1);
+    gfunc_call(arg - save);
 
     vpush(&ct);
     PUT_R_RET(vtop, ct.t);
-    if (ct.t == VT_BOOL) {
+    t = ct.t & VT_BTYPE;
+    if (t == VT_BYTE || t == VT_SHORT || t == VT_BOOL) {
 #ifdef PROMOTE_RET
-	vtop->r |= BFVAL(VT_MUSTCAST, 1);
+        vtop->r |= BFVAL(VT_MUSTCAST, 1);
 #else
-	vtop->type.t = VT_INT;
+        vtop->type.t = VT_INT;
 #endif
     }
+    gen_cast(&ct);
+    if (save) {
+        vpush(&ct);
+        *vtop = store;
+        vswap();
+        vstore();
+    }
 }
 
 ST_FUNC void unary(void)
@@ -5880,7 +5442,7 @@ ST_FUNC void unary(void)
 
     /* generate line number info */
     if (debug_modes)
-        tcc_debug_line(tcc_state), tcc_tcov_check_line (1);
+        tcc_debug_line(tcc_state), tcc_tcov_check_line (tcc_state, 1);
 
     sizeof_caller = in_sizeof;
     in_sizeof = 0;
@@ -5921,7 +5483,11 @@ ST_FUNC void unary(void)
         t = VT_DOUBLE;
 	goto push_tokc;
     case TOK_CLDOUBLE:
+#ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
+        t = VT_DOUBLE | VT_LONG;
+#else
         t = VT_LDOUBLE;
+#endif
 	goto push_tokc;
     case TOK_CLONG:
         t = (LONG_SIZE == 8 ? VT_LLONG : VT_INT) | VT_LONG;
@@ -5934,25 +5500,12 @@ ST_FUNC void unary(void)
             goto tok_identifier;
         /* fall thru */
     case TOK___FUNC__:
-        {
-            Section *sec;
-            int len;
-            /* special function name identifier */
-            len = strlen(funcname) + 1;
-            /* generate char[len] type */
-            type.t = char_type.t;
-            if (tcc_state->warn_write_strings & WARN_ON)
-                type.t |= VT_CONSTANT;
-            mk_pointer(&type);
-            type.t |= VT_ARRAY;
-            type.ref->c = len;
-            sec = rodata_section;
-            vpush_ref(&type, sec, sec->data_offset, len);
-            if (!NODATA_WANTED)
-                memcpy(section_ptr_add(sec, len), funcname, len);
-            next();
-        }
-        break;
+        tok = TOK_STR;
+        cstr_reset(&tokcstr);
+        cstr_cat(&tokcstr, funcname, 0);
+        tokc.str.size = tokcstr.size;
+        tokc.str.data = tokcstr.data;
+        goto case_TOK_STR;
     case TOK_LSTR:
 #ifdef TCC_TARGET_PE
         t = VT_SHORT | VT_UNSIGNED;
@@ -5961,6 +5514,7 @@ ST_FUNC void unary(void)
 #endif
         goto str_init;
     case TOK_STR:
+    case_TOK_STR:
         /* string parsing */
         t = char_type.t;
     str_init:
@@ -5976,7 +5530,7 @@ ST_FUNC void unary(void)
     case '(':
         next();
         /* cast ? */
-        if (parse_btype(&type, &ad)) {
+        if (parse_btype(&type, &ad, 0)) {
             type_decl(&type, &ad, &n, TYPE_ABSTRACT);
             skip(')');
             /* check ISOC99 compound literal */
@@ -6001,7 +5555,7 @@ ST_FUNC void unary(void)
             }
         } else if (tok == '{') {
 	    int saved_nocode_wanted = nocode_wanted;
-            if (const_wanted && !(nocode_wanted & unevalmask))
+            if (CONST_WANTED && !NOEVAL_WANTED)
                 expect("constant");
             if (0 == local_scope)
                 tcc_error("statement expression outside of function");
@@ -6013,9 +5567,12 @@ ST_FUNC void unary(void)
 	       outside, so any reactivation of code emission (from labels
 	       or loop heads) can be disabled again after the end of it. */
             block(1);
-            /* or'ing to keep however possible CODE_OFF() from e.g. "return 0;"
-               in the statement expression */
-	    nocode_wanted |= saved_nocode_wanted;
+            /* If the statement expr can be entered, then we retain the current
+               nocode_wanted state (from e.g. a 'return 0;' in the stmt-expr).
+               If it can't be entered then the state is that from before the
+               statement expression.  */
+            if (saved_nocode_wanted)
+              nocode_wanted = saved_nocode_wanted;
             skip(')');
         } else {
             gexpr();
@@ -6036,7 +5593,7 @@ ST_FUNC void unary(void)
            there and in function calls. */
         /* arrays can also be used although they are not lvalues */
         if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
-            !(vtop->type.t & VT_ARRAY))
+            !(vtop->type.t & (VT_ARRAY | VT_VLA)))
             test_lvalue();
         if (vtop->sym)
           vtop->sym->a.addrtaken = 1;
@@ -6130,8 +5687,10 @@ ST_FUNC void unary(void)
 	}
         break;
     case TOK_builtin_constant_p:
+	constant_p = 1;
 	parse_builtin_params(1, "e");
-	n = (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST &&
+	n = constant_p &&
+	    (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST &&
             !((vtop->r & VT_SYM) && vtop->sym->a.addrtaken);
 	vtop--;
 	vpushi(n);
@@ -6140,17 +5699,16 @@ ST_FUNC void unary(void)
     case TOK_builtin_return_address:
         {
             int tok1 = tok;
-            int level;
+            int64_t level;
             next();
             skip('(');
-            if (tok != TOK_CINT) {
+            level = expr_const64();
+            if (level < 0) {
                 tcc_error("%s only takes positive integers",
                           tok1 == TOK_builtin_return_address ?
                           "__builtin_return_address" :
                           "__builtin_frame_address");
             }
-            level = (uint32_t)tokc.i;
-            next();
             skip(')');
             type.t = VT_VOID;
             mk_pointer(&type);
@@ -6253,6 +5811,13 @@ ST_FUNC void unary(void)
     case TOK___atomic_fetch_or:
     case TOK___atomic_fetch_xor:
     case TOK___atomic_fetch_and:
+    case TOK___atomic_fetch_nand:
+    case TOK___atomic_add_fetch:
+    case TOK___atomic_sub_fetch:
+    case TOK___atomic_or_fetch:
+    case TOK___atomic_xor_fetch:
+    case TOK___atomic_and_fetch:
+    case TOK___atomic_nand_fetch:
         parse_atomic(tok);
         break;
 
@@ -6289,7 +5854,7 @@ ST_FUNC void unary(void)
             if (s->r == LABEL_DECLARED)
                 s->r = LABEL_FORWARD;
         }
-        if (!s->type.t) {
+        if ((s->type.t & VT_BTYPE) != VT_PTR) {
             s->type.t = VT_VOID;
             mk_pointer(&s->type);
             s->type.t |= VT_STATIC;
@@ -6305,17 +5870,17 @@ ST_FUNC void unary(void)
 	int has_match = 0;
 	int learn = 0;
 	TokenString *str = NULL;
-	int saved_const_wanted = const_wanted;
+	int saved_nocode_wanted = nocode_wanted;
+        nocode_wanted &= ~CONST_WANTED_MASK;
 
-	next();
+        next();
 	skip('(');
-	const_wanted = 0;
 	expr_type(&controlling_type, expr_eq);
-	controlling_type.t &= ~(VT_CONSTANT | VT_VOLATILE | VT_ARRAY);
-	if ((controlling_type.t & VT_BTYPE) == VT_FUNC)
-	  mk_pointer(&controlling_type);
-	const_wanted = saved_const_wanted;
-	for (;;) {
+	convert_parameter_type (&controlling_type);
+
+        nocode_wanted = saved_nocode_wanted;
+
+        for (;;) {
 	    learn = 0;
 	    skip(',');
 	    if (tok == TOK_DEFAULT) {
@@ -6330,10 +5895,7 @@ ST_FUNC void unary(void)
 		int itmp;
 	        CType cur_type;
 
-                in_generic++;
-		parse_btype(&cur_type, &ad_tmp);
-                in_generic--;
-
+		parse_btype(&cur_type, &ad_tmp, 0);
 		type_decl(&cur_type, &ad_tmp, &itmp, TYPE_ABSTRACT);
 		if (compare_types(&controlling_type, &cur_type, 0)) {
 		    if (has_match) {
@@ -6426,28 +5988,20 @@ ST_FUNC void unary(void)
         if (tok == TOK_INC || tok == TOK_DEC) {
             inc(1, tok);
             next();
-        } else if (tok == '.' || tok == TOK_ARROW || tok == TOK_CDOUBLE) {
-            int qualifiers, cumofs = 0;
+        } else if (tok == '.' || tok == TOK_ARROW) {
+            int qualifiers, cumofs;
             /* field */ 
             if (tok == TOK_ARROW) 
                 indir();
             qualifiers = vtop->type.t & (VT_CONSTANT | VT_VOLATILE);
             test_lvalue();
-            gaddrof();
             /* expect pointer on structure */
-            if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
-                expect("struct or union");
-            if (tok == TOK_CDOUBLE)
-                expect("field name");
             next();
-            if (tok == TOK_CINT || tok == TOK_CUINT)
-                expect("field name");
 	    s = find_field(&vtop->type, tok, &cumofs);
-            if (!s)
-                tcc_error("field not found: %s",  get_tok_str(tok & ~SYM_FIELD, &tokc));
             /* add field offset to pointer */
+            gaddrof();
             vtop->type = char_pointer_type; /* change type to 'char *' */
-            vpushi(cumofs + s->c);
+            vpushi(cumofs);
             gen_op('+');
             /* change type to field type, and set to lvalue */
             vtop->type = s->type;
@@ -6560,10 +6114,20 @@ ST_FUNC void unary(void)
 #endif
             } else {
                 /* return value */
-                for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) {
+                n = ret_nregs;
+                while (n > 1) {
+                    int rc = reg_classes[ret.r] & ~(RC_INT | RC_FLOAT);
+                    /* We assume that when a structure is returned in multiple
+                       registers, their classes are consecutive values of the
+                       suite s(n) = 2^n */
+                    rc <<= --n;
+                    for (r = 0; r < NB_REGS; ++r)
+                        if (reg_classes[r] & rc)
+                            break;
                     vsetc(&ret.type, r, &ret.c);
-                    vtop->r2 = ret.r2; /* Loop only happens when r2 is VT_CONST */
                 }
+                vsetc(&ret.type, ret.r, &ret.c);
+                vtop->r2 = ret.r2;
 
                 /* handle packed struct return */
                 if (((s->type.t & VT_BTYPE) == VT_STRUCT) && ret_nregs) {
@@ -6572,8 +6136,9 @@ ST_FUNC void unary(void)
                     size = type_size(&s->type, &align);
                     /* We're writing whole regs often, make sure there's enough
                        space.  Assume register size is power of 2.  */
-                    if (regsize > align)
-                      align = regsize;
+                    size = (size + regsize - 1) & -regsize;
+                    if (ret_align > align)
+                        align = ret_align;
                     loc = (loc - size) & -align;
                     addr = loc;
                     offset = 0;
@@ -6605,7 +6170,7 @@ ST_FUNC void unary(void)
             }
             if (s->f.func_noreturn) {
                 if (debug_modes)
-	            tcc_tcov_block_end (tcov_data.line);
+	            tcc_tcov_block_end(tcc_state, -1);
                 CODE_OFF();
 	    }
         } else {
@@ -6835,7 +6400,6 @@ static void expr_cond(void)
     int tt, u, r1, r2, rc, t1, t2, islv, c, g;
     SValue sv;
     CType type;
-    int ncw_prev;
 
     expr_lor();
     if (tok == '?') {
@@ -6858,7 +6422,6 @@ static void expr_cond(void)
             tt = gvtst(0, 0);
         }
 
-        ncw_prev = nocode_wanted;
         if (c == 0)
           nocode_wanted++;
         if (!g)
@@ -6877,12 +6440,21 @@ static void expr_cond(void)
         } else
           u = 0;
 
-        nocode_wanted = ncw_prev;
+        if (c == 0)
+          nocode_wanted--;
         if (c == 1)
           nocode_wanted++;
         skip(':');
         expr_cond();
 
+        if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
+          mk_pointer(&vtop->type);
+
+        /* cast operands to correct type according to ISOC rules */
+        if (!combine_types(&type, &sv, vtop, '?'))
+          type_incompatibility_error(&sv.type, &vtop->type,
+            "type mismatch in conditional expression (have '%s' and '%s')");
+
         if (c < 0 && is_cond_bool(vtop) && is_cond_bool(&sv)) {
             /* optimize "if (f ? a > b : c || d) ..." for example, where normally
                "a < b" and "c || d" would be forced to "(int)0/1" first, whereas
@@ -6894,18 +6466,11 @@ static void expr_cond(void)
             /* combine jump targets of 2nd op with VT_CMP of 1st op */
             gvtst_set(0, t1);
             gvtst_set(1, t2);
-            nocode_wanted = ncw_prev;
+            gen_cast(&type);
             //  tcc_warning("two conditions expr_cond");
             return;
         }
 
-        if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
-          mk_pointer(&vtop->type);
-
-        /* cast operands to correct type according to ISOC rules */
-        if (!combine_types(&type, &sv, vtop, '?'))
-          type_incompatibility_error(&sv.type, &vtop->type,
-            "type mismatch in conditional expression (have '%s' and '%s')");
         /* keep structs lvalue by transforming `(expr ? a : b)` to `*(expr ? &a : &b)` so
            that `(expr ? a : b).mem` does not error  with "lvalue expected" */
         islv = (vtop->r & VT_LVAL) && (sv.r & VT_LVAL) && VT_STRUCT == (type.t & VT_BTYPE);
@@ -6932,7 +6497,8 @@ static void expr_cond(void)
             tt = gjmp(0);
         }
         gsym(u);
-        nocode_wanted = ncw_prev;
+        if (c == 1)
+          nocode_wanted--;
 
         /* this is horrible, but we must also convert first
            operand */
@@ -6979,23 +6545,23 @@ static void expr_eq(void)
 
 ST_FUNC void gexpr(void)
 {
-    while (1) {
-        expr_eq();
-        if (tok != ',')
-            break;
+    expr_eq();
+    while (tok == ',') {
+	constant_p &= (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST &&
+                      !((vtop->r & VT_SYM) && vtop->sym->a.addrtaken);
         vpop();
         next();
+        expr_eq();
+	convert_parameter_type (&vtop->type);
     }
 }
 
 /* parse a constant expression and return value in vtop.  */
 static void expr_const1(void)
 {
-    const_wanted++;
-    nocode_wanted += unevalmask + 1;
+    nocode_wanted += CONST_WANTED_BIT;
     expr_cond();
-    nocode_wanted -= unevalmask + 1;
-    const_wanted--;
+    nocode_wanted -= CONST_WANTED_BIT;
 }
 
 /* parse an integer constant and return its value. */
@@ -7003,7 +6569,7 @@ static inline int64_t expr_const64(void)
 {
     int64_t c;
     expr_const1();
-    if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
+    if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM | VT_NONCONST)) != VT_CONST)
         expect("constant expression");
     c = vtop->c.i;
     vpop();
@@ -7049,11 +6615,12 @@ static void gfunc_return(CType *func_type)
             vstore();
         } else {
             /* returning structure packed into registers */
-            int size, addr, align, rc;
+            int size, addr, align, rc, n;
             size = type_size(func_type,&align);
-            if ((vtop->r != (VT_LOCAL | VT_LVAL) ||
-                 (vtop->c.i & (ret_align-1)))
-                && (align & (ret_align-1))) {
+            if ((align & (ret_align - 1))
+                && ((vtop->r & VT_VALMASK) < VT_CONST /* pointer to struct */
+                    || (vtop->c.i & (ret_align - 1))
+                    )) {
                 loc = (loc - size) & -ret_align;
                 addr = loc;
                 type = *func_type;
@@ -7065,22 +6632,19 @@ static void gfunc_return(CType *func_type)
             }
             vtop->type = ret_type;
             rc = RC_RET(ret_type.t);
-            if (ret_nregs == 1)
+            //printf("struct return: n:%d t:%02x rc:%02x\n", ret_nregs, ret_type.t, rc);
+            for (n = ret_nregs; --n > 0;) {
+                vdup();
                 gv(rc);
-            else {
-                for (;;) {
-                    vdup();
-                    gv(rc);
-                    vpop();
-                    if (--ret_nregs == 0)
-                      break;
-                    /* We assume that when a structure is returned in multiple
-                       registers, their classes are consecutive values of the
-                       suite s(n) = 2^n */
-                    rc <<= 1;
-                    vtop->c.i += regsize;
-                }
+                vswap();
+                incr_offset(regsize);
+                /* We assume that when a structure is returned in multiple
+                   registers, their classes are consecutive values of the
+                   suite s(n) = 2^n */
+                rc <<= 1;
             }
+            gv(rc);
+            vtop -= ret_nregs - 1;
         }
     } else {
         gv(RC_RET(func_type->t));
@@ -7283,9 +6847,6 @@ static void new_scope(struct scope *o)
     o->lstk = local_stack;
     o->llstk = local_label_stack;
     ++local_scope;
-
-    if (debug_modes)
-        tcc_debug_stabn(tcc_state, N_LBRAC, ind - func_ind);
 }
 
 static void prev_scope(struct scope *o, int is_expr)
@@ -7310,9 +6871,6 @@ static void prev_scope(struct scope *o, int is_expr)
     pop_local_syms(o->lstk, is_expr);
     cur_scope = o->prev;
     --local_scope;
-
-    if (debug_modes)
-        tcc_debug_stabn(tcc_state, N_RBRAC, ind - func_ind);
 }
 
 /* leave a scope via break/continue(/goto) */
@@ -7324,6 +6882,20 @@ static void leave_scope(struct scope *o)
     vla_leave(o);
 }
 
+/* short versiona for scopes with 'if/do/while/switch' which can
+   declare only types (of struct/union/enum) */
+static void new_scope_s(struct scope *o)
+{
+    o->lstk = local_stack;
+    ++local_scope;
+}
+
+static void prev_scope_s(struct scope *o)
+{
+    sym_pop(&local_stack, o->lstk, 0);
+    --local_scope;
+}
+
 /* ------------------------------------------------------------------------- */
 /* call block from 'for do while' loops */
 
@@ -7365,9 +6937,10 @@ static void block(int is_expr)
     next();
 
     if (debug_modes)
-        tcc_tcov_check_line (0), tcc_tcov_block_begin ();
+        tcc_tcov_check_line (tcc_state, 0), tcc_tcov_block_begin (tcc_state);
 
     if (t == TOK_IF) {
+        new_scope_s(&o);
         skip('(');
         gexpr();
         skip(')');
@@ -7382,8 +6955,10 @@ static void block(int is_expr)
         } else {
             gsym(a);
         }
+        prev_scope_s(&o);
 
     } else if (t == TOK_WHILE) {
+        new_scope_s(&o);
         d = gind();
         skip('(');
         gexpr();
@@ -7394,8 +6969,11 @@ static void block(int is_expr)
         gjmp_addr(d);
         gsym_addr(b, d);
         gsym(a);
+        prev_scope_s(&o);
 
     } else if (t == '{') {
+        if (debug_modes)
+            tcc_debug_stabn(tcc_state, N_LBRAC, ind - func_ind);
         new_scope(&o);
 
         /* handle local labels declarations */
@@ -7420,6 +6998,8 @@ static void block(int is_expr)
         }
 
         prev_scope(&o, is_expr);
+        if (debug_modes)
+            tcc_debug_stabn(tcc_state, N_RBRAC, ind - func_ind);
         if (local_scope)
             next();
         else if (!nocode_wanted)
@@ -7448,7 +7028,7 @@ static void block(int is_expr)
         if (tok != '}' || local_scope != 1)
             rsym = gjmp(rsym);
         if (debug_modes)
-	    tcc_tcov_block_end (tcov_data.line);
+	    tcc_tcov_block_end (tcc_state, -1);
         CODE_OFF();
 
     } else if (t == TOK_BREAK) {
@@ -7476,7 +7056,7 @@ static void block(int is_expr)
         skip('(');
         if (tok != ';') {
             /* c99 for-loop init decl? */
-            if (!decl0(VT_LOCAL, 1, NULL)) {
+            if (!decl(VT_JMP)) {
                 /* no, regular for-loop init expr */
                 gexpr();
                 vpop();
@@ -7506,6 +7086,7 @@ static void block(int is_expr)
         prev_scope(&o, 0);
 
     } else if (t == TOK_DO) {
+        new_scope_s(&o);
         a = b = 0;
         d = gind();
         lblock(&a, &b);
@@ -7518,6 +7099,7 @@ static void block(int is_expr)
 	c = gvtst(0, 0);
 	gsym_addr(c, d);
         gsym(a);
+        prev_scope_s(&o);
 
     } else if (t == TOK_SWITCH) {
         struct switch_t *sw;
@@ -7526,31 +7108,33 @@ static void block(int is_expr)
         sw->bsym = &a;
         sw->scope = cur_scope;
         sw->prev = cur_switch;
+        sw->nocode_wanted = nocode_wanted;
         cur_switch = sw;
 
+        new_scope_s(&o);
         skip('(');
         gexpr();
         skip(')');
         sw->sv = *vtop--; /* save switch value */
-
         a = 0;
         b = gjmp(0); /* jump to first case */
         lblock(&a, NULL);
         a = gjmp(a); /* add implicit break */
         /* case lookup */
         gsym(b);
+        prev_scope_s(&o);
 
+        if (sw->nocode_wanted)
+            goto skip_switch;
         if (sw->sv.type.t & VT_UNSIGNED)
             qsort(sw->p, sw->n, sizeof(void*), case_cmpu);
         else
             qsort(sw->p, sw->n, sizeof(void*), case_cmpi);
-
         for (b = 1; b < sw->n; b++)
             if (sw->sv.type.t & VT_UNSIGNED
                 ? (uint64_t)sw->p[b - 1]->v2 >= (uint64_t)sw->p[b]->v1
                 : sw->p[b - 1]->v2 >= sw->p[b]->v1)
                 tcc_error("duplicate case value");
-
         vpushv(&sw->sv);
         gv(RC_INT);
         d = 0, gcase(sw->p, sw->n, &d);
@@ -7559,6 +7143,7 @@ static void block(int is_expr)
             gsym_addr(d, sw->def_sym);
         else
             gsym(d);
+    skip_switch:
         /* break label */
         gsym(a);
 
@@ -7578,8 +7163,9 @@ static void block(int is_expr)
                 || (cur_switch->sv.type.t & VT_UNSIGNED && (uint64_t)cr->v2 < (uint64_t)cr->v1))
                 tcc_warning("empty case range");
         }
-        tcov_data.ind = 0;
-        cr->sym = gind();
+        /* case and default are unreachable from a switch under nocode_wanted */
+        if (!cur_switch->nocode_wanted)
+            cr->sym = gind();
         dynarray_add(&cur_switch->p, &cur_switch->n, cr);
         skip(':');
         is_expr = 0;
@@ -7590,15 +7176,13 @@ static void block(int is_expr)
             expect("switch");
         if (cur_switch->def_sym)
             tcc_error("too many 'default'");
-        tcov_data.ind = 0;
-        cur_switch->def_sym = gind();
+        cur_switch->def_sym = cur_switch->nocode_wanted ? 1 : gind();
         skip(':');
         is_expr = 0;
         goto block_after_label;
 
     } else if (t == TOK_GOTO) {
-        if (cur_scope->vla.num)
-          vla_restore(cur_scope->vla.locorig);
+        vla_restore(cur_scope->vla.locorig);
         if (tok == '*' && gnu_ext) {
             /* computed goto */
             next();
@@ -7661,6 +7245,13 @@ static void block(int is_expr)
             s->cleanupstate = cur_scope->cl.s;
 
     block_after_label:
+              {
+                /* Accept attributes after labels (e.g. 'unused') */
+                AttributeDef ad_tmp;
+                parse_attribute(&ad_tmp);
+              }
+            if (debug_modes)
+                tcc_tcov_reset_ind(tcc_state);
             vla_restore(cur_scope->vla.loc);
             if (tok != '}')
                 goto again;
@@ -7685,7 +7276,7 @@ static void block(int is_expr)
     }
 
     if (debug_modes)
-        tcc_tcov_check_line (0), tcc_tcov_block_end (0);
+        tcc_tcov_check_line (tcc_state, 0), tcc_tcov_block_end (tcc_state, 0);
 }
 
 /* This skips over a stream of tokens containing balanced {} and ()
@@ -7700,9 +7291,16 @@ static void skip_or_save_block(TokenString **str)
     if (str)
       *str = tok_str_alloc();
 
-    while ((level > 0 || (tok != '}' && tok != ',' && tok != ';' && tok != ')'))) {
-	int t;
-	if (tok == TOK_EOF) {
+    while (1) {
+	int t = tok;
+        if (level == 0
+            && (t == ','
+             || t == ';'
+             || t == '}'
+             || t == ')'
+             || t == ']'))
+             break;
+	if (t == TOK_EOF) {
 	     if (str || level > 0)
 	       tcc_error("unexpected end of file");
 	     else
@@ -7710,11 +7308,10 @@ static void skip_or_save_block(TokenString **str)
 	}
 	if (str)
 	  tok_str_add_tok(*str);
-	t = tok;
 	next();
-	if (t == '{' || t == '(') {
+	if (t == '{' || t == '(' || t == '[') {
 	    level++;
-	} else if (t == '}' || t == ')') {
+	} else if (t == '}' || t == ')' || t == ']') {
 	    level--;
 	    if (level == 0 && braces && t == '}')
 	      break;
@@ -7876,16 +7473,11 @@ static int decl_designator(init_params *p, CType *type, unsigned long c,
             l = tok;
         struct_field:
             next();
-            if ((type->t & VT_BTYPE) != VT_STRUCT)
-                expect("struct/union type");
-            cumofs = 0;
 	    f = find_field(type, l, &cumofs);
-            if (!f)
-                expect("field");
             if (cur_field)
                 *cur_field = f;
 	    type = &f->type;
-            c += cumofs + f->c;
+            c += cumofs;
         }
         cur_field = NULL;
     }
@@ -7908,7 +7500,9 @@ static int decl_designator(init_params *p, CType *type, unsigned long c,
             c += index * elem_size;
         } else {
             f = *cur_field;
-	    while (f && (f->v & SYM_FIRST_ANOM) && (f->type.t & VT_BITFIELD))
+	    /* Skip bitfield padding. Also with size 32 and 64. */
+	    while (f && (f->v & SYM_FIRST_ANOM) &&
+		   is_integer_btype(f->type.t & VT_BTYPE))
 	        *cur_field = f = f->next;
             if (!f)
                 tcc_error("too many initializers");
@@ -8092,8 +7686,6 @@ static void init_putv(init_params *p, CType *type, unsigned long c)
                 else if (sizeof (long double) == sizeof (double))
                     __asm__("fldl %1\nfstpt %0\n" : "=m" (*ptr) : "m" (vtop->c.ld));
 #endif
-                else if (vtop->c.ld == 0.0)
-                    ;
                 else
 #endif
                 /* For other platforms it should work natively, but may not work
@@ -8101,7 +7693,9 @@ static void init_putv(init_params *p, CType *type, unsigned long c)
                 if (sizeof(long double) == LDOUBLE_SIZE)
                     memcpy(ptr, &vtop->c.ld, LDOUBLE_SIZE);
                 else if (sizeof(double) == LDOUBLE_SIZE)
-                    memcpy(ptr, &vtop->c.ld, LDOUBLE_SIZE);
+                    *(double*)ptr = (double)vtop->c.ld;
+                else if (0 == memcmp(ptr, &vtop->c.ld, LDOUBLE_SIZE))
+                    ; /* nothing to do for 0.0 */
 #ifndef TCC_CROSS_TEST
                 else
                     tcc_error("can't cross compile long double constants");
@@ -8159,8 +7753,8 @@ static void decl_initializer(init_params *p, CType *type, unsigned long c, int f
     CType *t1;
 
     /* generate line number info */
-    if (debug_modes && !p->sec)
-        tcc_debug_line(tcc_state), tcc_tcov_check_line (1);
+    if (debug_modes && !(flags & DIF_SIZE_ONLY) && !p->sec)
+        tcc_debug_line(tcc_state), tcc_tcov_check_line (tcc_state, 1);
 
     if (!(flags & DIF_HAVE_ELEM) && tok != '{' &&
 	/* In case of strings we have special handling for arrays, so
@@ -8230,7 +7824,7 @@ static void decl_initializer(init_params *p, CType *type, unsigned long c, int f
 
             decl_design_flex(p, s, len);
             if (!(flags & DIF_SIZE_ONLY)) {
-                int nb = n;
+                int nb = n, ch;
                 if (len < nb)
                     nb = len;
                 if (len > nb)
@@ -8277,6 +7871,10 @@ static void decl_initializer(init_params *p, CType *type, unsigned long c, int f
             }
 
 	    len = 0;
+            /* GNU extension: if the initializer is empty for a flex array,
+               it's size is zero.  We won't enter the loop, so set the size
+               now.  */
+            decl_design_flex(p, s, len);
 	    while (tok != '}' || (flags & DIF_HAVE_ELEM)) {
 		len = decl_designator(p, type, c, &f, flags, len);
 		flags &= ~DIF_HAVE_ELEM;
@@ -8371,7 +7969,7 @@ static void decl_initializer(init_params *p, CType *type, unsigned long c, int f
    is put in the value stack. If 'has_init' is 2, a special parsing
    is done to handle string constants. */
 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, 
-                                   int has_init, int v, int scope)
+                                   int has_init, int v, int global)
 {
     int size, align, addr;
     TokenString *init_str = NULL;
@@ -8387,7 +7985,7 @@ static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
 
     /* Always allocate static or global variables */
     if (v && (r & VT_VALMASK) == VT_CONST)
-        nocode_wanted |= 0x80000000;
+        nocode_wanted |= DATA_ONLY_WANTED;
 
     flexible_array = NULL;
     size = type_size(type, &align);
@@ -8396,6 +7994,11 @@ static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
        toplevel array or the last member of the toplevel struct */
 
     if (size < 0) {
+        // error out except for top-level incomplete arrays
+        // (arrays of incomplete types are handled in array parsing)
+        if (!(type->t & VT_ARRAY))
+            tcc_error("initialization of incomplete type");
+
         /* If the base type itself was an array type of unspecified size
            (like in 'typedef int arr[]; arr x = {1};') then we will
            overwrite the unknown size by the real one for this decl.
@@ -8508,7 +8111,7 @@ static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
         }
     } else {
 	sym = NULL;
-        if (v && scope == VT_CONST) {
+        if (v && global) {
             /* see if the symbol was already defined */
             sym = sym_find(v);
             if (sym) {
@@ -8676,56 +8279,70 @@ static void gen_function(Sym *sym)
     struct scope f = { 0 };
     cur_scope = root_scope = &f;
     nocode_wanted = 0;
+
     ind = cur_text_section->data_offset;
     if (sym->a.aligned) {
 	size_t newoff = section_add(cur_text_section, 0,
 				    1 << (sym->a.aligned - 1));
 	gen_fill_nops(newoff - ind);
     }
+
+    funcname = get_tok_str(sym->v, NULL);
+    func_ind = ind;
+    func_vt = sym->type.ref->type;
+    func_var = sym->type.ref->f.func_type == FUNC_ELLIPSIS;
+
     /* NOTE: we patch the symbol size later */
     put_extern_sym(sym, cur_text_section, ind, 0);
+
     if (sym->type.ref->f.func_ctor)
         add_array (tcc_state, ".init_array", sym->c);
     if (sym->type.ref->f.func_dtor)
         add_array (tcc_state, ".fini_array", sym->c);
 
-    funcname = get_tok_str(sym->v, NULL);
-    func_ind = ind;
-    func_vt = sym->type.ref->type;
-    func_var = sym->type.ref->f.func_type == FUNC_ELLIPSIS;
-
     /* put debug symbol */
     tcc_debug_funcstart(tcc_state, sym);
+
     /* push a dummy symbol to enable local sym storage */
     sym_push2(&local_stack, SYM_FIELD, 0, 0);
     local_scope = 1; /* for function parameters */
     gfunc_prolog(sym);
+    tcc_debug_prolog_epilog(tcc_state, 0);
+
     local_scope = 0;
     rsym = 0;
     clear_temp_local_var_list();
     func_vla_arg(sym);
     block(0);
     gsym(rsym);
+
     nocode_wanted = 0;
     /* reset local stack */
     pop_local_syms(NULL, 0);
+    tcc_debug_prolog_epilog(tcc_state, 1);
     gfunc_epilog();
+
+    /* end of function */
+    tcc_debug_funcend(tcc_state, ind - func_ind);
+
+    /* patch symbol size */
+    elfsym(sym)->st_size = ind - func_ind;
+
     cur_text_section->data_offset = ind;
     local_scope = 0;
     label_pop(&global_label_stack, NULL, 0);
     sym_pop(&all_cleanups, NULL, 0);
-    /* patch symbol size */
-    elfsym(sym)->st_size = ind - func_ind;
-    /* end of function */
-    tcc_debug_funcend(tcc_state, ind - func_ind);
+
     /* It's better to crash than to generate wrong code */
     cur_text_section = NULL;
     funcname = ""; /* for safety */
     func_vt.t = VT_VOID; /* for safety */
     func_var = 0; /* for safety */
     ind = 0; /* for safety */
-    nocode_wanted = 0x80000000;
+    func_ind = -1;
+    nocode_wanted = DATA_ONLY_WANTED;
     check_vstack();
+
     /* do this after funcend debug info */
     next();
 }
@@ -8773,9 +8390,29 @@ static void free_inline_functions(TCCState *s)
     dynarray_reset(&s->inline_fns, &s->nb_inline_fns);
 }
 
-/* 'l' is VT_LOCAL or VT_CONST to define default storage type, or VT_CMP
-   if parsing old style parameter decl list (and FUNC_SYM is set then) */
-static int decl0(int l, int is_for_loop_init, Sym *func_sym)
+static void do_Static_assert(void)
+{
+    int c;
+    const char *msg;
+
+    next();
+    skip('(');
+    c = expr_const();
+    msg = "_Static_assert fail";
+    if (tok == ',') {
+        next();
+        msg = parse_mult_str("string constant")->data;
+    }
+    skip(')');
+    if (c == 0)
+        tcc_error("%s", msg);
+    skip(';');
+}
+
+/* 'l' is VT_LOCAL or VT_CONST to define default storage type
+   or VT_CMP if parsing old style parameter list
+   or VT_JMP if parsing c99 for decl: for (int i = 0, ...) */
+static int decl(int l)
 {
     int v, has_init, r, oldint;
     CType type, btype;
@@ -8783,35 +8420,15 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
     AttributeDef ad, adbase;
 
     while (1) {
-	if (tok == TOK_STATIC_ASSERT) {
-	    CString error_str;
-	    int c;
-
-	    next();
-	    skip('(');
-	    c = expr_const();
-
-	    if (tok == ')') {
-		if (!c)
-		    tcc_error("_Static_assert fail");
-		next();
-		goto static_assert_out;
-	    }
 
-	    skip(',');
-	    parse_mult_str(&error_str, "string constant");
-	    if (c == 0)
-		tcc_error("%s", (char *)error_str.data);
-	    cstr_free(&error_str);
-	    skip(')');
-	  static_assert_out:
-            skip(';');
-	    continue;
-	}
+        if (tok == TOK_STATIC_ASSERT) {
+            do_Static_assert();
+            continue;
+        }
 
         oldint = 0;
-        if (!parse_btype(&btype, &adbase)) {
-            if (is_for_loop_init)
+        if (!parse_btype(&btype, &adbase, l == VT_LOCAL)) {
+            if (l == VT_JMP)
                 return 0;
             /* skip redundant ';' if not in old parameter decl scope */
             if (tok == ';' && l != VT_CMP) {
@@ -8863,14 +8480,16 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
             }
 #endif
             if ((type.t & VT_BTYPE) == VT_FUNC) {
-                if ((type.t & VT_STATIC) && (l == VT_LOCAL))
+                if ((type.t & VT_STATIC) && (l != VT_CONST))
                     tcc_error("function without file scope cannot be static");
                 /* if old style function prototype, we accept a
                    declaration list */
                 sym = type.ref;
-                if (sym->f.func_type == FUNC_OLD && l == VT_CONST)
-                    decl0(VT_CMP, 0, sym);
-#ifdef TCC_TARGET_MACHO
+                if (sym->f.func_type == FUNC_OLD && l == VT_CONST) {
+                    func_vt = type;
+                    decl(VT_CMP);
+                }
+#if defined TCC_TARGET_MACHO || defined TARGETOS_ANDROID
                 if (sym->f.func_alwinl
                     && ((type.t & (VT_EXTERN | VT_INLINE))
                         == (VT_EXTERN | VT_INLINE))) {
@@ -8963,12 +8582,12 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
             } else {
 		if (l == VT_CMP) {
 		    /* find parameter in function parameter list */
-		    for (sym = func_sym->next; sym; sym = sym->next)
+		    for (sym = func_vt.ref->next; sym; sym = sym->next)
 			if ((sym->v & ~SYM_FIELD) == v)
 			    goto found;
 		    tcc_error("declaration for parameter '%s' but no such parameter",
 			      get_tok_str(v, NULL));
-found:
+                found:
 		    if (type.t & VT_STORAGE) /* 'register' is okay */
 		        tcc_error("storage class specified for '%s'",
 				  get_tok_str(v, NULL));
@@ -8991,7 +8610,8 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
                         sym = sym_push(v, &type, 0, 0);
                     }
                     sym->a = ad.a;
-                    sym->f = ad.f;
+                    if ((type.t & VT_BTYPE) == VT_FUNC)
+                      merge_funcattr(&sym->type.ref->f, &ad.f);
                     if (debug_modes)
                         tcc_debug_typedef (tcc_state, sym);
 		} else if ((type.t & VT_BTYPE) == VT_VOID
@@ -9002,7 +8622,7 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
                     if ((type.t & VT_BTYPE) == VT_FUNC) {
                         /* external function definition */
                         /* specific case for func_call attribute */
-                        type.ref->f = ad.f;
+                        merge_funcattr(&type.ref->f, &ad.f);
                     } else if (!(type.t & VT_ARRAY)) {
                         /* not lvalue if array */
                         r |= VT_LVAL;
@@ -9035,20 +8655,30 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
                                             esym->st_value, esym->st_size, 1);
                         }
                     } else {
-                        if (type.t & VT_STATIC)
+                        if (l == VT_CONST || (type.t & VT_STATIC))
                             r |= VT_CONST;
                         else
-                            r |= l;
+                            r |= VT_LOCAL;
                         if (has_init)
                             next();
                         else if (l == VT_CONST)
                             /* uninitialized global variables may be overridden */
                             type.t |= VT_EXTERN;
-                        decl_initializer_alloc(&type, &ad, r, has_init, v, l);
+
+                        if (ad.alias_target && 1) {
+                            Sym *alias_target = sym_find(ad.alias_target);
+                            ElfSym *esym = elfsym(alias_target);
+                            if (!esym) tcc_error("unsupported forward __alias__ attribute");
+                            sym = external_sym(v, &type, r, &ad);
+                            put_extern_sym2(sym, esym->st_shndx,
+                                            esym->st_value, esym->st_size, 1);
+                        }
+
+                        decl_initializer_alloc(&type, &ad, r, has_init, v, l == VT_CONST);
                     }
                 }
                 if (tok != ',') {
-                    if (is_for_loop_init)
+                    if (l == VT_JMP)
                         return 1;
                     skip(';');
                     break;
@@ -9060,11 +8690,6 @@ static int decl0(int l, int is_for_loop_init, Sym *func_sym)
     return 0;
 }
 
-static void decl(int l)
-{
-    decl0(l, 0, NULL);
-}
-
 /* ------------------------------------------------------------------------- */
 #undef gjmp_addr
 #undef gjmp
diff --git a/tccmacho.c b/tccmacho.c
index 3b95a3bfc..72b56770c 100644
--- a/tccmacho.c
+++ b/tccmacho.c
@@ -31,9 +31,32 @@
    to setup our own crt code.  We're not using lazy linking, so even function
    calls are resolved at startup.  */
 
+#if !defined TCC_TARGET_X86_64 && !defined TCC_TARGET_ARM64
+#error Platform not supported
+#endif
+
+/* XXX: this file uses tcc_error() to the effect of exit(1) */
+#undef _tcc_error
+
 #define DEBUG_MACHO 0
 #define dprintf if (DEBUG_MACHO) printf
 
+#define MH_EXECUTE              (0x2)
+#define MH_DYLDLINK             (0x4)
+#define MH_DYLIB                (0x6)
+#define MH_PIE                  (0x200000)
+
+#define CPU_SUBTYPE_LIB64       (0x80000000)
+#define CPU_SUBTYPE_X86_ALL     (3)
+#define CPU_SUBTYPE_ARM64_ALL   (0)
+
+#define CPU_ARCH_ABI64          (0x01000000)
+
+#define CPU_TYPE_X86            (7)
+#define CPU_TYPE_X86_64         (CPU_TYPE_X86 | CPU_ARCH_ABI64)
+#define CPU_TYPE_ARM            (12)
+#define CPU_TYPE_ARM64          (CPU_TYPE_ARM | CPU_ARCH_ABI64)
+
 struct fat_header {
     uint32_t        magic;          /* FAT_MAGIC or FAT_MAGIC_64 */
     uint32_t        nfat_arch;      /* number of structs that follow */
@@ -85,8 +108,16 @@ struct load_command {
 #define LC_ID_DYLIB      0xd
 #define LC_LOAD_DYLINKER 0xe
 #define LC_SEGMENT_64    0x19
+#define LC_RPATH (0x1c | LC_REQ_DYLD)
 #define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD)
+#define LC_DYLD_INFO_ONLY (0x22|LC_REQ_DYLD)
 #define LC_MAIN (0x28|LC_REQ_DYLD)
+#define LC_SOURCE_VERSION 0x2A
+#define LC_BUILD_VERSION 0x32
+#define LC_DYLD_EXPORTS_TRIE (0x33 | LC_REQ_DYLD)
+#define LC_DYLD_CHAINED_FIXUPS (0x34 | LC_REQ_DYLD)
+
+#define SG_READ_ONLY    0x10 /* This segment is made read-only after fixups */
 
 typedef int vm_prot_t;
 
@@ -119,14 +150,91 @@ struct section_64 { /* for 64-bit architectures */
     uint32_t        reserved3;      /* reserved */
 };
 
+enum {
+    DYLD_CHAINED_IMPORT          = 1,
+};
+
+struct dyld_chained_fixups_header {
+    uint32_t    fixups_version; ///< 0
+    uint32_t    starts_offset;  ///< Offset of dyld_chained_starts_in_image.
+    uint32_t    imports_offset; ///< Offset of imports table in chain_data.
+    uint32_t    symbols_offset; ///< Offset of symbol strings in chain_data.
+    uint32_t    imports_count;  ///< Number of imported symbol names.
+    uint32_t    imports_format; ///< DYLD_CHAINED_IMPORT*
+    uint32_t    symbols_format; ///< 0 => uncompressed, 1 => zlib compressed
+};
+
+struct dyld_chained_starts_in_image
+{
+    uint32_t    seg_count;
+    uint32_t    seg_info_offset[1];  // each entry is offset into this struct for that segment
+    // followed by pool of dyld_chain_starts_in_segment data
+};
+
+enum {
+    DYLD_CHAINED_PTR_64                     =  2,    // target is vmaddr
+    DYLD_CHAINED_PTR_64_OFFSET              =  6,    // target is vm offset
+};
+
+enum {
+    DYLD_CHAINED_PTR_START_NONE   = 0xFFFF, // used in page_start[] to denote a page with no fixups
+};
+
+#define SEG_PAGE_SIZE 16384
+
+struct dyld_chained_starts_in_segment
+{
+    uint32_t    size;               // size of this (amount kernel needs to copy)
+    uint16_t    page_size;          // 0x1000 or 0x4000
+    uint16_t    pointer_format;     // DYLD_CHAINED_PTR_*
+    uint64_t    segment_offset;     // offset in memory to start of segment
+    uint32_t    max_valid_pointer;  // for 32-bit OS, any value beyond this is not a pointer
+    uint16_t    page_count;         // how many pages are in array
+    uint16_t    page_start[1];      // each entry is offset in each page of first element in chain
+                                    // or DYLD_CHAINED_PTR_START_NONE if no fixups on page
+};
+
+enum BindSpecialDylib {
+  BIND_SPECIAL_DYLIB_FLAT_LOOKUP = -2,
+};
+
+struct dyld_chained_import
+{
+    uint32_t    lib_ordinal :  8,
+                weak_import :  1,
+                name_offset : 23;
+};
+
+struct dyld_chained_ptr_64_rebase
+{
+    uint64_t    target    : 36,    // vmaddr, 64GB max image size
+                high8     :  8,    // top 8 bits set to this after slide added
+                reserved  :  7,    // all zeros
+                next      : 12,    // 4-byte stride
+                bind      :  1;    // == 0
+};
+
+struct dyld_chained_ptr_64_bind
+{
+    uint64_t    ordinal   : 24,
+                addend    :  8,   // 0 thru 255
+                reserved  : 19,   // all zeros
+                next      : 12,   // 4-byte stride
+                bind      :  1;   // == 1
+};
+
 #define S_REGULAR                       0x0
 #define S_ZEROFILL                      0x1
 #define S_NON_LAZY_SYMBOL_POINTERS      0x6
+#define S_LAZY_SYMBOL_POINTERS          0x7
+#define S_SYMBOL_STUBS                  0x8
 #define S_MOD_INIT_FUNC_POINTERS        0x9
 #define S_MOD_TERM_FUNC_POINTERS        0xa
 
 #define S_ATTR_PURE_INSTRUCTIONS        0x80000000
 #define S_ATTR_SOME_INSTRUCTIONS        0x00000400
+#define S_ATTR_DEBUG             	0x02000000
+
 
 typedef uint32_t lc_str;
 
@@ -140,6 +248,12 @@ struct dylib_command {
     uint32_t compatibility_version; /* library's compatibility vers number*/
 };
 
+struct rpath_command {
+    uint32_t     cmd;           /* LC_RPATH */
+    uint32_t     cmdsize;       /* includes string */
+    lc_str       path;          /* path to add to run path */
+};
+
 struct dylinker_command {
     uint32_t        cmd;            /* LC_ID_DYLINKER, LC_LOAD_DYLINKER or
                                        LC_DYLD_ENVIRONMENT */
@@ -147,6 +261,36 @@ struct dylinker_command {
     lc_str          name;           /* dynamic linker's path name */
 };
 
+struct linkedit_data_command {
+    uint32_t    cmd;            /* LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO,
+                                   LC_FUNCTION_STARTS, LC_DATA_IN_CODE,
+                                   LC_DYLIB_CODE_SIGN_DRS,
+                                   LC_LINKER_OPTIMIZATION_HINT,
+                                   LC_DYLD_EXPORTS_TRIE, or
+                                   LC_DYLD_CHAINED_FIXUPS. */
+    uint32_t    cmdsize;        /* sizeof(struct linkedit_data_command) */
+    uint32_t    dataoff;        /* file offset of data in __LINKEDIT segment */
+    uint32_t    datasize;       /* file size of data in __LINKEDIT segment  */
+};
+
+#define PLATFORM_MACOS 1
+
+struct build_version_command {
+    uint32_t    cmd;            /* LC_BUILD_VERSION */
+    uint32_t    cmdsize;        /* sizeof(struct build_version_command) plus */
+                                /* ntools * sizeof(struct build_tool_version) */
+    uint32_t    platform;       /* platform */
+    uint32_t    minos;          /* X.Y.Z is encoded in nibbles xxxx.yy.zz */
+    uint32_t    sdk;            /* X.Y.Z is encoded in nibbles xxxx.yy.zz */
+    uint32_t    ntools;         /* number of tool entries following this */
+};
+
+struct source_version_command {
+    uint32_t  cmd;      /* LC_SOURCE_VERSION */
+    uint32_t  cmdsize;  /* 16 */
+    uint64_t  version;  /* A.B.C.D.E packed as a24.b10.c10.d10.e10 */
+};
+
 struct symtab_command {
     uint32_t        cmd;            /* LC_SYMTAB */
     uint32_t        cmdsize;        /* sizeof(struct symtab_command) */
@@ -187,6 +331,44 @@ struct dysymtab_command {
     uint32_t nlocrel;   /* number of local relocation entries */
 };
 
+#define BIND_OPCODE_DONE                                        0x00
+#define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM                       0x30
+#define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM               0x40
+#define BIND_OPCODE_SET_TYPE_IMM                                0x50
+#define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB                 0x70
+#define BIND_OPCODE_DO_BIND                                     0x90
+
+#define BIND_SYMBOL_FLAGS_WEAK_IMPORT                           0x1
+
+#define BIND_TYPE_POINTER                                       1
+#define BIND_SPECIAL_DYLIB_FLAT_LOOKUP                          -2
+
+#define REBASE_OPCODE_DONE                                      0x00
+#define REBASE_OPCODE_SET_TYPE_IMM                              0x10
+#define REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB               0x20
+#define REBASE_OPCODE_DO_REBASE_IMM_TIMES                       0x50
+
+#define REBASE_TYPE_POINTER                                     1
+
+#define EXPORT_SYMBOL_FLAGS_KIND_REGULAR                        0x00
+#define EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE                       0x02
+#define EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION                     0x04
+
+struct dyld_info_command {
+    uint32_t cmd;             /* LC_DYLD_INFO or LC_DYLD_INFO_ONLY */
+    uint32_t cmdsize;         /* sizeof(struct dyld_info_command) */
+    uint32_t rebase_off;      /* file offset to rebase info  */
+    uint32_t rebase_size;     /* size of rebase info   */
+    uint32_t bind_off;        /* file offset to binding info   */
+    uint32_t bind_size;       /* size of binding info  */
+    uint32_t weak_bind_off;   /* file offset to weak binding info   */
+    uint32_t weak_bind_size;  /* size of weak binding info  */
+    uint32_t lazy_bind_off;   /* file offset to lazy binding info */
+    uint32_t lazy_bind_size;  /* size of lazy binding infs */
+    uint32_t export_off;      /* file offset to lazy binding info */
+    uint32_t export_size;     /* size of lazy binding infs */
+};
+
 #define INDIRECT_SYMBOL_LOCAL   0x80000000
 
 struct entry_point_command {
@@ -201,9 +383,18 @@ enum skind {
     sk_discard,
     sk_text,
     sk_stubs,
+    sk_stub_helper,
     sk_ro_data,
     sk_uw_info,
     sk_nl_ptr,  // non-lazy pointers, aka GOT
+    sk_debug_info,
+    sk_debug_abbrev,
+    sk_debug_line,
+    sk_debug_aranges,
+    sk_debug_str,
+    sk_debug_line_str,
+    sk_stab,
+    sk_stab_str,
     sk_la_ptr,  // lazy pointers
     sk_init,
     sk_fini,
@@ -231,7 +422,7 @@ struct nlist_64 {
 
 struct macho {
     struct mach_header_64 mh;
-    int seg2lc[4], nseg;
+    int *seg2lc, nseg;
     struct load_command **lc;
     struct entry_point_command *ep;
     int nlc;
@@ -241,9 +432,42 @@ struct macho {
     } sk_to_sect[sk_last];
     int *elfsectomacho;
     int *e2msym;
-    Section *symtab, *strtab, *wdata, *indirsyms, *stubs;
-    int stubsym;
+    Section *symtab, *strtab, *indirsyms, *stubs, *exports;
     uint32_t ilocal, iextdef, iundef;
+    int stubsym, n_got, nr_plt;
+    int segment[sk_last];
+#ifdef CONFIG_NEW_MACHO
+    Section *chained_fixups;
+    int n_bind;
+    int n_bind_rebase;
+    struct bind_rebase {
+	int section;
+	int bind;
+	ElfW_Rel rel;
+    } *bind_rebase;
+#else
+    Section *rebase, *binding, *weak_binding, *lazy_binding;
+    Section *stub_helper, *la_symbol_ptr;
+    struct dyld_info_command *dyldinfo;
+    int helpsym, lasym, dyld_private, dyld_stub_binder;
+    int n_lazy_bind;    
+    struct s_lazy_bind {
+        int section;
+        int bind_offset;
+        int la_symbol_offset;
+        ElfW_Rel rel;
+    } *s_lazy_bind;
+    int n_rebase;    
+    struct s_rebase {
+        int section;
+        ElfW_Rel rel;
+    } *s_rebase;
+    int n_bind; 
+    struct bind {
+        int section;
+        ElfW_Rel rel;
+    } *bind;
+#endif
 };
 
 #define SHT_LINKEDIT (SHT_LOOS + 42)
@@ -263,6 +487,7 @@ static struct segment_command_64 * add_segment(struct macho *mo, const char *nam
 {
     struct segment_command_64 *sc = add_lc(mo, LC_SEGMENT_64, sizeof(*sc));
     strncpy(sc->segname, name, 16);
+    mo->seg2lc = tcc_realloc(mo->seg2lc, sizeof(*mo->seg2lc) * (mo->nseg + 1));
     mo->seg2lc[mo->nseg++] = mo->nlc - 1;
     return sc;
 }
@@ -306,21 +531,156 @@ static void * add_dylib(struct macho *mo, char *name)
     return lc;
 }
 
-static void check_relocs(TCCState *s1, struct macho *mo)
+static int uleb128_size (unsigned long long value)
+{
+    int size =  0;
+
+    do {
+        value >>= 7;
+        size++;
+    } while (value != 0);
+    return size;
+}
+
+static void write_uleb128(Section *section, uint64_t value)
+{
+    do {
+        unsigned char byte = value & 0x7f;
+	uint8_t *ptr = section_ptr_add(section, 1);
+
+        value >>= 7;
+        *ptr = byte | (value ? 0x80 : 0);
+    } while (value != 0);
+}
+
+static void tcc_macho_add_destructor(TCCState *s1)
 {
+    int init_sym, mh_execute_header, at_exit_sym;
     Section *s;
     ElfW_Rel *rel;
+    uint8_t *ptr;
+
+    mh_execute_header = put_elf_sym(s1->symtab, -4096, 0,
+				    ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT), 0,
+				    text_section->sh_num, "__mh_execute_header");
+    s = find_section(s1, ".fini_array");
+    if (s->data_offset == 0)
+        return; 
+    init_sym = put_elf_sym(s1->symtab, text_section->data_offset, 0,
+                           ELFW(ST_INFO)(STB_LOCAL, STT_FUNC), 0,
+                           text_section->sh_num, "___GLOBAL_init_65535");
+    at_exit_sym = put_elf_sym(s1->symtab, 0, 0,
+                              ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0,
+                              SHN_UNDEF, "___cxa_atexit");
+#ifdef TCC_TARGET_X86_64
+    ptr = section_ptr_add(text_section, 4);
+    ptr[0] = 0x55;  // pushq   %rbp
+    ptr[1] = 0x48;  // movq    %rsp, %rbp
+    ptr[2] = 0x89;
+    ptr[3] = 0xe5;
+    for_each_elem(s->reloc, 0, rel, ElfW_Rel) {
+        int sym_index = ELFW(R_SYM)(rel->r_info);
+
+        ptr = section_ptr_add(text_section, 26);
+        ptr[0] = 0x48;  // lea destructor(%rip),%rax
+        ptr[1] = 0x8d;
+        ptr[2] = 0x05;
+        put_elf_reloca(s1->symtab, text_section, 
+		       text_section->data_offset - 23,
+		       R_X86_64_PC32, sym_index, -4);
+        ptr[7] = 0x48;  // mov %rax,%rdi
+        ptr[8] = 0x89;
+        ptr[9] = 0xc7;
+	ptr[10] = 0x31; // xorl %ecx, %ecx
+	ptr[11] = 0xc9;
+	ptr[12] = 0x89; // movl %ecx, %esi
+	ptr[13] = 0xce;
+        ptr[14] = 0x48;  // lea mh_execute_header(%rip),%rdx
+        ptr[15] = 0x8d;
+        ptr[16] = 0x15;
+        put_elf_reloca(s1->symtab, text_section,
+		       text_section->data_offset - 9,
+		       R_X86_64_PC32, mh_execute_header, -4);
+	ptr[21] = 0xe8; // call __cxa_atexit
+        put_elf_reloca(s1->symtab, text_section,
+		       text_section->data_offset - 4,
+		       R_X86_64_PLT32, at_exit_sym, -4);
+    }
+    ptr = section_ptr_add(text_section, 2);
+    ptr[0] = 0x5d;  // pop   %rbp
+    ptr[1] = 0xc3;  // ret
+#elif defined TCC_TARGET_ARM64
+    ptr = section_ptr_add(text_section, 8);
+    write32le(ptr, 0xa9bf7bfd);     // stp     x29, x30, [sp, #-16]!
+    write32le(ptr + 4, 0x910003fd); // mov     x29, sp
+    for_each_elem(s->reloc, 0, rel, ElfW_Rel) {
+        int sym_index = ELFW(R_SYM)(rel->r_info);
+
+        ptr = section_ptr_add(text_section, 24);
+        put_elf_reloc(s1->symtab, text_section, 
+		      text_section->data_offset - 24,
+		      R_AARCH64_ADR_PREL_PG_HI21, sym_index);
+        write32le(ptr, 0x90000000);      // adrp x0, destructor@page
+        put_elf_reloc(s1->symtab, text_section,
+		      text_section->data_offset - 20,
+		      R_AARCH64_LDST8_ABS_LO12_NC, sym_index);
+        write32le(ptr + 4, 0x91000000);  // add x0,x0,destructor@pageoff
+        write32le(ptr + 8, 0xd2800001);  // mov x1, #0
+        put_elf_reloc(s1->symtab, text_section, 
+		      text_section->data_offset - 12,
+		      R_AARCH64_ADR_PREL_PG_HI21, mh_execute_header);
+        write32le(ptr + 12, 0x90000002);      // adrp x2, mh_execute_header@page
+        put_elf_reloc(s1->symtab, text_section,
+		      text_section->data_offset - 8,
+		      R_AARCH64_LDST8_ABS_LO12_NC, mh_execute_header);
+        write32le(ptr + 16, 0x91000042);  // add x2,x2,mh_execute_header@pageoff
+        put_elf_reloc(s1->symtab, text_section,
+		      text_section->data_offset - 4,
+		      R_AARCH64_CALL26, at_exit_sym);
+	write32le(ptr + 20, 0x94000000); // bl __cxa_atexit
+    }
+    ptr = section_ptr_add(text_section, 8);
+    write32le(ptr, 0xa8c17bfd);     // ldp     x29, x30, [sp], #16
+    write32le(ptr + 4, 0xd65f03c0); // ret
+#endif
+    s->reloc->data_offset = s->data_offset = 0;
+    s->sh_flags &= ~SHF_ALLOC;
+    add_array (s1, ".init_array", init_sym);
+}
+
+#ifdef CONFIG_NEW_MACHO
+static void bind_rebase_add(struct macho *mo, int bind, int sh_info,
+			    ElfW_Rel *rel, struct sym_attr *attr)
+{
+    mo->bind_rebase = tcc_realloc(mo->bind_rebase, (mo->n_bind_rebase + 1) *
+		                  sizeof(struct bind_rebase));
+    mo->bind_rebase[mo->n_bind_rebase].section = sh_info;
+    mo->bind_rebase[mo->n_bind_rebase].bind = bind;
+    mo->bind_rebase[mo->n_bind_rebase].rel = *rel;
+    if (attr)
+        mo->bind_rebase[mo->n_bind_rebase].rel.r_offset = attr->got_offset;
+    mo->n_bind_rebase++;
+    mo->n_bind += bind;
+}
+
+static void check_relocs(TCCState *s1, struct macho *mo)
+{
+    Section *s;
+    ElfW_Rel *rel, save_rel;
     ElfW(Sym) *sym;
-    int i, type, gotplt_entry, sym_index, for_code;
+    int i, j, type, gotplt_entry, sym_index, for_code;
+    uint32_t *pi, *goti;
     struct sym_attr *attr;
 
-    s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
-    mo->indirsyms = new_section(s1, "LEINDIR", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+    goti = NULL;
+    mo->nr_plt = mo->n_got = 0;
     for (i = 1; i < s1->nb_sections; i++) {
         s = s1->sections[i];
-        if (s->sh_type != SHT_RELX)
+        if (s->sh_type != SHT_RELX ||
+	    !strncmp(s1->sections[s->sh_info]->name, ".debug_", 7))
             continue;
         for_each_elem(s, 0, rel, ElfW_Rel) {
+	    save_rel = *rel;
             type = ELFW(R_TYPE)(rel->r_info);
             gotplt_entry = gotplt_entry_type(type);
             for_code = code_reloc(type);
@@ -333,42 +693,313 @@ static void check_relocs(TCCState *s1, struct macho *mo)
                 || gotplt_entry == ALWAYS_GOTPLT_ENTRY) {
                 attr = get_sym_attr(s1, sym_index, 1);
                 if (!attr->dyn_index) {
-                    uint32_t *pi = section_ptr_add(mo->indirsyms, sizeof(*pi));
                     attr->got_offset = s1->got->data_offset;
                     attr->plt_offset = -1;
                     attr->dyn_index = 1; /* used as flag */
                     section_ptr_add(s1->got, PTR_SIZE);
+                    put_elf_reloc(s1->symtab, s1->got, attr->got_offset,
+                                  R_JMP_SLOT, sym_index);
+	 	    goti = tcc_realloc(goti, (mo->n_got + 1) * sizeof(*goti));
                     if (ELFW(ST_BIND)(sym->st_info) == STB_LOCAL) {
                         if (sym->st_shndx == SHN_UNDEF)
-                          tcc_error("undefined local symbol???");
-                        *pi = INDIRECT_SYMBOL_LOCAL;
-                        /* The pointer slot we generated must point to the
-                           symbol, whose address is only known after layout,
-                           so register a simple relocation for that.  */
-                        put_elf_reloc(s1->symtab, s1->got, attr->got_offset,
-                                      R_DATA_PTR, sym_index);
-                    } else
-                      *pi = mo->e2msym[sym_index];
+                          tcc_error("undefined local symbo: '%s'",
+				    (char *) symtab_section->link->data + sym->st_name);
+			goti[mo->n_got++] = INDIRECT_SYMBOL_LOCAL;
+                    } else {
+                        goti[mo->n_got++] = mo->e2msym[sym_index];
+                        if (sym->st_shndx == SHN_UNDEF
+#ifdef TCC_TARGET_X86_64
+                            && type == R_X86_64_GOTPCREL
+#elif defined TCC_TARGET_ARM64
+                            && type == R_AARCH64_ADR_GOT_PAGE
+#endif
+                            ) {
+			    attr->plt_offset = -mo->n_bind_rebase - 2;
+			    bind_rebase_add(mo, 1, s1->got->reloc->sh_info, &save_rel, attr);
+			    s1->got->reloc->data_offset -= sizeof (ElfW_Rel);
+			}
+		        if (for_code && sym->st_shndx == SHN_UNDEF)
+			    s1->got->reloc->data_offset -= sizeof (ElfW_Rel);
+		    }
                 }
-                if (for_code) {
+                if (for_code && sym->st_shndx == SHN_UNDEF) {
+		    if ((int)attr->plt_offset < -1) {
+			/* remove above bind and replace with plt */
+			mo->bind_rebase[-attr->plt_offset - 2].bind = 2;
+			attr->plt_offset = -1;
+		    }
                     if (attr->plt_offset == -1) {
                         uint8_t *jmp;
+
                         attr->plt_offset = mo->stubs->data_offset;
+#ifdef TCC_TARGET_X86_64
+                        if (type != R_X86_64_PLT32)
+                             continue;
                         jmp = section_ptr_add(mo->stubs, 6);
                         jmp[0] = 0xff;  /* jmpq *ofs(%rip) */
                         jmp[1] = 0x25;
                         put_elf_reloc(s1->symtab, mo->stubs,
                                       attr->plt_offset + 2,
                                       R_X86_64_GOTPCREL, sym_index);
+#elif defined TCC_TARGET_ARM64
+                        if (type != R_AARCH64_CALL26)
+                             continue;
+                        jmp = section_ptr_add(mo->stubs, 12);
+                        put_elf_reloc(s1->symtab, mo->stubs,
+                                      attr->plt_offset,
+                                      R_AARCH64_ADR_GOT_PAGE, sym_index);
+                        write32le(jmp, // adrp x16, #sym
+                                  0x90000010);
+                        put_elf_reloc(s1->symtab, mo->stubs,
+                                      attr->plt_offset + 4,
+                                      R_AARCH64_LD64_GOT_LO12_NC, sym_index);
+                        write32le(jmp + 4, // ld x16,[x16, #sym]
+                                  0xf9400210);
+                        write32le(jmp + 8, // br x16
+                                  0xd61f0200);
+#endif
+			bind_rebase_add(mo, 1, s1->got->reloc->sh_info, &save_rel, attr);
+                        pi = section_ptr_add(mo->indirsyms, sizeof(*pi));
+                        *pi = mo->e2msym[sym_index];
+                        mo->nr_plt++;
                     }
                     rel->r_info = ELFW(R_INFO)(mo->stubsym, type);
                     rel->r_addend += attr->plt_offset;
                 }
             }
+	    if (type == R_DATA_PTR || type == R_JMP_SLOT)
+		bind_rebase_add(mo, sym->st_shndx == SHN_UNDEF ? 1 : 0,
+				s->sh_info, &save_rel, NULL);
         }
     }
+    /* remove deleted binds */
+    for (i = 0, j = 0; i < mo->n_bind_rebase; i++)
+	if (mo->bind_rebase[i].bind == 2)
+	    mo->n_bind--;
+	else
+	    mo->bind_rebase[j++] = mo->bind_rebase[i];
+    mo->n_bind_rebase = j;
+    pi = section_ptr_add(mo->indirsyms, mo->n_got * sizeof(*pi));
+    memcpy(pi, goti, mo->n_got * sizeof(*pi));
+    tcc_free(goti);
 }
 
+#else
+
+static void check_relocs(TCCState *s1, struct macho *mo)
+{
+    uint8_t *jmp;
+    Section *s;
+    ElfW_Rel *rel, save_rel;
+    ElfW(Sym) *sym;
+    int i, type, gotplt_entry, sym_index, for_code;
+    int bind_offset, la_symbol_offset;
+    uint32_t *pi, *goti;
+    struct sym_attr *attr;
+
+#ifdef TCC_TARGET_X86_64
+    jmp = section_ptr_add(mo->stub_helper, 16);
+    jmp[0] = 0x4c;  /* leaq _dyld_private(%rip), %r11 */
+    jmp[1] = 0x8d;
+    jmp[2] = 0x1d;
+    put_elf_reloca(s1->symtab, mo->stub_helper, 3,
+		   R_X86_64_PC32, mo->dyld_private, -4);
+    jmp[7] = 0x41;  /* pushq %r11 */
+    jmp[8] = 0x53;
+    jmp[9] = 0xff;  /* jmpq    *dyld_stub_binder@GOT(%rip) */
+    jmp[10] = 0x25;
+    put_elf_reloca(s1->symtab, mo->stub_helper, 11,
+		   R_X86_64_GOTPCREL, mo->dyld_stub_binder, -4);
+    jmp[15] = 0x90; /* nop */
+#elif defined TCC_TARGET_ARM64
+    jmp = section_ptr_add(mo->stub_helper, 24);
+    put_elf_reloc(s1->symtab, mo->stub_helper, 0,
+		  R_AARCH64_ADR_PREL_PG_HI21, mo->dyld_private);
+    write32le(jmp, 0x90000011); // adrp x17, _dyld_private@page
+    put_elf_reloc(s1->symtab, mo->stub_helper, 4,
+		  R_AARCH64_LDST64_ABS_LO12_NC, mo->dyld_private);
+    write32le(jmp + 4, 0x91000231); // add x17,x17,_dyld_private@pageoff
+    write32le(jmp + 8, 0xa9bf47f0); // stp x16/x17, [sp, #-16]!
+    put_elf_reloc(s1->symtab, mo->stub_helper, 12,
+		  R_AARCH64_ADR_GOT_PAGE, mo->dyld_stub_binder);
+    write32le(jmp + 12, 0x90000010); // adrp x16, dyld_stub_binder@page
+    put_elf_reloc(s1->symtab, mo->stub_helper, 16,
+		  R_AARCH64_LD64_GOT_LO12_NC, mo->dyld_stub_binder);
+    write32le(jmp + 16, 0xf9400210); // ldr x16,[x16,dyld_stub_binder@pageoff]
+    write32le(jmp + 20, 0xd61f0200); // br x16
+#endif
+    
+    goti = NULL;
+    mo->nr_plt = mo->n_got = 0;
+    for (i = 1; i < s1->nb_sections; i++) {
+        s = s1->sections[i];
+        if (s->sh_type != SHT_RELX ||
+	    !strncmp(s1->sections[s->sh_info]->name, ".debug_", 7))
+            continue;
+        for_each_elem(s, 0, rel, ElfW_Rel) {
+	    save_rel = *rel;
+            type = ELFW(R_TYPE)(rel->r_info);
+            gotplt_entry = gotplt_entry_type(type);
+            for_code = code_reloc(type);
+            /* We generate a non-lazy pointer for used undefined symbols
+               and for defined symbols that must have a place for their
+               address due to codegen (i.e. a reloc requiring a got slot).  */
+            sym_index = ELFW(R_SYM)(rel->r_info);
+            sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+            if (sym->st_shndx == SHN_UNDEF
+                || gotplt_entry == ALWAYS_GOTPLT_ENTRY) {
+                attr = get_sym_attr(s1, sym_index, 1);
+                if (!attr->dyn_index) {
+                    attr->got_offset = s1->got->data_offset;
+                    attr->plt_offset = -1;
+                    attr->dyn_index = 1; /* used as flag */
+		    section_ptr_add(s1->got, PTR_SIZE);
+                    put_elf_reloc(s1->symtab, s1->got, attr->got_offset,
+                                  R_JMP_SLOT, sym_index);
+		    goti = tcc_realloc(goti, (mo->n_got + 1) * sizeof(*goti));
+                    if (ELFW(ST_BIND)(sym->st_info) == STB_LOCAL) {
+                        if (sym->st_shndx == SHN_UNDEF)
+                          tcc_error("undefined local symbo: '%s'",
+				    (char *) symtab_section->link->data + sym->st_name);
+			goti[mo->n_got++] = INDIRECT_SYMBOL_LOCAL;
+                    } else {
+			goti[mo->n_got++] = mo->e2msym[sym_index];
+			if (sym->st_shndx == SHN_UNDEF
+#ifdef TCC_TARGET_X86_64
+			    && type == R_X86_64_GOTPCREL
+#elif defined TCC_TARGET_ARM64
+			    && type == R_AARCH64_ADR_GOT_PAGE
+#endif
+			    ) {
+			    mo->bind =
+			        tcc_realloc(mo->bind,
+					    (mo->n_bind + 1) *
+					    sizeof(struct bind));
+			    mo->bind[mo->n_bind].section = s1->got->reloc->sh_info;
+			    mo->bind[mo->n_bind].rel = save_rel;
+                            mo->bind[mo->n_bind].rel.r_offset = attr->got_offset;
+			    mo->n_bind++;
+			    s1->got->reloc->data_offset -= sizeof (ElfW_Rel);
+			}
+		    }
+                }
+                if (for_code && sym->st_shndx == SHN_UNDEF) {
+                    if (attr->plt_offset == -1) {
+                        attr->plt_offset = mo->stubs->data_offset;
+#ifdef TCC_TARGET_X86_64
+			if (type != R_X86_64_PLT32)
+			     continue;
+			/* __stubs */
+                        jmp = section_ptr_add(mo->stubs, 6);
+                        jmp[0] = 0xff;  /* jmpq *__la_symbol_ptr(%rip) */
+                        jmp[1] = 0x25;
+                        put_elf_reloca(s1->symtab, mo->stubs,
+                                       mo->stubs->data_offset - 4,
+                                       R_X86_64_PC32, mo->lasym,
+				       mo->la_symbol_ptr->data_offset - 4);
+
+			/* __stub_helper */
+			bind_offset = mo->stub_helper->data_offset + 1;
+                        jmp = section_ptr_add(mo->stub_helper, 10);
+                        jmp[0] = 0x68;  /* pushq $bind_offset */
+                        jmp[5] = 0xe9;  /* jmpq __stub_helper */
+                        write32le(jmp + 6, -mo->stub_helper->data_offset);
+
+			/* __la_symbol_ptr */
+			la_symbol_offset = mo->la_symbol_ptr->data_offset;
+                        put_elf_reloca(s1->symtab, mo->la_symbol_ptr,
+				       mo->la_symbol_ptr->data_offset,
+				       R_DATA_PTR, mo->helpsym,
+				       mo->stub_helper->data_offset - 10);
+			section_ptr_add(mo->la_symbol_ptr, PTR_SIZE);
+#elif defined TCC_TARGET_ARM64
+			if (type != R_AARCH64_CALL26)
+			     continue;
+			/* __stubs */
+                        jmp = section_ptr_add(mo->stubs, 12);
+                        put_elf_reloca(s1->symtab, mo->stubs,
+                                       mo->stubs->data_offset - 12,
+                                       R_AARCH64_ADR_PREL_PG_HI21, mo->lasym,
+				       mo->la_symbol_ptr->data_offset);
+                        write32le(jmp, // adrp x16, __la_symbol_ptr@page
+                                  0x90000010);
+                        put_elf_reloca(s1->symtab, mo->stubs,
+                                       mo->stubs->data_offset - 8,
+                                       R_AARCH64_LDST64_ABS_LO12_NC, mo->lasym,
+				       mo->la_symbol_ptr->data_offset);
+                        write32le(jmp + 4, // ldr x16,[x16, __la_symbol_ptr@pageoff]
+                                  0xf9400210);
+                        write32le(jmp + 8, // br x16
+                                  0xd61f0200);
+
+			/* __stub_helper */
+			bind_offset = mo->stub_helper->data_offset + 8;
+                        jmp = section_ptr_add(mo->stub_helper, 12);
+                        write32le(jmp + 0, // ldr  w16, l0
+                                  0x18000050);
+                        write32le(jmp + 4, // b stubHelperHeader
+                                  0x14000000 +
+				  ((-(mo->stub_helper->data_offset - 8) / 4) &
+				   0x3ffffff));
+                        write32le(jmp + 8, 0); // l0: .long bind_offset
+
+			/* __la_symbol_ptr */
+			la_symbol_offset = mo->la_symbol_ptr->data_offset;
+                        put_elf_reloca(s1->symtab, mo->la_symbol_ptr,
+				       mo->la_symbol_ptr->data_offset,
+				       R_DATA_PTR, mo->helpsym,
+				       mo->stub_helper->data_offset - 12);
+			section_ptr_add(mo->la_symbol_ptr, PTR_SIZE);
+#endif
+                        mo->s_lazy_bind =
+                            tcc_realloc(mo->s_lazy_bind, (mo->n_lazy_bind + 1) *
+                                        sizeof(struct s_lazy_bind));
+                        mo->s_lazy_bind[mo->n_lazy_bind].section =
+                            mo->stub_helper->reloc->sh_info;
+                        mo->s_lazy_bind[mo->n_lazy_bind].bind_offset =
+			    bind_offset;
+                        mo->s_lazy_bind[mo->n_lazy_bind].la_symbol_offset =
+			    la_symbol_offset;
+                        mo->s_lazy_bind[mo->n_lazy_bind].rel = save_rel;
+                        mo->s_lazy_bind[mo->n_lazy_bind].rel.r_offset =
+                            attr->plt_offset;
+                        mo->n_lazy_bind++;
+			pi = section_ptr_add(mo->indirsyms, sizeof(*pi));
+			*pi = mo->e2msym[sym_index];
+			mo->nr_plt++;
+                    }
+                    rel->r_info = ELFW(R_INFO)(mo->stubsym, type);
+                    rel->r_addend += attr->plt_offset;
+                }
+            }
+            if (type == R_DATA_PTR || type == R_JMP_SLOT) {
+		if (sym->st_shndx == SHN_UNDEF) {
+		    mo->bind = tcc_realloc(mo->bind,
+					   (mo->n_bind + 1) *
+					   sizeof(struct bind));
+		    mo->bind[mo->n_bind].section = s->sh_info;
+		    mo->bind[mo->n_bind].rel = save_rel;
+		    mo->n_bind++;
+		}
+		else {
+                    mo->s_rebase =
+                        tcc_realloc(mo->s_rebase, (mo->n_rebase + 1) *
+				    sizeof(struct s_rebase));
+                    mo->s_rebase[mo->n_rebase].section = s->sh_info;
+                    mo->s_rebase[mo->n_rebase].rel = save_rel;
+                    mo->n_rebase++;
+		}
+	    }
+        }
+    }
+    pi = section_ptr_add(mo->indirsyms, mo->n_got * sizeof(*pi));
+    memcpy(pi, goti, mo->n_got * sizeof(*pi));
+    pi = section_ptr_add(mo->indirsyms, mo->nr_plt * sizeof(*pi));
+    memcpy(pi, mo->indirsyms->data, mo->nr_plt * sizeof(*pi));
+    tcc_free(goti);
+}
+#endif
+
 static int check_symbols(TCCState *s1, struct macho *mo)
 {
     int sym_index, sym_end;
@@ -401,6 +1032,7 @@ static int check_symbols(TCCState *s1, struct macho *mo)
             if (mo->iundef == -1)
               mo->iundef = sym_index - 1;
             if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK
+		|| s1->output_type != TCC_OUTPUT_EXE
                 || find_elf_sym(s1->dynsymtab_section, name)) {
                 /* Mark the symbol as coming from a dylib so that
                    relocate_syms doesn't complain.  Normally bind_exe_dynsyms
@@ -444,9 +1076,11 @@ static void convert_symbol(TCCState *s1, struct macho *mo, struct nlist_64 *pn)
       n.n_type = N_ABS, n.n_sect = 0;
     else if (sym->st_shndx >= SHN_LORESERVE)
       tcc_error("unhandled ELF symbol section %d %s", sym->st_shndx, name);
-    else if (!mo->elfsectomacho[sym->st_shndx])
-      tcc_error("ELF section %d not mapped into Mach-O for symbol %s",
-                sym->st_shndx, name);
+    else if (!mo->elfsectomacho[sym->st_shndx]) {
+      if (strncmp(s1->sections[sym->st_shndx]->name, ".debug_", 7))
+        tcc_error("ELF section %d(%s) not mapped into Mach-O for symbol %s",
+                  sym->st_shndx, s1->sections[sym->st_shndx]->name, name);
+    }
     else
       n.n_sect = mo->elfsectomacho[sym->st_shndx];
     if (ELFW(ST_BIND)(sym->st_info) == STB_GLOBAL)
@@ -465,9 +1099,9 @@ static void convert_symbols(TCCState *s1, struct macho *mo)
         convert_symbol(s1, mo, pn);
 }
 
-static int machosymcmp(const void *_a, const void *_b)
+static int machosymcmp(const void *_a, const void *_b, void *arg)
 {
-    TCCState *s1 = tcc_state;
+    TCCState *s1 = arg;
     int ea = ((struct nlist_64 *)_a)->n_value;
     int eb = ((struct nlist_64 *)_b)->n_value;
     ElfSym *sa = (ElfSym *)symtab_section->data + ea;
@@ -492,6 +1126,37 @@ static int machosymcmp(const void *_a, const void *_b)
     return ea - eb;
 }
 
+/* cannot use qsort because code has to be reentrant */
+static void tcc_qsort (void  *base, size_t nel, size_t width,
+                       int (*comp)(const void *, const void *, void *), void *arg)
+{
+    size_t wnel, gap, wgap, i, j, k;
+    char *a, *b, tmp;
+
+    wnel = width * nel;
+    for (gap = 0; ++gap < nel;)
+        gap *= 3;
+    while ( gap /= 3 ) {
+        wgap = width * gap;
+        for (i = wgap; i < wnel; i += width) {
+            for (j = i - wgap; ;j -= wgap) {
+                a = j + (char *)base;
+                b = a + wgap;
+                if ( (*comp)(a, b, arg) <= 0 )
+                    break;
+                k = width;
+                do {
+                    tmp = *a;
+                    *a++ = *b;
+                    *b++ = tmp;
+                } while ( --k );
+                if (j < wgap)
+                    break;
+            }
+        }
+    }
+}
+
 static void create_symtab(TCCState *s1, struct macho *mo)
 {
     int sym_index, sym_end;
@@ -500,9 +1165,37 @@ static void create_symtab(TCCState *s1, struct macho *mo)
     /* Stub creation belongs to check_relocs, but we need to create
        the symbol now, so its included in the sorting.  */
     mo->stubs = new_section(s1, "__stubs", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
+    s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
     mo->stubsym = put_elf_sym(s1->symtab, 0, 0,
                               ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
                               mo->stubs->sh_num, ".__stubs");
+#ifdef CONFIG_NEW_MACHO
+    mo->chained_fixups = new_section(s1, "CHAINED_FIXUPS",
+				     SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+#else
+    mo->stub_helper = new_section(s1, "__stub_helper", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
+    mo->la_symbol_ptr = new_section(s1, "__la_symbol_ptr", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
+    mo->helpsym = put_elf_sym(s1->symtab, 0, 0,
+                              ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
+                              mo->stub_helper->sh_num, ".__stub_helper");
+    mo->lasym = put_elf_sym(s1->symtab, 0, 0,
+                            ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
+                            mo->la_symbol_ptr->sh_num, ".__la_symbol_ptr");
+    section_ptr_add(data_section, -data_section->data_offset & (PTR_SIZE - 1));
+    mo->dyld_private = put_elf_sym(s1->symtab, data_section->data_offset, PTR_SIZE,
+                                   ELFW(ST_INFO)(STB_LOCAL, STT_OBJECT), 0,
+                                   data_section->sh_num, ".__dyld_private");
+    section_ptr_add(data_section, PTR_SIZE);
+    mo->dyld_stub_binder = put_elf_sym(s1->symtab, 0, 0,
+                		       ELFW(ST_INFO)(STB_GLOBAL, STT_OBJECT), 0,
+				       SHN_UNDEF, "dyld_stub_binder");
+    mo->rebase = new_section(s1, "REBASE", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+    mo->binding = new_section(s1, "BINDING", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+    mo->weak_binding = new_section(s1, "WEAK_BINDING", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+    mo->lazy_binding = new_section(s1, "LAZY_BINDING", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+#endif
+    mo->exports = new_section(s1, "EXPORT", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
+    mo->indirsyms = new_section(s1, "LEINDIR", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
 
     mo->symtab = new_section(s1, "LESYMTAB", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
     mo->strtab = new_section(s1, "LESTRTAB", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
@@ -515,9 +1208,8 @@ static void create_symtab(TCCState *s1, struct macho *mo)
         pn[sym_index - 1].n_strx = put_elf_str(mo->strtab, name);
         pn[sym_index - 1].n_value = sym_index;
     }
-    tcc_enter_state(s1);  /* qsort needs global state */
-    qsort(pn, sym_end - 1, sizeof(*pn), machosymcmp);
-    tcc_exit_state(s1);
+    section_ptr_add(mo->strtab, -mo->strtab->data_offset & (PTR_SIZE - 1));
+    tcc_qsort(pn, sym_end - 1, sizeof(*pn), machosymcmp, s1);
     mo->e2msym = tcc_malloc(sym_end * sizeof(*mo->e2msym));
     mo->e2msym[0] = -1;
     for (sym_index = 1; sym_index < sym_end; ++sym_index) {
@@ -526,76 +1218,423 @@ static void create_symtab(TCCState *s1, struct macho *mo)
 }
 
 const struct {
-    int seg;
+    int seg_initial;
     uint32_t flags;
     const char *name;
 } skinfo[sk_last] = {
-    /*[sk_unknown] =*/  { 0 },
-    /*[sk_discard] =*/  { 0 },
-    /*[sk_text] =*/     { 1, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS
-                             | S_ATTR_SOME_INSTRUCTIONS, "__text" },
-    /*[sk_stubs] =*/    { 0 },
-    /*[sk_ro_data] =*/  { 1, S_REGULAR, "__rodata" },
-    /*[sk_uw_info] =*/  { 0 },
-    /*[sk_nl_ptr] =*/   { 2, S_NON_LAZY_SYMBOL_POINTERS, "__got" },
-    /*[sk_la_ptr] =*/   { 0 },
-    /*[sk_init] =*/     { 2, S_MOD_INIT_FUNC_POINTERS, "__mod_init_func" },
-    /*[sk_fini] =*/     { 2, S_MOD_TERM_FUNC_POINTERS, "__mod_term_func" },
-    /*[sk_rw_data] =*/  { 2, S_REGULAR, "__data" },
-    /*[sk_bss] =*/      { 2, S_ZEROFILL, "__bss" },
-    /*[sk_linkedit] =*/ { 3, S_REGULAR, NULL },
+    /*[sk_unknown] =*/        { 0 },
+    /*[sk_discard] =*/        { 0 },
+    /*[sk_text] =*/           { 1, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS
+                                   | S_ATTR_SOME_INSTRUCTIONS, "__text" },
+    /*[sk_stubs] =*/          { 1, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS | S_SYMBOL_STUBS
+                                   | S_ATTR_SOME_INSTRUCTIONS , "__stubs" },
+    /*[sk_stub_helper] =*/    { 1, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS
+                                   | S_ATTR_SOME_INSTRUCTIONS , "__stub_helper" },
+    /*[sk_ro_data] =*/        { 2, S_REGULAR, "__rodata" },
+    /*[sk_uw_info] =*/        { 0 },
+    /*[sk_nl_ptr] =*/         { 2, S_NON_LAZY_SYMBOL_POINTERS, "__got" },
+    /*[sk_debug_info] =*/     { 3, S_REGULAR | S_ATTR_DEBUG, "__debug_info" },
+    /*[sk_debug_abbrev] =*/   { 3, S_REGULAR | S_ATTR_DEBUG, "__debug_abbrev" },
+    /*[sk_debug_line] =*/     { 3, S_REGULAR | S_ATTR_DEBUG, "__debug_line" },
+    /*[sk_debug_aranges] =*/  { 3, S_REGULAR | S_ATTR_DEBUG, "__debug_aranges" },
+    /*[sk_debug_str] =*/      { 3, S_REGULAR | S_ATTR_DEBUG, "__debug_str" },
+    /*[sk_debug_line_str] =*/ { 3, S_REGULAR | S_ATTR_DEBUG, "__debug_line_str" },
+    /*[sk_stab] =*/           { 4, S_REGULAR, "__stab" },
+    /*[sk_stab_str] =*/       { 4, S_REGULAR, "__stab_str" },
+    /*[sk_la_ptr] =*/         { 4, S_LAZY_SYMBOL_POINTERS, "__la_symbol_ptr" },
+    /*[sk_init] =*/           { 4, S_MOD_INIT_FUNC_POINTERS, "__mod_init_func" },
+    /*[sk_fini] =*/           { 4, S_MOD_TERM_FUNC_POINTERS, "__mod_term_func" },
+    /*[sk_rw_data] =*/        { 4, S_REGULAR, "__data" },
+    /*[sk_bss] =*/            { 4, S_ZEROFILL, "__bss" },
+    /*[sk_linkedit] =*/       { 5, S_REGULAR, NULL },
+};
+
+#define	START	((uint64_t)1 << 32)
+
+const struct {
+    int used;
+    const char *name;
+    uint64_t vmaddr;
+    uint64_t vmsize;
+    vm_prot_t maxprot;
+    vm_prot_t initprot;
+    uint32_t flags;
+} all_segment[] = {
+    { 1, "__PAGEZERO",       0, START, 0, 0,            0 },
+    { 0, "__TEXT",       START,     0, 5, 5,            0 },
+    { 0, "__DATA_CONST",    -1,     0, 3, 3, SG_READ_ONLY },
+    { 0, "__DWARF",         -1,     0, 7, 3,            0 },
+    { 0, "__DATA",          -1,     0, 3, 3,            0 },
+    { 1, "__LINKEDIT",      -1,     0, 1, 1,            0 },
 };
 
-static void collect_sections(TCCState *s1, struct macho *mo)
+#define	N_SEGMENT	(sizeof(all_segment)/sizeof(all_segment[0]))
+
+#ifdef CONFIG_NEW_MACHO
+static void calc_fixup_size(TCCState *s1, struct macho *mo)
 {
-    int i, sk, numsec;
-    uint64_t curaddr, fileofs;
-    Section *s;
+    int i, size;
+
+    size = (sizeof(struct dyld_chained_fixups_header) + 7) & -8;
+    size += (sizeof(struct dyld_chained_starts_in_image) + (mo->nseg - 1) * sizeof(uint32_t) + 7) & -8;
+    for (i = (s1->output_type == TCC_OUTPUT_EXE); i < mo->nseg - 1; i++) {
+	int page_count = (get_segment(mo, i)->vmsize + SEG_PAGE_SIZE - 1) / SEG_PAGE_SIZE;
+	size += (sizeof(struct dyld_chained_starts_in_segment) + (page_count - 1) * sizeof(uint16_t) + 7) & -8;
+    }
+    size += mo->n_bind * sizeof (struct dyld_chained_import) + 1;
+    for (i = 0; i < mo->n_bind_rebase; i++) {
+	if (mo->bind_rebase[i].bind) {
+	    int sym_index = ELFW(R_SYM)(mo->bind_rebase[i].rel.r_info);
+	    ElfW(Sym) *sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+	    const char *name = (char *) symtab_section->link->data + sym->st_name;
+	    size += strlen(name) + 1;
+	}
+    }
+    size = (size + 7) & -8;
+    section_ptr_add(mo->chained_fixups, size);
+}
+
+#else
+
+static void set_segment_and_offset(TCCState *s1, struct macho *mo, addr_t addr,
+				   uint8_t *ptr, int opcode,
+				   Section *sec, addr_t offset)
+{
+    int i;
     struct segment_command_64 *seg = NULL;
-    struct dylinker_command *dyldlc;
-    struct symtab_command *symlc;
-    struct dysymtab_command *dysymlc;
-    char *str;
 
-    seg = add_segment(mo, "__PAGEZERO");
-    seg->vmsize = (uint64_t)1 << 32;
+    for (i = (s1->output_type == TCC_OUTPUT_EXE); i < mo->nseg - 1; i++) {
+	seg = get_segment(mo, i);
+	if (addr >= seg->vmaddr && addr < (seg->vmaddr + seg->vmsize))
+	    break;
+    }
+    *ptr = opcode | i;
+    write_uleb128(sec, offset - seg->vmaddr);
+}
 
-    seg = add_segment(mo, "__TEXT");
-    seg->vmaddr = (uint64_t)1 << 32;
-    seg->maxprot = 7;  // rwx
-    seg->initprot = 5; // r-x
+static void bind_rebase(TCCState *s1, struct macho *mo)
+{
+    int i;
+    uint8_t *ptr;
+    ElfW(Sym) *sym;
+    const char *name;
 
-    seg = add_segment(mo, "__DATA");
-    seg->vmaddr = -1;
-    seg->maxprot = 7;  // rwx
-    seg->initprot = 3; // rw-
+    for (i = 0; i < mo->n_lazy_bind; i++) {
+	int sym_index = ELFW(R_SYM)(mo->s_lazy_bind[i].rel.r_info);
+
+	sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+	name = (char *) symtab_section->link->data + sym->st_name;
+	write32le(mo->stub_helper->data +
+		  mo->s_lazy_bind[i].bind_offset,
+		  mo->lazy_binding->data_offset);
+	ptr = section_ptr_add(mo->lazy_binding, 1);
+	set_segment_and_offset(s1, mo, mo->la_symbol_ptr->sh_addr, ptr,
+			       BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
+			       mo->lazy_binding,
+			       mo->s_lazy_bind[i].la_symbol_offset +
+			       mo->la_symbol_ptr->sh_addr);
+	ptr = section_ptr_add(mo->lazy_binding, 5 + strlen(name));
+	*ptr++ = BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
+		 (BIND_SPECIAL_DYLIB_FLAT_LOOKUP & 0xf);
+	*ptr++ = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM | 0;
+	strcpy((char *)ptr, name);
+	ptr += strlen(name) + 1;
+	*ptr++ = BIND_OPCODE_DO_BIND;
+	*ptr = BIND_OPCODE_DONE;
+    }
+    for (i = 0; i < mo->n_rebase; i++) {
+	Section *s = s1->sections[mo->s_rebase[i].section];
+
+	ptr = section_ptr_add(mo->rebase, 2);
+	*ptr++ = REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER;
+	set_segment_and_offset(s1, mo, s->sh_addr, ptr,
+			       REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
+			       mo->rebase,
+			       mo->s_rebase[i].rel.r_offset +
+			       s->sh_addr);
+	ptr = section_ptr_add(mo->rebase, 1);
+	*ptr = REBASE_OPCODE_DO_REBASE_IMM_TIMES | 1;
+    }
+    for (i = 0; i < mo->n_bind; i++) {
+	int sym_index = ELFW(R_SYM)(mo->bind[i].rel.r_info);
+	Section *s = s1->sections[mo->bind[i].section];
+	Section *binding;
+
+	sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+	name = (char *) symtab_section->link->data + sym->st_name;
+	binding = ELFW(ST_BIND)(sym->st_info) == STB_WEAK
+	    ? mo->weak_binding : mo->binding;
+        ptr = section_ptr_add(binding, 4 + (binding == mo->binding) +
+			     	       strlen(name));
+	if (binding == mo->binding)
+            *ptr++ = BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
+	             (BIND_SPECIAL_DYLIB_FLAT_LOOKUP & 0xf);
+        *ptr++ = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM |
+		 (binding == mo->weak_binding
+		  ? BIND_SYMBOL_FLAGS_WEAK_IMPORT : 0);
+        strcpy((char *)ptr, name);
+        ptr += strlen(name) + 1;
+        *ptr++ = BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER;
+	set_segment_and_offset(s1, mo, s->sh_addr, ptr,
+			       BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB,
+			       binding,
+			       mo->bind[i].rel.r_offset + s->sh_addr);
+        ptr = section_ptr_add(binding, 1);
+        *ptr++ = BIND_OPCODE_DO_BIND;
+    }
+    if (mo->rebase->data_offset) {
+        ptr = section_ptr_add(mo->rebase, 1);
+        *ptr = REBASE_OPCODE_DONE;
+    }
+    if (mo->binding->data_offset) {
+        ptr = section_ptr_add(mo->binding, 1);
+        *ptr = BIND_OPCODE_DONE;
+    }
+    if (mo->weak_binding->data_offset) {
+        ptr = section_ptr_add(mo->weak_binding, 1);
+        *ptr = BIND_OPCODE_DONE;
+    }
+    tcc_free(mo->s_lazy_bind);
+    tcc_free(mo->s_rebase);
+    tcc_free(mo->bind);
+}
+#endif
 
-    seg = add_segment(mo, "__LINKEDIT");
-    seg->vmaddr = -1;
-    seg->maxprot = 7;  // rwx
-    seg->initprot = 1; // r--
+struct trie_info {
+    const char *name;
+    int flag;
+    addr_t addr;
+    int str_size;
+    int term_size;
+};
 
-    mo->ep = add_lc(mo, LC_MAIN, sizeof(*mo->ep));
-    mo->ep->entryoff = 4096;
+struct trie_node {
+    int start;
+    int end;
+    int index_start;
+    int index_end;
+    int n_child;
+    struct trie_node *child;
+};
 
-    i = (sizeof(*dyldlc) + strlen("/usr/lib/dyld") + 1 + 7) &-8;
-    dyldlc = add_lc(mo, LC_LOAD_DYLINKER, i);
-    dyldlc->name = sizeof(*dyldlc);
-    str = (char*)dyldlc + dyldlc->name;
-    strcpy(str, "/usr/lib/dyld");
+struct trie_seq {
+    int n_child;
+    struct trie_node *node;
+    int offset;
+    int nest_offset;
+};
 
-    symlc = add_lc(mo, LC_SYMTAB, sizeof(*symlc));
-    dysymlc = add_lc(mo, LC_DYSYMTAB, sizeof(*dysymlc));
+static void create_trie(struct trie_node *node,
+                        int from, int to, int index_start,
+                        int n_trie, struct trie_info *trie)
+{
+    int i;
+    int start, end, index_end;
+    char cur;
+    struct trie_node *child;
+
+    for (i = from; i < to; i = end) {
+        cur = trie[i].name[index_start];
+        start = i++;
+        for (; i < to; i++)
+            if (cur != trie[i].name[index_start])
+                break;
+        end = i;
+        if (start == end - 1 ||
+            (trie[start].name[index_start] &&
+             trie[start].name[index_start + 1] == 0))
+            index_end = trie[start].str_size - 1;
+        else {
+            index_end = index_start + 1;
+            for (;;) {
+                cur = trie[start].name[index_end];
+                for (i = start + 1; i < end; i++)
+                    if (cur != trie[i].name[index_end])
+                        break;
+                if (trie[start].name[index_end] &&
+                    trie[start].name[index_end + 1] == 0) {
+                    end = start + 1;
+                    index_end = trie[start].str_size - 1;
+                    break;
+                }
+                if (i != end)
+                    break;
+                index_end++;
+            }
+        }
+        node->child = tcc_realloc(node->child,
+                                  (node->n_child + 1) *
+                                  sizeof(struct trie_node));
+        child = &node->child[node->n_child];
+        child->start = start;
+        child->end = end;
+        child->index_start = index_start;
+        child->index_end = index_end;
+        child->n_child = 0;
+        child->child = NULL;
+        node->n_child++;
+        if (start != end - 1)
+            create_trie(child, start, end, index_end, n_trie, trie);
+    }
+}
 
-    for(i = 0; i < s1->nb_loaded_dlls; i++) {
-        DLLReference *dllref = s1->loaded_dlls[i];
-        if (dllref->level == 0)
-          add_dylib(mo, dllref->name);
+static int create_seq(int *offset, int *n_seq, struct trie_seq **seq,
+                        struct trie_node *node,
+                        int n_trie, struct trie_info *trie)
+{
+    int i, nest_offset, last_seq = *n_seq, retval = *offset;
+    struct trie_seq *p_seq;
+    struct trie_node *p_nest;
+
+    for (i = 0; i < node->n_child; i++) {
+        p_nest = &node->child[i];
+        *seq = tcc_realloc(*seq, (*n_seq + 1) * sizeof(struct trie_seq));
+        p_seq = &(*seq)[(*n_seq)++];
+        p_seq->n_child = i == 0 ? node->n_child : -1;
+        p_seq->node = p_nest;
+        p_seq->offset = *offset;
+        p_seq->nest_offset = 0;
+        *offset += (i == 0 ? 1 + 1 : 0) +
+                   p_nest->index_end - p_nest->index_start + 1 + 3;
+    }
+    for (i = 0; i < node->n_child; i++) {
+        nest_offset =
+            create_seq(offset, n_seq, seq, &node->child[i], n_trie, trie);
+        p_seq = &(*seq)[last_seq + i];
+        p_seq->nest_offset = nest_offset;
+    }
+    return retval;
+}
+
+static void node_free(struct trie_node *node)
+{
+    int i;
+
+    for (i = 0; i < node->n_child; i++)
+	node_free(&node->child[i]);
+    tcc_free(node->child);
+}
+
+static int triecmp(const void *_a, const void *_b, void *arg)
+{
+    struct trie_info *a = (struct trie_info *) _a;
+    struct trie_info *b = (struct trie_info *) _b;
+    int len_a = strlen(a->name);
+    int len_b = strlen(b->name);
+
+    /* strange sorting needed. Name 'xx' should be after 'xx1' */
+    if (!strncmp(a->name, b->name, len_a < len_b ? len_a : len_b))
+	return len_a < len_b ? 1 : (len_a > len_b ? -1 : 0);
+    return strcmp(a->name, b->name);
+}
+
+static void export_trie(TCCState *s1, struct macho *mo)
+{
+    int i, size, offset = 0, save_offset;
+    uint8_t *ptr;
+    int sym_index;
+    int sym_end = symtab_section->data_offset / sizeof(ElfW(Sym));
+    int n_trie = 0, n_seq = 0;
+    struct trie_info *trie = NULL, *p_trie;
+    struct trie_node node, *p_node;
+    struct trie_seq *seq = NULL;
+    addr_t vm_addr = get_segment(mo, s1->output_type == TCC_OUTPUT_EXE)->vmaddr;
+
+    for (sym_index = 1; sym_index < sym_end; ++sym_index) {
+	ElfW(Sym) *sym = (ElfW(Sym) *)symtab_section->data + sym_index;
+	const char *name = (char*)symtab_section->link->data + sym->st_name;
+
+	if (sym->st_shndx != SHN_UNDEF && sym->st_shndx < SHN_LORESERVE &&
+            (ELFW(ST_BIND)(sym->st_info) == STB_GLOBAL ||
+	     ELFW(ST_BIND)(sym->st_info) == STB_WEAK)) {
+	    int flag = EXPORT_SYMBOL_FLAGS_KIND_REGULAR;
+	    addr_t addr =
+		sym->st_value + s1->sections[sym->st_shndx]->sh_addr - vm_addr;
+
+	    if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
+		flag |= EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION;
+	    dprintf ("%s %d %llx\n", name, flag, (long long)addr + vm_addr);
+	    trie = tcc_realloc(trie, (n_trie + 1) * sizeof(struct trie_info));
+	    trie[n_trie].name = name;
+	    trie[n_trie].flag = flag;
+	    trie[n_trie].addr = addr;
+	    trie[n_trie].str_size = strlen(name) + 1;
+	    trie[n_trie].term_size = uleb128_size(flag) + uleb128_size(addr);
+	    n_trie++;
+	}
     }
+    if (n_trie) {
+        tcc_qsort(trie, n_trie, sizeof(struct trie_info), triecmp, NULL);
+	memset(&node, 0, sizeof(node));
+        create_trie(&node, 0, n_trie, 0, n_trie, trie);
+	create_seq(&offset, &n_seq, &seq, &node, n_trie, trie);
+        save_offset = offset;
+        for (i = 0; i < n_seq; i++) {
+            p_node = seq[i].node;
+            if (p_node->n_child == 0) {
+                p_trie = &trie[p_node->start];
+                seq[i].nest_offset = offset;
+                offset += 1 + p_trie->term_size + 1;
+            }
+        }
+        for (i = 0; i < n_seq; i++) {
+            p_node = seq[i].node;
+            p_trie = &trie[p_node->start];
+            if (seq[i].n_child >= 0) {
+                section_ptr_add(mo->exports,
+				seq[i].offset - mo->exports->data_offset);
+                ptr = section_ptr_add(mo->exports, 2);
+                *ptr++ = 0;
+                *ptr = seq[i].n_child;
+            }
+            size = p_node->index_end - p_node->index_start;
+            ptr = section_ptr_add(mo->exports, size + 1);
+            memcpy(ptr, &p_trie->name[p_node->index_start], size);
+            ptr[size] = 0;
+            write_uleb128(mo->exports, seq[i].nest_offset);
+        }
+        section_ptr_add(mo->exports, save_offset - mo->exports->data_offset);
+        for (i = 0; i < n_seq; i++) {
+            p_node = seq[i].node;
+            if (p_node->n_child == 0) {
+                p_trie = &trie[p_node->start];
+                write_uleb128(mo->exports, p_trie->term_size);
+                write_uleb128(mo->exports, p_trie->flag);
+                write_uleb128(mo->exports, p_trie->addr);
+                ptr = section_ptr_add(mo->exports, 1);
+                *ptr = 0;
+            }
+        }
+        section_ptr_add(mo->exports, -mo->exports->data_offset & 7);
+	node_free(&node);
+        tcc_free(seq);
+    }
+    tcc_free(trie);
+}
+
+static void collect_sections(TCCState *s1, struct macho *mo, const char *filename)
+{
+    int i, sk, numsec;
+    int used_segment[N_SEGMENT];
+    uint64_t curaddr, fileofs;
+    Section *s;
+    struct segment_command_64 *seg;
+    struct dylib_command *dylib;
+#ifdef CONFIG_NEW_MACHO
+    struct linkedit_data_command *chained_fixups_lc;
+    struct linkedit_data_command *export_trie_lc;
+#endif
+    struct build_version_command *dyldbv;
+    struct source_version_command *dyldsv;
+    struct rpath_command *rpath;
+    struct dylinker_command *dyldlc;
+    struct symtab_command *symlc;
+    struct dysymtab_command *dysymlc;
+    char *str;
+
+    for (i = 0; i < N_SEGMENT; i++)
+	used_segment[i] = all_segment[i].used;
 
-    /* dyld requires a writable segment with classic Mach-O, but it ignores
-       zero-sized segments for this, so force to have some data.  */
-    section_ptr_add(data_section, 1);
     memset (mo->sk_to_sect, 0, sizeof(mo->sk_to_sect));
     for (i = s1->nb_sections; i-- > 1;) {
         int type, flags;
@@ -603,19 +1642,49 @@ static void collect_sections(TCCState *s1, struct macho *mo)
         type = s->sh_type;
         flags = s->sh_flags;
         sk = sk_unknown;
-        if (flags & SHF_ALLOC) {
+	/* debug sections have sometimes no SHF_ALLOC */
+        if ((flags & SHF_ALLOC) || !strncmp(s->name, ".debug_", 7)) {
             switch (type) {
             default:           sk = sk_unknown; break;
             case SHT_INIT_ARRAY: sk = sk_init; break;
             case SHT_FINI_ARRAY: sk = sk_fini; break;
             case SHT_NOBITS:   sk = sk_bss; break;
             case SHT_SYMTAB:   sk = sk_discard; break;
-            case SHT_STRTAB:   sk = s == stabstr_section ? sk_ro_data : sk_discard; break;
+            case SHT_STRTAB:
+		if (s == stabstr_section)
+		  sk = sk_stab_str;
+		else
+		  sk = sk_discard;
+		break;
             case SHT_RELX:     sk = sk_discard; break;
             case SHT_LINKEDIT: sk = sk_linkedit; break;
             case SHT_PROGBITS:
-                if (s == s1->got)
+                if (s == mo->stubs)
+                  sk = sk_stubs;
+#ifndef CONFIG_NEW_MACHO
+                else if (s == mo->stub_helper)
+                  sk = sk_stub_helper;
+                else if (s == mo->la_symbol_ptr)
+                  sk = sk_la_ptr;
+#endif
+                else if (s == rodata_section)
+                  sk = sk_ro_data;
+                else if (s == s1->got)
                   sk = sk_nl_ptr;
+                else if (s == stab_section)
+                  sk = sk_stab;
+                else if (s == dwarf_info_section)
+                  sk = sk_debug_info;
+                else if (s == dwarf_abbrev_section)
+                  sk = sk_debug_abbrev;
+                else if (s == dwarf_line_section)
+                  sk = sk_debug_line;
+                else if (s == dwarf_aranges_section)
+                  sk = sk_debug_aranges;
+                else if (s == dwarf_str_section)
+                  sk = sk_debug_str;
+                else if (s == dwarf_line_str_section)
+                  sk = sk_debug_line_str;
                 else if (flags & SHF_EXECINSTR)
                   sk = sk_text;
                 else if (flags & SHF_WRITE)
@@ -628,9 +1697,100 @@ static void collect_sections(TCCState *s1, struct macho *mo)
           sk = sk_discard;
         s->prev = mo->sk_to_sect[sk].s;
         mo->sk_to_sect[sk].s = s;
+	used_segment[skinfo[sk].seg_initial] = 1;
+    }
+
+    if (s1->output_type != TCC_OUTPUT_EXE)
+	used_segment[0] = 0;
+
+    for (i = 0; i < N_SEGMENT; i++)
+	if (used_segment[i]) {
+	    seg = add_segment(mo, all_segment[i].name);
+	    if (i == 1 && s1->output_type != TCC_OUTPUT_EXE)
+	        seg->vmaddr = 0;
+	    else
+	        seg->vmaddr = all_segment[i].vmaddr;
+	    seg->vmsize = all_segment[i].vmsize;
+	    seg->maxprot = all_segment[i].maxprot;
+	    seg->initprot = all_segment[i].initprot;
+	    seg->flags = all_segment[i].flags;
+            for (sk = sk_unknown; sk < sk_last; sk++)
+		if (skinfo[sk].seg_initial == i)
+	            mo->segment[sk] = mo->nseg - 1;
+	}
+
+    if (s1->output_type != TCC_OUTPUT_EXE) {
+	const char *name = s1->install_name ? s1->install_name : filename;
+        i = (sizeof(*dylib) + strlen(name) + 1 + 7) &-8;
+        dylib = add_lc(mo, LC_ID_DYLIB, i);
+	dylib->name = sizeof(*dylib);
+	dylib->timestamp = 1;
+	dylib->current_version =
+	    s1->current_version ? s1->current_version : 1 << 16;
+	dylib->compatibility_version =
+	    s1->compatibility_version ? s1->compatibility_version : 1 << 16;
+        str = (char*)dylib + dylib->name;
+        strcpy(str, name);
+    }
+
+#ifdef CONFIG_NEW_MACHO
+    chained_fixups_lc = add_lc(mo, LC_DYLD_CHAINED_FIXUPS,
+			       sizeof(struct linkedit_data_command));
+    export_trie_lc = add_lc(mo, LC_DYLD_EXPORTS_TRIE,
+			    sizeof(struct linkedit_data_command));
+#else
+    mo->dyldinfo = add_lc(mo, LC_DYLD_INFO_ONLY, sizeof(*mo->dyldinfo));
+#endif
+
+    symlc = add_lc(mo, LC_SYMTAB, sizeof(*symlc));
+    dysymlc = add_lc(mo, LC_DYSYMTAB, sizeof(*dysymlc));
+
+    if (s1->output_type == TCC_OUTPUT_EXE) {
+        i = (sizeof(*dyldlc) + strlen("/usr/lib/dyld") + 1 + 7) &-8;
+        dyldlc = add_lc(mo, LC_LOAD_DYLINKER, i);
+        dyldlc->name = sizeof(*dyldlc);
+        str = (char*)dyldlc + dyldlc->name;
+        strcpy(str, "/usr/lib/dyld");
     }
+
+    dyldbv = add_lc(mo, LC_BUILD_VERSION, sizeof(*dyldbv));
+    dyldbv->platform = PLATFORM_MACOS;
+    dyldbv->minos = (10 << 16) + (6 << 8);
+    dyldbv->sdk = (10 << 16) + (6 << 8);
+    dyldbv->ntools = 0;
+
+    dyldsv = add_lc(mo, LC_SOURCE_VERSION, sizeof(*dyldsv));
+    dyldsv->version = 0;
+
+    if (s1->output_type == TCC_OUTPUT_EXE) {
+        mo->ep = add_lc(mo, LC_MAIN, sizeof(*mo->ep));
+        mo->ep->entryoff = 4096;
+    }
+
+    for(i = 0; i < s1->nb_loaded_dlls; i++) {
+        DLLReference *dllref = s1->loaded_dlls[i];
+        if (dllref->level == 0)
+          add_dylib(mo, dllref->name);
+    }
+
+    if (s1->rpath) {
+	char *path = s1->rpath, *end;
+	do {
+	    end = strchr(path, ':');
+	    if (!end)
+		end = strchr(path, 0);
+            i = (sizeof(*rpath) + (end - path) + 1 + 7) &-8;
+            rpath = add_lc(mo, LC_RPATH, i);
+            rpath->path = sizeof(*rpath);
+            str = (char*)rpath + rpath->path;
+            memcpy(str, path, end - path);
+	    str[end - path] = 0;
+	    path = end + 1;
+	} while (*end);
+    }
+
     fileofs = 4096;  /* leave space for mach-o headers */
-    curaddr = get_segment(mo, 1)->vmaddr;
+    curaddr = get_segment(mo, s1->output_type == TCC_OUTPUT_EXE)->vmaddr;
     curaddr += 4096;
     seg = NULL;
     numsec = 0;
@@ -641,22 +1801,47 @@ static void collect_sections(TCCState *s1, struct macho *mo)
             seg->vmsize = curaddr - seg->vmaddr;
             seg->filesize = fileofs - seg->fileoff;
         }
-        if (skinfo[sk].seg && mo->sk_to_sect[sk].s) {
+#ifdef CONFIG_NEW_MACHO
+	if (sk == sk_linkedit) {
+	    calc_fixup_size(s1, mo);
+	    export_trie(s1, mo);
+	}
+#else
+	if (sk == sk_linkedit) {
+	    bind_rebase(s1, mo);
+	    export_trie(s1, mo);
+	}
+#endif
+        if (skinfo[sk].seg_initial &&
+	    (s1->output_type != TCC_OUTPUT_EXE || mo->segment[sk]) &&
+	    mo->sk_to_sect[sk].s) {
             uint64_t al = 0;
             int si;
-            seg = get_segment(mo, skinfo[sk].seg);
+            seg = get_segment(mo, mo->segment[sk]);
             if (skinfo[sk].name) {
                 si = add_section(mo, &seg, skinfo[sk].name);
                 numsec++;
-                mo->lc[mo->seg2lc[skinfo[sk].seg]] = (struct load_command*)seg;
+                mo->lc[mo->seg2lc[mo->segment[sk]]] = (struct load_command*)seg;
                 mo->sk_to_sect[sk].machosect = si;
                 sec = get_section(seg, si);
                 sec->flags = skinfo[sk].flags;
+		if (sk == sk_stubs)
+#ifdef TCC_TARGET_X86_64
+	    	    sec->reserved2 = 6;
+#elif defined TCC_TARGET_ARM64
+	    	    sec->reserved2 = 12;
+#endif
+		if (sk == sk_nl_ptr)
+	    	    sec->reserved1 = mo->nr_plt;
+#ifndef CONFIG_NEW_MACHO
+		if (sk == sk_la_ptr)
+	    	    sec->reserved1 = mo->nr_plt + mo->n_got;
+#endif
             }
             if (seg->vmaddr == -1) {
-                curaddr = (curaddr + 4095) & -4096;
+                curaddr = (curaddr + SEG_PAGE_SIZE - 1) & -SEG_PAGE_SIZE;
                 seg->vmaddr = curaddr;
-                fileofs = (fileofs + 4095) & -4096;
+                fileofs = (fileofs + SEG_PAGE_SIZE - 1) & -SEG_PAGE_SIZE;
                 seg->fileoff = fileofs;
             }
 
@@ -680,14 +1865,14 @@ static void collect_sections(TCCState *s1, struct macho *mo)
             for (s = mo->sk_to_sect[sk].s; s; s = s->prev) {
                 al = s->sh_addralign;
                 curaddr = (curaddr + al - 1) & -al;
-                dprintf("curaddr now 0x%lx\n", (long)curaddr);
+                dprintf("%s: curaddr now 0x%lx\n", s->name, (long)curaddr);
                 s->sh_addr = curaddr;
                 curaddr += s->sh_size;
                 if (s->sh_type != SHT_NOBITS) {
                     fileofs = (fileofs + al - 1) & -al;
                     s->sh_offset = fileofs;
                     fileofs += s->sh_size;
-                    dprintf("fileofs now %ld\n", (long)fileofs);
+                    dprintf("%s: fileofs now %ld\n", s->name, (long)fileofs);
                 }
                 if (sec)
                   mo->elfsectomacho[s->sh_num] = numsec;
@@ -737,6 +1922,38 @@ static void collect_sections(TCCState *s1, struct macho *mo)
     dysymlc->nundefsym = symlc->nsyms - dysymlc->iundefsym;
     dysymlc->indirectsymoff = mo->indirsyms->sh_offset;
     dysymlc->nindirectsyms = mo->indirsyms->data_offset / sizeof(uint32_t);
+
+#ifdef CONFIG_NEW_MACHO
+    if (mo->chained_fixups->data_offset) {
+        chained_fixups_lc->dataoff = mo->chained_fixups->sh_offset;
+        chained_fixups_lc->datasize = mo->chained_fixups->data_offset;
+    }
+    if (mo->exports->data_offset) {
+        export_trie_lc->dataoff = mo->exports->sh_offset;
+        export_trie_lc->datasize = mo->exports->data_offset;
+    }
+#else
+    if (mo->rebase->data_offset) {
+        mo->dyldinfo->rebase_off = mo->rebase->sh_offset;
+        mo->dyldinfo->rebase_size = mo->rebase->data_offset;
+    }
+    if (mo->binding->data_offset) {
+        mo->dyldinfo->bind_off = mo->binding->sh_offset;
+        mo->dyldinfo->bind_size = mo->binding->data_offset;
+    }
+    if (mo->weak_binding->data_offset) {
+        mo->dyldinfo->weak_bind_off = mo->weak_binding->sh_offset;
+        mo->dyldinfo->weak_bind_size = mo->weak_binding->data_offset;
+    }
+    if (mo->lazy_binding->data_offset) {
+        mo->dyldinfo->lazy_bind_off = mo->lazy_binding->sh_offset;
+        mo->dyldinfo->lazy_bind_size = mo->lazy_binding->data_offset;
+    }
+    if (mo->exports->data_offset) {
+        mo->dyldinfo->export_off = mo->exports->sh_offset;
+        mo->dyldinfo->export_size = mo->exports->data_offset;
+    }
+#endif
 }
 
 static void macho_write(TCCState *s1, struct macho *mo, FILE *fp)
@@ -745,10 +1962,21 @@ static void macho_write(TCCState *s1, struct macho *mo, FILE *fp)
     uint64_t fileofs = 0;
     Section *s;
     mo->mh.mh.magic = MH_MAGIC_64;
-    mo->mh.mh.cputype = 0x1000007;    // x86_64
-    mo->mh.mh.cpusubtype = 0x80000003;// all | CPU_SUBTYPE_LIB64
-    mo->mh.mh.filetype = 2;           // MH_EXECUTE
-    mo->mh.mh.flags = 4;              // DYLDLINK
+#ifdef TCC_TARGET_X86_64
+    mo->mh.mh.cputype = CPU_TYPE_X86_64;
+    mo->mh.mh.cpusubtype = CPU_SUBTYPE_LIB64 | CPU_SUBTYPE_X86_ALL;
+#elif defined TCC_TARGET_ARM64
+    mo->mh.mh.cputype = CPU_TYPE_ARM64;
+    mo->mh.mh.cpusubtype = CPU_SUBTYPE_ARM64_ALL;
+#endif
+    if (s1->output_type == TCC_OUTPUT_EXE) {
+        mo->mh.mh.filetype = MH_EXECUTE;
+        mo->mh.mh.flags = MH_DYLDLINK | MH_PIE;
+    }
+    else {
+        mo->mh.mh.filetype = MH_DYLIB;
+        mo->mh.mh.flags = MH_DYLDLINK;
+    }
     mo->mh.mh.ncmds = mo->nlc;
     mo->mh.mh.sizeofcmds = 0;
     for (i = 0; i < mo->nlc; i++)
@@ -763,9 +1991,11 @@ static void macho_write(TCCState *s1, struct macho *mo, FILE *fp)
 
     for (sk = sk_unknown; sk < sk_last; sk++) {
         //struct segment_command_64 *seg;
-        if (!skinfo[sk].seg || !mo->sk_to_sect[sk].s)
+        if (skinfo[sk].seg_initial == 0 ||
+	    (s1->output_type == TCC_OUTPUT_EXE && !mo->segment[sk]) ||
+	    !mo->sk_to_sect[sk].s)
           continue;
-        /*seg =*/ get_segment(mo, skinfo[sk].seg);
+        /*seg =*/ get_segment(mo, mo->segment[sk]);
         for (s = mo->sk_to_sect[sk].s; s; s = s->prev) {
             if (s->sh_type != SHT_NOBITS) {
                 while (fileofs < s->sh_offset)
@@ -779,6 +2009,172 @@ static void macho_write(TCCState *s1, struct macho *mo, FILE *fp)
     }
 }
 
+#ifdef CONFIG_NEW_MACHO
+static int bind_rebase_cmp(const void *_a, const void *_b, void *arg)
+{
+    TCCState *s1 = arg;
+    struct bind_rebase *a = (struct bind_rebase *) _a;
+    struct bind_rebase *b = (struct bind_rebase *) _b;
+    addr_t aa = s1->sections[a->section]->sh_addr + a->rel.r_offset;
+    addr_t ab = s1->sections[b->section]->sh_addr + b->rel.r_offset;
+
+    return aa > ab ? 1 : aa < ab ? -1 : 0;
+}
+
+ST_FUNC void bind_rebase_import(TCCState *s1, struct macho *mo)
+{
+    int i, j, k, bind_index, size, page_count, sym_index;
+    const char *name;
+    ElfW(Sym) *sym;
+    unsigned char *data = mo->chained_fixups->data;
+    struct segment_command_64 *seg;
+    struct dyld_chained_fixups_header *header;
+    struct dyld_chained_starts_in_image *image;
+    struct dyld_chained_starts_in_segment *segment;
+    struct dyld_chained_import *import;
+
+    tcc_qsort(mo->bind_rebase, mo->n_bind_rebase, sizeof(struct bind_rebase),
+	      bind_rebase_cmp, s1);
+    for (i = 0; i < mo->n_bind_rebase - 1; i++)
+	if (mo->bind_rebase[i].section == mo->bind_rebase[i + 1].section &&
+	    mo->bind_rebase[i].rel.r_offset == mo->bind_rebase[i + 1].rel.r_offset) {
+	    sym_index = ELFW(R_SYM)(mo->bind_rebase[i].rel.r_info);
+            sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+	    name = (char *) symtab_section->link->data + sym->st_name;
+	    tcc_error("Overlap %s/%s %s:%s",
+		      mo->bind_rebase[i].bind ? "bind" : "rebase",
+		      mo->bind_rebase[i + 1].bind ? "bind" : "rebase",
+		      s1->sections[mo->bind_rebase[i].section]->name, name);
+	}
+    header = (struct dyld_chained_fixups_header *) data;
+    data += (sizeof(struct dyld_chained_fixups_header) + 7) & -8;
+    header->starts_offset = data - mo->chained_fixups->data;
+    header->imports_count = mo->n_bind;
+    header->imports_format = DYLD_CHAINED_IMPORT;
+    header->symbols_format = 0;
+    size = sizeof(struct dyld_chained_starts_in_image) +
+	   (mo->nseg - 1) * sizeof(uint32_t);
+    image = (struct dyld_chained_starts_in_image *) data;
+    data += (size + 7) & -8;
+    image->seg_count = mo->nseg;
+    for (i = (s1->output_type == TCC_OUTPUT_EXE); i < mo->nseg - 1; i++) {
+        image->seg_info_offset[i] = (data - mo->chained_fixups->data) -
+				    header->starts_offset;
+	seg = get_segment(mo, i);
+	page_count = (seg->vmsize + SEG_PAGE_SIZE - 1) / SEG_PAGE_SIZE;
+	size = sizeof(struct dyld_chained_starts_in_segment) +
+		      (page_count - 1) * sizeof(uint16_t);
+        segment = (struct dyld_chained_starts_in_segment *) data;
+        data += (size + 7) & -8;
+        segment->size = size;
+        segment->page_size = SEG_PAGE_SIZE;
+#if 1
+#define	PTR_64_OFFSET 0
+#define	PTR_64_MASK   0x7FFFFFFFFFFULL
+        segment->pointer_format = DYLD_CHAINED_PTR_64;
+#else
+#define	PTR_64_OFFSET 0x100000000ULL
+#define	PTR_64_MASK   0xFFFFFFFFFFFFFFULL
+        segment->pointer_format = DYLD_CHAINED_PTR_64_OFFSET;
+#endif
+        segment->segment_offset = seg->fileoff;
+        segment->max_valid_pointer = 0;
+        segment->page_count = page_count;
+	// add bind/rebase
+	bind_index = 0;
+	k = 0;
+	for (j = 0; j < page_count; j++) {
+	    addr_t start = seg->vmaddr + j * SEG_PAGE_SIZE;
+	    addr_t end = start + SEG_PAGE_SIZE;
+	    void *last = NULL;
+	    addr_t last_o = 0;
+	    addr_t cur_o, cur;
+	    struct dyld_chained_ptr_64_rebase *rebase;
+	    struct dyld_chained_ptr_64_bind *bind;
+
+	    segment->page_start[j] = DYLD_CHAINED_PTR_START_NONE;
+	    for (; k < mo->n_bind_rebase; k++) {
+	        Section *s = s1->sections[mo->bind_rebase[k].section];
+		addr_t r_offset = mo->bind_rebase[k].rel.r_offset;
+		addr_t addr = s->sh_addr + r_offset;
+
+		if ((addr & 3) ||
+		    (addr & (SEG_PAGE_SIZE - 1)) > SEG_PAGE_SIZE - PTR_SIZE)
+		    tcc_error("Illegal rel_offset %s %lld",
+			      s->name, (long long)r_offset);
+		if (addr >= end)
+		    break;
+		if (addr >= start) {
+		    cur_o = addr - start;
+	            if (mo->bind_rebase[k].bind) {
+		        if (segment->page_start[j] == DYLD_CHAINED_PTR_START_NONE)
+			    segment->page_start[j] = cur_o;
+		        else {
+			    bind = (struct dyld_chained_ptr_64_bind *) last;
+			    bind->next = (cur_o - last_o) / 4;
+		        }
+		        bind = (struct dyld_chained_ptr_64_bind *)
+				    (s->data + r_offset);
+		        last = bind;
+		        last_o = cur_o;
+		        bind->ordinal = bind_index;
+		        bind->addend = 0;
+		        bind->reserved = 0;
+		        bind->next = 0;
+		        bind->bind = 1;
+		    }
+		    else {
+		        if (segment->page_start[j] == DYLD_CHAINED_PTR_START_NONE)
+			    segment->page_start[j] = cur_o;
+		        else {
+			    rebase = (struct dyld_chained_ptr_64_rebase *) last;
+			    rebase->next = (cur_o - last_o) / 4;
+		        }
+		        rebase = (struct dyld_chained_ptr_64_rebase *)
+				    (s->data + r_offset);
+		        last = rebase;
+		        last_o = cur_o;
+		        cur = (*(uint64_t *) (s->data + r_offset)) -
+			      PTR_64_OFFSET;
+		        rebase->target = cur & PTR_64_MASK;
+		        rebase->high8 = cur >> (64 - 8);
+			if (cur != ((uint64_t)rebase->high8 << (64 - 8)) + rebase->target)
+			    tcc_error("rebase error");
+		        rebase->reserved = 0;
+		        rebase->next = 0;
+		        rebase->bind = 0;
+		    }
+		}
+		bind_index += mo->bind_rebase[k].bind;
+	    }
+	}
+    }
+    // add imports
+    header->imports_offset = data - mo->chained_fixups->data;
+    import = (struct dyld_chained_import *) data;
+    data += mo->n_bind * sizeof (struct dyld_chained_import);
+    header->symbols_offset = data - mo->chained_fixups->data;
+    data++;
+    for (i = 0, bind_index = 0; i < mo->n_bind_rebase; i++) {
+	if (mo->bind_rebase[i].bind) {
+	    import[bind_index].lib_ordinal =
+		BIND_SPECIAL_DYLIB_FLAT_LOOKUP & 0xffu;
+	    import[bind_index].name_offset =
+		(data - mo->chained_fixups->data) - header->symbols_offset;
+	    sym_index = ELFW(R_SYM)(mo->bind_rebase[i].rel.r_info);
+	    sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+	    import[bind_index].weak_import =
+		ELFW(ST_BIND)(sym->st_info) == STB_WEAK;
+	    name = (char *) symtab_section->link->data + sym->st_name;
+            strcpy((char *) data, name);
+	    data += strlen(name) + 1;
+	    bind_index++;
+	}
+    }
+    tcc_free(mo->bind_rebase);
+}
+#endif
+
 ST_FUNC int macho_output_file(TCCState *s1, const char *filename)
 {
     int fd, mode, file_type;
@@ -803,18 +2199,28 @@ ST_FUNC int macho_output_file(TCCState *s1, const char *filename)
         printf("<- %s\n", filename);
 
     tcc_add_runtime(s1);
+    tcc_macho_add_destructor(s1);
     resolve_common_syms(s1);
     create_symtab(s1, &mo);
     check_relocs(s1, &mo);
     ret = check_symbols(s1, &mo);
     if (!ret) {
-        collect_sections(s1, &mo);
+	int save_output = s1->output_type;
+
+        collect_sections(s1, &mo, filename);
         relocate_syms(s1, s1->symtab, 0);
-        mo.ep->entryoff = get_sym_addr(s1, "main", 1, 1)
-                            - get_segment(&mo, 1)->vmaddr;
+	if (s1->output_type == TCC_OUTPUT_EXE)
+            mo.ep->entryoff = get_sym_addr(s1, "main", 1, 1)
+                            -     get_segment(&mo, 1)->vmaddr;
         if (s1->nb_errors)
           goto do_ret;
+	// Macho uses bind/rebase instead of dynsym
+	s1->output_type = TCC_OUTPUT_EXE;
         relocate_sections(s1);
+	s1->output_type = save_output;
+#ifdef CONFIG_NEW_MACHO
+	bind_rebase_import(s1, &mo);
+#endif
         convert_symbols(s1, &mo);
         macho_write(s1, &mo, fp);
     }
@@ -822,11 +2228,23 @@ ST_FUNC int macho_output_file(TCCState *s1, const char *filename)
  do_ret:
     for (i = 0; i < mo.nlc; i++)
       tcc_free(mo.lc[i]);
+    tcc_free(mo.seg2lc);
     tcc_free(mo.lc);
     tcc_free(mo.elfsectomacho);
     tcc_free(mo.e2msym);
 
     fclose(fp);
+#ifdef CONFIG_CODESIGN
+    if (!ret) {
+	char command[1024];
+	int retval;
+
+	snprintf(command, sizeof(command), "codesign -f -s - %s", filename);
+	retval = system (command);
+	if (retval == -1 || !(WIFEXITED(retval) && WEXITSTATUS(retval) == 0))
+	    tcc_error ("command failed '%s'", command);
+    }
+#endif
     return ret;
 }
 
@@ -835,25 +2253,6 @@ static uint32_t macho_swap32(uint32_t x)
   return (x >> 24) | (x << 24) | ((x >> 8) & 0xff00) | ((x & 0xff00) << 8);
 }
 #define SWAP(x) (swap ? macho_swap32(x) : (x))
-
-ST_FUNC int macho_add_dllref(TCCState* s1, int lev, const char* soname)
-{
-     /* if the dll is already loaded, do not load it */
-    DLLReference *dllref;
-    int i;
-    for(i = 0; i < s1->nb_loaded_dlls; i++) {
-        dllref = s1->loaded_dlls[i];
-        if (!strcmp(soname, dllref->name)) {
-            /* but update level if needed */
-            if (lev < dllref->level)
-                dllref->level = lev;
-            return -1;
-        }
-    }
-    tcc_add_dllref(s1, soname)->level = lev;
-    return 0;
-}
-
 #define tbd_parse_movepast(s) \
     (pos = (pos = strstr(pos, s)) ? pos + strlen(s) : NULL)
 #define tbd_parse_movetoany(cs) (pos = strpbrk(pos, cs))
@@ -940,7 +2339,8 @@ ST_FUNC int macho_load_tbd(TCCState* s1, int fd, const char* filename, int lev)
     if (!tbd_parse_movetoany("\n \"'")) goto the_end;
     tbd_parse_trample;
     ret = 0;
-    if (macho_add_dllref(s1, lev, soname) != 0) goto the_end;
+    if (tcc_add_dllref(s1, soname, lev)->found)
+        goto the_end;
     while(pos) {
         char* sym = NULL;
         int cont = 1;
@@ -992,8 +2392,13 @@ ST_FUNC int macho_load_dll(TCCState * s1, int fd, const char* filename, int lev)
                                         fh.nfat_arch * sizeof(*fa));
         swap = fh.magic == FAT_CIGAM;
         for (i = 0; i < SWAP(fh.nfat_arch); i++)
-          if (SWAP(fa[i].cputype) == 0x01000007 /* CPU_TYPE_X86_64 */
-              && SWAP(fa[i].cpusubtype) == 3)   /* CPU_SUBTYPE_X86_ALL */
+#ifdef TCC_TARGET_X86_64
+          if (SWAP(fa[i].cputype) == CPU_TYPE_X86_64
+              && SWAP(fa[i].cpusubtype) == CPU_SUBTYPE_X86_ALL)
+#elif defined TCC_TARGET_ARM64
+          if (SWAP(fa[i].cputype) == CPU_TYPE_ARM64
+              && SWAP(fa[i].cpusubtype) == CPU_SUBTYPE_ARM64_ALL)
+#endif
             break;
         if (i == SWAP(fh.nfat_arch)) {
             tcc_free(fa);
@@ -1062,7 +2467,7 @@ ST_FUNC int macho_load_dll(TCCState * s1, int fd, const char* filename, int lev)
         lc = (struct load_command*) ((char*)lc + lc->cmdsize);
     }
 
-    if (0 != macho_add_dllref(s1, lev, soname))
+    if (tcc_add_dllref(s1, soname, lev)->found)
         goto the_end;
 
     if (!nsyms || !nextdef)
diff --git a/tccpe.c b/tccpe.c
index 07501a966..11ec6df61 100644
--- a/tccpe.c
+++ b/tccpe.c
@@ -301,8 +301,7 @@ enum {
     sec_pdata ,
     sec_other ,
     sec_rsrc ,
-    sec_stab ,
-    sec_stabstr ,
+    sec_debug ,
     sec_reloc ,
     sec_last
 };
@@ -324,7 +323,7 @@ static const DWORD pe_sec_flags[] = {
 struct section_info {
     int cls;
     char name[32];
-    DWORD sh_addr;
+    ADDR3264 sh_addr;
     DWORD sh_size;
     DWORD pe_flags;
     Section *sec;
@@ -451,9 +450,9 @@ static DWORD pe_file_align(struct pe_info *pe, DWORD n)
     return (n + (pe->file_align - 1)) & ~(pe->file_align - 1);
 }
 
-static DWORD pe_virtual_align(struct pe_info *pe, DWORD n)
+static ADDR3264 pe_virtual_align(struct pe_info *pe, ADDR3264 n)
 {
-    return (n + (pe->section_align - 1)) & ~(pe->section_align - 1);
+    return (n + (pe->section_align - 1)) & ~(ADDR3264)(pe->section_align - 1);
 }
 
 static void pe_align_section(Section *s, int a)
@@ -475,9 +474,9 @@ struct pe_file {
     unsigned pos;
 };
 
-static int pe_fwrite(void *data, int len, struct pe_file *pf)
+static int pe_fwrite(const void *data, int len, struct pe_file *pf)
 {
-    WORD *p = data;
+    const WORD *p = data;
     DWORD sum;
     int ret, i;
     pf->pos += (ret = fwrite(data, 1, len, pf->op));
@@ -502,6 +501,51 @@ static void pe_fpad(struct pe_file *pf, DWORD new_pos)
     pf->pos = new_pos;
 }
 
+/*----------------------------------------------------------------------------*/
+/* PE-DWARF/COFF support
+   does not work with a mingw-gdb really but works with cv2pdb
+   (https://github.com/rainers/cv2pdb) */
+
+#define N_COFF_SYMS 0
+
+static const char dwarf_secs[] =
+{
+    ".debug_info\0"
+    ".debug_abbrev\0"
+    ".debug_line\0"
+    ".debug_aranges\0"
+    ".debug_str\0"
+    ".debug_line_str\0"
+};
+
+static const unsigned coff_strtab_size = 4 + sizeof dwarf_secs - 1;
+
+static int pe_put_long_secname(char *secname, const char *name)
+{
+    const char *d = dwarf_secs;
+    do {
+        if (0 == strcmp(d, name)) {
+            sprintf(secname, "/%d", (int)(d - dwarf_secs + 4));
+            return 1;
+        }
+        d = strchr(d, 0) + 1;
+    } while (*d);
+    return 0;
+}
+
+static void pe_create_pdb(TCCState *s1, const char *exename)
+{
+    char buf[300]; int r;
+    snprintf(buf, sizeof buf, "cv2pdb.exe %s", exename);
+    r = system(buf);
+    strcpy(tcc_fileextension(strcpy(buf, exename)), ".pdb");
+    if (r) {
+        tcc_error_noabort("could not create '%s'\n(need working cv2pdb from https://github.com/rainers/cv2pdb)", buf);
+    } else if (s1->verbose) {
+        printf("<- %s\n", buf);
+    }
+}
+
 /*----------------------------------------------------------------------------*/
 static int pe_write(struct pe_info *pe)
 {
@@ -616,12 +660,11 @@ static int pe_write(struct pe_info *pe)
     struct section_info *si;
     IMAGE_SECTION_HEADER *psh;
     TCCState *s1 = pe->s1;
+    int need_strtab = 0;
 
     pf.op = fopen(pe->filename, "wb");
-    if (NULL == pf.op) {
-        tcc_error_noabort("could not write '%s': %s", pe->filename, strerror(errno));
-        return -1;
-    }
+    if (NULL == pf.op)
+        return tcc_error_noabort("could not write '%s': %s", pe->filename, strerror(errno));
 
     pe->sizeofheaders = pe_file_align(pe,
         sizeof (struct pe_header)
@@ -688,6 +731,8 @@ static int pe_write(struct pe_info *pe)
         }
 
         memcpy(psh->Name, sh_name, umin(strlen(sh_name), sizeof psh->Name));
+        if (si->cls == sec_debug)
+            need_strtab += pe_put_long_secname(psh->Name, sh_name);
 
         psh->Characteristics = si->pe_flags;
         psh->VirtualAddress = addr;
@@ -717,7 +762,10 @@ static int pe_write(struct pe_info *pe)
     if (PE_DLL == pe->type)
         pe_header.filehdr.Characteristics = CHARACTERISTICS_DLL;
     pe_header.filehdr.Characteristics |= pe->s1->pe_characteristics;
-
+    if (need_strtab) {
+        pe_header.filehdr.PointerToSymbolTable = file_offset;
+        pe_header.filehdr.NumberOfSymbols = N_COFF_SYMS;
+    }
     pe_fwrite(&pe_header, sizeof pe_header, &pf);
     for (i = 0; i < pe->sec_count; ++i)
         pe_fwrite(&pe->sec_info[i]->ish, sizeof(IMAGE_SECTION_HEADER), &pf);
@@ -738,6 +786,13 @@ static int pe_write(struct pe_info *pe)
         pe_fpad(&pf, file_offset);
     }
 
+    if (need_strtab) {
+        /* create a tiny COFF string table with the long section names */
+        pe_fwrite(&coff_strtab_size, sizeof coff_strtab_size, &pf);
+        pe_fwrite(dwarf_secs, sizeof dwarf_secs - 1, &pf);
+        file_offset = pf.pos;
+    }
+
     pf.sum += file_offset;
     fseek(pf.op, offsetof(struct pe_header, opthdr.CheckSum), SEEK_SET);
     pe_fwrite(&pf.sum, sizeof (DWORD), &pf);
@@ -752,6 +807,8 @@ static int pe_write(struct pe_info *pe)
     if (pe->s1->verbose)
         printf("<- %s (%u bytes)\n", pe->filename, (unsigned)file_offset);
 
+    if (s1->do_debug & 16)
+        pe_create_pdb(s1, pe->filename);
     return 0;
 }
 
@@ -1071,12 +1128,18 @@ static int pe_section_class(Section *s)
 {
     int type, flags;
     const char *name;
-
     type = s->sh_type;
     flags = s->sh_flags;
     name = s->name;
-    if (flags & SHF_ALLOC) {
-        if (type == SHT_PROGBITS) {
+
+    if (0 == memcmp(name, ".stab", 5) || 0 == memcmp(name, ".debug_", 7)) {
+        if (s->s1->do_debug)
+            return sec_debug;
+
+    } else if (flags & SHF_ALLOC) {
+        if (type == SHT_PROGBITS
+         || type == SHT_INIT_ARRAY
+         || type == SHT_FINI_ARRAY) {
             if (flags & SHF_EXECINSTR)
                 return sec_text;
             if (flags & SHF_WRITE)
@@ -1089,57 +1152,49 @@ static int pe_section_class(Section *s)
                 return sec_pdata;
             return sec_rdata;
         } else if (type == SHT_NOBITS) {
-            if (flags & SHF_WRITE)
-                return sec_bss;
+            return sec_bss;
         }
+        return sec_other;
     } else {
         if (0 == strcmp(name, ".reloc"))
             return sec_reloc;
     }
-    if (0 == memcmp(name, ".stab", 5))
-        return name[5] ? sec_stabstr : sec_stab;
-    if (flags & SHF_ALLOC)
-        return sec_other;
-    return -1;
+    return sec_last;
 }
 
 static int pe_assign_addresses (struct pe_info *pe)
 {
-    int i, k, o, c;
-    DWORD addr;
-    int *section_order;
+    int i, k, n, c, nbs;
+    ADDR3264 addr;
+    int *sec_order, *sec_cls;
     struct section_info *si;
     Section *s;
     TCCState *s1 = pe->s1;
 
     if (PE_DLL == pe->type)
         pe->reloc = new_section(pe->s1, ".reloc", SHT_PROGBITS, 0);
-    // pe->thunk = new_section(pe->s1, ".iedat", SHT_PROGBITS, SHF_ALLOC);
-
-    section_order = tcc_malloc(pe->s1->nb_sections * sizeof (int));
-    for (o = k = 0 ; k < sec_last; ++k) {
-        for (i = 1; i < s1->nb_sections; ++i) {
-            s = s1->sections[i];
-            if (k == pe_section_class(s))
-                section_order[o++] = i;
-        }
-    }
+    //pe->thunk = new_section(pe->s1, ".iedat", SHT_PROGBITS, SHF_ALLOC);
 
+    nbs = s1->nb_sections;
+    sec_order = tcc_mallocz(2 * sizeof (int) * nbs);
+    sec_cls = sec_order + nbs;
+    for (i = 1; i < nbs; ++i) {
+        s = s1->sections[i];
+        k = pe_section_class(s);
+        for (n = i; n > 1 && k < (c = sec_cls[n - 1]); --n)
+            sec_cls[n] = c, sec_order[n] = sec_order[n - 1];
+        sec_cls[n] = k, sec_order[n] = i;
+    }
     si = NULL;
     addr = pe->imagebase + 1;
 
-    for (i = 0; i < o; ++i) {
-        k = section_order[i];
-        s = s1->sections[k];
-        c = pe_section_class(s);
-
-        if ((c == sec_stab || c == sec_stabstr) && 0 == s1->do_debug)
-            continue;
+    for (i = 1; (c = sec_cls[i]) < sec_last; ++i) {
+        s = s1->sections[sec_order[i]];
 
         if (PE_MERGE_DATA && c == sec_bss)
             c = sec_data;
 
-        if (si && c == si->cls) {
+        if (si && c == si->cls && c != sec_debug) {
             /* merge with previous section */
             s->sh_addr = addr = ((addr - 1) | (16 - 1)) + 1;
         } else {
@@ -1195,28 +1250,31 @@ static int pe_assign_addresses (struct pe_info *pe)
         }
         //printf("%08x %05x %08x %s\n", si->sh_addr, si->sh_size, si->pe_flags, s->name);
     }
-    tcc_free(section_order);
 #if 0
-    for (i = 1; i < s1->nb_sections; ++i) {
-        Section *s = s1->sections[i];
+    for (i = 1; i < nbs; ++i) {
+        Section *s = s1->sections[sec_order[i]];
         int type = s->sh_type;
         int flags = s->sh_flags;
-        printf("section %-16s %-10s %08x %04x %s,%s,%s\n",
+        printf("section %-16s %-10s %p %04x %s,%s,%s\n",
             s->name,
             type == SHT_PROGBITS ? "progbits" :
+            type == SHT_INIT_ARRAY ? "initarr" :
+            type == SHT_FINI_ARRAY ? "finiarr" :
             type == SHT_NOBITS ? "nobits" :
             type == SHT_SYMTAB ? "symtab" :
             type == SHT_STRTAB ? "strtab" :
             type == SHT_RELX ? "rel" : "???",
             s->sh_addr,
-            s->data_offset,
+            (unsigned)s->data_offset,
             flags & SHF_ALLOC ? "alloc" : "",
             flags & SHF_WRITE ? "write" : "",
             flags & SHF_EXECINSTR ? "exec" : ""
             );
+        fflush(stdout);
     }
     s1->verbose = 2;
 #endif
+    tcc_free(sec_order);
     return 0;
 }
 
@@ -1279,7 +1337,7 @@ static int pe_check_symbols(struct pe_info *pe)
             is = pe_add_import(pe, imp_sym);
 
             if (type == STT_FUNC) {
-                unsigned long offset = is->thk_offset;
+                unsigned offset = is->thk_offset;
                 if (offset) {
                     /* got aliased symbol, like stricmp and _stricmp */
                 } else {
@@ -1336,9 +1394,8 @@ static int pe_check_symbols(struct pe_info *pe)
             if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
                 /* STB_WEAK undefined symbols are accepted */
                 continue;
-            tcc_error_noabort("undefined symbol '%s'%s", name,
+            ret = tcc_error_noabort("undefined symbol '%s'%s", name,
                 imp_sym < 0 ? ", missing __declspec(dllimport)?":"");
-            ret = -1;
 
         } else if (pe->s1->rdynamic
                    && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
@@ -1533,16 +1590,6 @@ ST_FUNC int pe_putimport(TCCState *s1, int dllindex, const char *name, addr_t va
         );
 }
 
-static int pe_add_dllref(TCCState *s1, const char *dllname)
-{
-    int i;
-    for (i = 0; i < s1->nb_loaded_dlls; ++i)
-        if (0 == strcmp(s1->loaded_dlls[i]->name, dllname))
-            return i + 1;
-    tcc_add_dllref(s1, dllname);
-    return s1->nb_loaded_dlls;
-}
-
 static int read_mem(int fd, unsigned offset, void *buffer, unsigned len)
 {
     lseek(fd, offset, SEEK_SET);
@@ -1732,7 +1779,7 @@ static int pe_load_def(TCCState *s1, int fd)
             ++state;
             break;
         case 2:
-            dllindex = pe_add_dllref(s1, dllname);
+            dllindex = tcc_add_dllref(s1, dllname, 0)->index;
             ++state;
             /* fall through */
         default:
@@ -1769,7 +1816,7 @@ static int pe_load_dll(TCCState *s1, int fd, const char *filename)
     if (ret) {
         return -1;
     } else if (p) {
-        index = pe_add_dllref(s1, filename);
+        index = tcc_add_dllref(s1, filename, 0)->index;
         for (q = p; *q; q += 1 + strlen(q))
             pe_putimport(s1, index, q, 0);
         tcc_free(p);
@@ -1868,12 +1915,6 @@ ST_FUNC void pe_add_unwind_data(unsigned start, unsigned end, unsigned stack)
 #define PE_STDSYM(n,s) "_" n s
 #endif
 
-static void tcc_add_support(TCCState *s1, const char *filename)
-{
-    if (tcc_add_dll(s1, filename, 0) < 0)
-        tcc_error_noabort("%s not found", filename);
-}
-
 static void pe_add_runtime(TCCState *s1, struct pe_info *pe)
 {
     const char *start_symbol;
@@ -2005,7 +2046,6 @@ static void pe_set_options(TCCState * s1, struct pe_info *pe)
 
 ST_FUNC int pe_output_file(TCCState *s1, const char *filename)
 {
-    int ret;
     struct pe_info pe;
 
     memset(&pe, 0, sizeof pe);
@@ -2020,9 +2060,9 @@ ST_FUNC int pe_output_file(TCCState *s1, const char *filename)
     pe_add_runtime(s1, &pe);
     resolve_common_syms(s1);
     pe_set_options(s1, &pe);
+    pe_check_symbols(&pe);
 
-    ret = pe_check_symbols(&pe);
-    if (ret)
+    if (s1->nb_errors)
         ;
     else if (filename) {
         pe_assign_addresses(&pe);
@@ -2031,10 +2071,8 @@ ST_FUNC int pe_output_file(TCCState *s1, const char *filename)
         relocate_sections(s1);
         pe.start_addr = (DWORD)
             (get_sym_addr(s1, pe.start_symbol, 1, 1) - pe.imagebase);
-        if (s1->nb_errors)
-            ret = -1;
-        else
-            ret = pe_write(&pe);
+        if (0 == s1->nb_errors)
+            pe_write(&pe);
         dynarray_reset(&pe.sec_info, &pe.sec_count);
     } else {
 #ifdef TCC_IS_NATIVE
@@ -2046,15 +2084,12 @@ ST_FUNC int pe_output_file(TCCState *s1, const char *filename)
 #endif
 #endif
     }
-
     pe_free_imports(&pe);
-
 #if PE_PRINT_SECTIONS
     if (s1->g_debug & 8)
         pe_print_sections(s1, "tcc.log");
 #endif
-    return ret;
+    return s1->nb_errors ? -1 : 0;
 }
 
 /* ------------------------------------------------------------- */
-
diff --git a/tccpp.c b/tccpp.c
index 2ff5d5e9b..dc68dc178 100644
--- a/tccpp.c
+++ b/tccpp.c
@@ -21,6 +21,9 @@
 #define USING_GLOBALS
 #include "tcc.h"
 
+/* #define to 1 to enable (see parse_pp_string()) */
+#define ACCEPT_LF_IN_STRINGS 0
+
 /********************************************************/
 /* global variables */
 
@@ -28,7 +31,7 @@ ST_DATA int tok_flags;
 ST_DATA int parse_flags;
 
 ST_DATA struct BufferedFile *file;
-ST_DATA int ch, tok;
+ST_DATA int tok;
 ST_DATA CValue tokc;
 ST_DATA const int *macro_ptr;
 ST_DATA CString tokcstr; /* current parsed string, if any */
@@ -42,11 +45,9 @@ ST_DATA TokenSym **table_ident;
 static TokenSym *hash_ident[TOK_HASH_SIZE];
 static char token_buf[STRING_MAX_SIZE + 1];
 static CString cstr_buf;
-static CString macro_equal_buf;
 static TokenString tokstr_buf;
 static unsigned char isidnum_table[256 - CH_EOF];
 static int pp_debug_tok, pp_debug_symv;
-static int pp_once;
 static int pp_expr;
 static int pp_counter;
 static void tok_print(const char *msg, const int *str);
@@ -97,8 +98,11 @@ static void next_nomacro(void);
 
 ST_FUNC void skip(int c)
 {
-    if (tok != c)
-        tcc_error("'%c' expected (got \"%s\")", c, get_tok_str(tok, &tokc));
+    if (tok != c) {
+        char tmp[40];
+        pstrcpy(tmp, sizeof tmp, get_tok_str(c, &tokc));
+        tcc_error("'%s' expected (got \"%s\")", tmp, get_tok_str(tok, &tokc));
+	}
     next();
 }
 
@@ -349,9 +353,10 @@ ST_INLN char *unicode_to_utf8 (char *b, uint32_t Uc)
 {
     if (Uc<0x80) *b++=Uc;
     else if (Uc<0x800) *b++=192+Uc/64, *b++=128+Uc%64;
-    else if (Uc-0xd800u<0x800) return b;
+    else if (Uc-0xd800u<0x800) goto error;
     else if (Uc<0x10000) *b++=224+Uc/4096, *b++=128+Uc/64%64, *b++=128+Uc%64;
     else if (Uc<0x110000) *b++=240+Uc/262144, *b++=128+Uc/4096%64, *b++=128+Uc/64%64, *b++=128+Uc%64;
+    else error: tcc_error("0x%x is not a valid universal character", Uc);
     return b;
 }
 
@@ -395,7 +400,6 @@ ST_FUNC void cstr_new(CString *cstr)
 ST_FUNC void cstr_free(CString *cstr)
 {
     tcc_free(cstr->data);
-    cstr_new(cstr);
 }
 
 /* reset string to empty */
@@ -416,7 +420,7 @@ ST_FUNC int cstr_vprintf(CString *cstr, const char *fmt, va_list ap)
         va_copy(v, ap);
         len = vsnprintf((char*)cstr->data + cstr->size, size, fmt, v);
         va_end(v);
-        if (len > 0 && len < size)
+        if (len >= 0 && len < size)
             break;
         size *= 2;
     }
@@ -573,17 +577,13 @@ ST_FUNC const char *get_tok_str(int v, CValue *cv)
         break;
 
     case TOK_CFLOAT:
-        cstr_cat(&cstr_buf, "<float>", 0);
-        break;
+        return strcpy(p, "<float>");
     case TOK_CDOUBLE:
-	cstr_cat(&cstr_buf, "<double>", 0);
-	break;
+        return strcpy(p, "<double>");
     case TOK_CLDOUBLE:
-	cstr_cat(&cstr_buf, "<long double>", 0);
-	break;
+        return strcpy(p, "<long double>");
     case TOK_LINENUM:
-	cstr_cat(&cstr_buf, "<linenumber>", 0);
-	break;
+        return strcpy(p, "<linenumber");
 
     /* above tokens have value, the ones below don't */
     case TOK_LT:
@@ -600,6 +600,8 @@ ST_FUNC const char *get_tok_str(int v, CValue *cv)
         return strcpy(p, ">>=");
     case TOK_EOF:
         return strcpy(p, "<eof>");
+    case 0: /* anonymous nameless symbols */
+        return strcpy(p, "<no name>");
     default:
         if (v < TOK_IDENT) {
             /* search in two bytes table */
@@ -613,13 +615,12 @@ ST_FUNC const char *get_tok_str(int v, CValue *cv)
                 }
                 q += 3;
             }
-        if (v >= 127) {
-            sprintf(cstr_buf.data, "<%02x>", v);
-            return cstr_buf.data;
-        }
-        addv:
+            if (v >= 127 || (v < 32 && !is_space(v) && v != '\n')) {
+                sprintf(p, "<\\x%02x>", v);
+                break;
+            }
+    addv:
             *p++ = v;
-    case 0: /* nameless anonymous symbol */
             *p = '\0';
         } else if (v < tok_ident) {
             return table_ident[v - TOK_IDENT]->str;
@@ -635,6 +636,17 @@ ST_FUNC const char *get_tok_str(int v, CValue *cv)
     return cstr_buf.data;
 }
 
+static inline int check_space(int t, int *spc)
+{
+    if (t < 256 && (isidnum_table[t - CH_EOF] & IS_SPC)) {
+        if (*spc)
+            return 1;
+        *spc = 1;
+    } else
+        *spc = 0;
+    return 0;
+}
+
 /* return the current character, handling end of block if necessary
    (but not stray) */
 static int handle_eob(void)
@@ -670,132 +682,102 @@ static int handle_eob(void)
 }
 
 /* read next char from current input file and handle end of input buffer */
-static inline void inp(void)
+static int next_c(void)
 {
-    ch = *(++(file->buf_ptr));
+    int ch = *++file->buf_ptr;
     /* end of buffer/file handling */
-    if (ch == CH_EOB)
+    if (ch == CH_EOB && file->buf_ptr >= file->buf_end)
         ch = handle_eob();
+    return ch;
 }
 
-/* handle '\[\r]\n' */
-static int handle_stray_noerror(void)
+/* input with '\[\r]\n' handling. */
+static int handle_stray_noerror(int err)
 {
-    while (ch == '\\') {
-        inp();
+    int ch;
+    while ((ch = next_c()) == '\\') {
+        ch = next_c();
         if (ch == '\n') {
+    newl:
             file->line_num++;
-            inp();
-        } else if (ch == '\r') {
-            inp();
-            if (ch != '\n')
-                goto fail;
-            file->line_num++;
-            inp();
         } else {
-        fail:
-            return 1;
+            if (ch == '\r') {
+                ch = next_c();
+                if (ch == '\n')
+                    goto newl;
+                *--file->buf_ptr = '\r';
+            }
+            if (err)
+                tcc_error("stray '\\' in program");
+            /* may take advantage of 'BufferedFile.unget[4}' */
+            return *--file->buf_ptr = '\\';
         }
     }
-    return 0;
+    return ch;
 }
 
-static void handle_stray(void)
+#define ninp() handle_stray_noerror(0)
+
+/* handle '\\' in strings, comments and skipped regions */
+static int handle_bs(uint8_t **p)
 {
-    if (handle_stray_noerror())
-        tcc_error("stray '\\' in program");
+    int c;
+    file->buf_ptr = *p - 1;
+    c = ninp();
+    *p = file->buf_ptr;
+    return c;
 }
 
 /* skip the stray and handle the \\n case. Output an error if
    incorrect char after the stray */
-static int handle_stray1(uint8_t *p)
+static int handle_stray(uint8_t **p)
 {
     int c;
-
-    file->buf_ptr = p;
-    if (p >= file->buf_end) {
-        c = handle_eob();
-        if (c != '\\')
-            return c;
-        p = file->buf_ptr;
-    }
-    ch = *p;
-    if (handle_stray_noerror()) {
-        if (!(parse_flags & PARSE_FLAG_ACCEPT_STRAYS))
-            tcc_error("stray '\\' in program");
-        *--file->buf_ptr = '\\';
-    }
-    p = file->buf_ptr;
-    c = *p;
+    file->buf_ptr = *p - 1;
+    c = handle_stray_noerror(!(parse_flags & PARSE_FLAG_ACCEPT_STRAYS));
+    *p = file->buf_ptr;
     return c;
 }
 
-/* handle just the EOB case, but not stray */
-#define PEEKC_EOB(c, p)\
-{\
-    p++;\
-    c = *p;\
-    if (c == '\\') {\
-        file->buf_ptr = p;\
-        c = handle_eob();\
-        p = file->buf_ptr;\
-    }\
-}
-
 /* handle the complicated stray case */
 #define PEEKC(c, p)\
 {\
-    p++;\
-    c = *p;\
-    if (c == '\\') {\
-        c = handle_stray1(p);\
-        p = file->buf_ptr;\
-    }\
+    c = *++p;\
+    if (c == '\\')\
+        c = handle_stray(&p); \
 }
 
-/* input with '\[\r]\n' handling. Note that this function cannot
-   handle other characters after '\', so you cannot call it inside
-   strings or comments */
-static void minp(void)
+static int skip_spaces(void)
 {
-    inp();
-    if (ch == '\\') 
-        handle_stray();
+    int ch;
+    --file->buf_ptr;
+    do {
+        ch = ninp();
+    } while (isidnum_table[ch - CH_EOF] & IS_SPC);
+    return ch;
 }
 
 /* single line C++ comments */
 static uint8_t *parse_line_comment(uint8_t *p)
 {
     int c;
-
-    p++;
     for(;;) {
-        c = *p;
+        for (;;) {
+            c = *++p;
     redo:
-        if (c == '\n' || c == CH_EOF) {
-            break;
-        } else if (c == '\\') {
-            file->buf_ptr = p;
-            c = handle_eob();
-            p = file->buf_ptr;
-            if (c == '\\') {
-                PEEKC_EOB(c, p);
-                if (c == '\n') {
-                    file->line_num++;
-                    PEEKC_EOB(c, p);
-                } else if (c == '\r') {
-                    PEEKC_EOB(c, p);
-                    if (c == '\n') {
-                        file->line_num++;
-                        PEEKC_EOB(c, p);
-                    }
-                }
-            } else {
-                goto redo;
-            }
-        } else {
-            p++;
+            if (c == '\n' || c == '\\')
+                break;
+            c = *++p;
+            if (c == '\n' || c == '\\')
+                break;
         }
+        if (c == '\n')
+            break;
+        c = handle_bs(&p);
+        if (c == CH_EOF)
+            break;
+        if (c != '\\')
+            goto redo;
     }
     return p;
 }
@@ -804,161 +786,97 @@ static uint8_t *parse_line_comment(uint8_t *p)
 static uint8_t *parse_comment(uint8_t *p)
 {
     int c;
-
-    p++;
     for(;;) {
         /* fast skip loop */
         for(;;) {
-            c = *p;
+            c = *++p;
+        redo:
             if (c == '\n' || c == '*' || c == '\\')
                 break;
-            p++;
-            c = *p;
+            c = *++p;
             if (c == '\n' || c == '*' || c == '\\')
                 break;
-            p++;
         }
         /* now we can handle all the cases */
         if (c == '\n') {
             file->line_num++;
-            p++;
         } else if (c == '*') {
-            p++;
-            for(;;) {
-                c = *p;
-                if (c == '*') {
-                    p++;
-                } else if (c == '/') {
-                    goto end_of_comment;
-                } else if (c == '\\') {
-                    file->buf_ptr = p;
-                    c = handle_eob();
-                    p = file->buf_ptr;
-                    if (c == CH_EOF)
-                        tcc_error("unexpected end of file in comment");
-                    if (c == '\\') {
-                        /* skip '\[\r]\n', otherwise just skip the stray */
-                        while (c == '\\') {
-                            PEEKC_EOB(c, p);
-                            if (c == '\n') {
-                                file->line_num++;
-                                PEEKC_EOB(c, p);
-                            } else if (c == '\r') {
-                                PEEKC_EOB(c, p);
-                                if (c == '\n') {
-                                    file->line_num++;
-                                    PEEKC_EOB(c, p);
-                                }
-                            } else {
-                                goto after_star;
-                            }
-                        }
-                    }
-                } else {
-                    break;
-                }
-            }
-        after_star: ;
+            do {
+                c = *++p;
+            } while (c == '*');
+            if (c == '\\')
+                c = handle_bs(&p);
+            if (c == '/')
+                break;
+            goto check_eof;
         } else {
-            /* stray, eob or eof */
-            file->buf_ptr = p;
-            c = handle_eob();
-            p = file->buf_ptr;
-            if (c == CH_EOF) {
+            c = handle_bs(&p);
+        check_eof:
+            if (c == CH_EOF)
                 tcc_error("unexpected end of file in comment");
-            } else if (c == '\\') {
-                p++;
-            }
+            if (c != '\\')
+                goto redo;
         }
     }
- end_of_comment:
-    p++;
-    return p;
-}
-
-ST_FUNC int set_idnum(int c, int val)
-{
-    int prev = isidnum_table[c - CH_EOF];
-    isidnum_table[c - CH_EOF] = val;
-    return prev;
-}
-
-#define cinp minp
-
-static inline void skip_spaces(void)
-{
-    while (isidnum_table[ch - CH_EOF] & IS_SPC)
-        cinp();
-}
-
-static inline int check_space(int t, int *spc) 
-{
-    if (t < 256 && (isidnum_table[t - CH_EOF] & IS_SPC)) {
-        if (*spc) 
-            return 1;
-        *spc = 1;
-    } else 
-        *spc = 0;
-    return 0;
+    return p + 1;
 }
 
 /* parse a string without interpreting escapes */
-static uint8_t *parse_pp_string(uint8_t *p,
-                                int sep, CString *str)
+static uint8_t *parse_pp_string(uint8_t *p, int sep, CString *str)
 {
     int c;
-    p++;
     for(;;) {
-        c = *p;
+        c = *++p;
+    redo:
         if (c == sep) {
             break;
         } else if (c == '\\') {
-            file->buf_ptr = p;
-            c = handle_eob();
-            p = file->buf_ptr;
+            c = handle_bs(&p);
             if (c == CH_EOF) {
-            unterminated_string:
+        unterminated_string:
                 /* XXX: indicate line number of start of string */
+                tok_flags &= ~TOK_FLAG_BOL;
                 tcc_error("missing terminating %c character", sep);
             } else if (c == '\\') {
-                /* escape : just skip \[\r]\n */
-                PEEKC_EOB(c, p);
-                if (c == '\n') {
-                    file->line_num++;
-                    p++;
-                } else if (c == '\r') {
-                    PEEKC_EOB(c, p);
-                    if (c != '\n')
-                        expect("'\n' after '\r'");
-                    file->line_num++;
-                    p++;
-                } else if (c == CH_EOF) {
-                    goto unterminated_string;
-                } else {
-                    if (str) {
-                        cstr_ccat(str, '\\');
-                        cstr_ccat(str, c);
-                    }
-                    p++;
+                if (str)
+                    cstr_ccat(str, c);
+                c = *++p;
+                /* add char after '\\' unconditionally */
+                if (c == '\\') {
+                    c = handle_bs(&p);
+                    if (c == CH_EOF)
+                        goto unterminated_string;
                 }
+                goto add_char;
+            } else {
+                goto redo;
             }
         } else if (c == '\n') {
-            file->line_num++;
-            goto add_char;
-        } else if (c == '\r') {
-            PEEKC_EOB(c, p);
-            if (c != '\n') {
-                if (str)
-                    cstr_ccat(str, '\r');
-            } else {
+        add_lf:
+            if (ACCEPT_LF_IN_STRINGS) {
                 file->line_num++;
                 goto add_char;
+            } else if (str) { /* not skipping */
+                goto unterminated_string;
+            } else {
+                //tcc_warning("missing terminating %c character", sep);
+                return p;
             }
+        } else if (c == '\r') {
+            c = *++p;
+            if (c == '\\')
+                c = handle_bs(&p);
+            if (c == '\n')
+                goto add_lf;
+            if (c == CH_EOF)
+                goto unterminated_string;
+            if (str)
+                cstr_ccat(str, '\r');
+            goto redo;
         } else {
         add_char:
             if (str)
                 cstr_ccat(str, c);
-            p++;
         }
     }
     p++;
@@ -993,34 +911,29 @@ static void preprocess_skip(void)
             p++;
             goto redo_start;
         case '\\':
-            file->buf_ptr = p;
-            c = handle_eob();
-            if (c == CH_EOF) {
+            c = handle_bs(&p);
+            if (c == CH_EOF)
                 expect("#endif");
-            } else if (c == '\\') {
-                ch = file->buf_ptr[0];
-                handle_stray_noerror();
-            }
-            p = file->buf_ptr;
+            if (c == '\\')
+                ++p;
             goto redo_no_start;
         /* skip strings */
         case '\"':
         case '\'':
             if (in_warn_or_error)
                 goto _default;
+            tok_flags &= ~TOK_FLAG_BOL;
             p = parse_pp_string(p, c, NULL);
             break;
         /* skip comments */
         case '/':
             if (in_warn_or_error)
                 goto _default;
-            file->buf_ptr = p;
-            ch = *p;
-            minp();
-            p = file->buf_ptr;
-            if (ch == '*') {
+            ++p;
+            c = handle_bs(&p);
+            if (c == '*') {
                 p = parse_comment(p);
-            } else if (ch == '/') {
+            } else if (c == '/') {
                 p = parse_line_comment(p);
             }
             break;
@@ -1089,7 +1002,11 @@ static inline int tok_size(const int *p)
     case TOK_CULLONG:
         return 1 + 2;
     case TOK_CLDOUBLE:
+#ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
+        return 1 + 8 / 4;
+#else
         return 1 + LDOUBLE_SIZE / 4;
+#endif
     default:
         return 1 + 0;
     }
@@ -1177,6 +1094,7 @@ ST_FUNC void end_macro(void)
     macro_stack = str->prev;
     macro_ptr = str->prev_ptr;
     file->line_num = str->save_line_num;
+    str->len = 0; /* matters if str not alloced, may be tokstr_buf */
     if (str->alloc != 0) {
         if (str->alloc == 2)
             str->str = NULL; /* don't free */
@@ -1229,25 +1147,24 @@ static void tok_str_add2(TokenString *s, int t, CValue *cv)
 #if LONG_SIZE == 8
     case TOK_CLONG:
     case TOK_CULONG:
-#endif
-#if LDOUBLE_SIZE == 8
-    case TOK_CLDOUBLE:
 #endif
         str[len++] = cv->tab[0];
         str[len++] = cv->tab[1];
         break;
-#if LDOUBLE_SIZE == 12
     case TOK_CLDOUBLE:
+#if LDOUBLE_SIZE == 8 || defined TCC_USING_DOUBLE_FOR_LDOUBLE
+        str[len++] = cv->tab[0];
+        str[len++] = cv->tab[1];
+#elif LDOUBLE_SIZE == 12
         str[len++] = cv->tab[0];
         str[len++] = cv->tab[1];
         str[len++] = cv->tab[2];
 #elif LDOUBLE_SIZE == 16
-    case TOK_CLDOUBLE:
         str[len++] = cv->tab[0];
         str[len++] = cv->tab[1];
         str[len++] = cv->tab[2];
         str[len++] = cv->tab[3];
-#elif LDOUBLE_SIZE != 8
+#else
 #error add long double size support
 #endif
         break;
@@ -1315,12 +1232,12 @@ static inline void tok_get(int *t, const int **pp, CValue *cv)
         n = 2;
         goto copy;
     case TOK_CLDOUBLE:
-#if LDOUBLE_SIZE == 16
-        n = 4;
+#if LDOUBLE_SIZE == 8 || defined TCC_USING_DOUBLE_FOR_LDOUBLE
+        n = 2;
 #elif LDOUBLE_SIZE == 12
         n = 3;
-#elif LDOUBLE_SIZE == 8
-        n = 2;
+#elif LDOUBLE_SIZE == 16
+        n = 4;
 #else
 # error add long double size support
 #endif
@@ -1356,12 +1273,11 @@ static int macro_is_equal(const int *a, const int *b)
         return 1;
 
     while (*a && *b) {
-        /* first time preallocate macro_equal_buf, next time only reset position to start */
-        cstr_reset(&macro_equal_buf);
+        cstr_reset(&tokcstr);
         TOK_GET(&t, &a, &cv);
-        cstr_cat(&macro_equal_buf, get_tok_str(t, &cv), 0);
+        cstr_cat(&tokcstr, get_tok_str(t, &cv), 0);
         TOK_GET(&t, &b, &cv);
-        if (strcmp(macro_equal_buf.data, get_tok_str(t, &cv)))
+        if (strcmp(tokcstr.data, get_tok_str(t, &cv)))
             return 0;
     }
     return !(*a || *b);
@@ -1410,63 +1326,6 @@ ST_FUNC void free_defines(Sym *b)
     }
 }
 
-/* label lookup */
-ST_FUNC Sym *label_find(int v)
-{
-    v -= TOK_IDENT;
-    if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
-        return NULL;
-    return table_ident[v]->sym_label;
-}
-
-ST_FUNC Sym *label_push(Sym **ptop, int v, int flags)
-{
-    Sym *s, **ps;
-    s = sym_push2(ptop, v, 0, 0);
-    s->r = flags;
-    ps = &table_ident[v - TOK_IDENT]->sym_label;
-    if (ptop == &global_label_stack) {
-        /* modify the top most local identifier, so that
-           sym_identifier will point to 's' when popped */
-        while (*ps != NULL)
-            ps = &(*ps)->prev_tok;
-    }
-    s->prev_tok = *ps;
-    *ps = s;
-    return s;
-}
-
-/* pop labels until element last is reached. Look if any labels are
-   undefined. Define symbols if '&&label' was used. */
-ST_FUNC void label_pop(Sym **ptop, Sym *slast, int keep)
-{
-    Sym *s, *s1;
-    for(s = *ptop; s != slast; s = s1) {
-        s1 = s->prev;
-        if (s->r == LABEL_DECLARED) {
-            tcc_warning_c(warn_all)("label '%s' declared but not used", get_tok_str(s->v, NULL));
-        } else if (s->r == LABEL_FORWARD) {
-                tcc_error("label '%s' used but not defined",
-                      get_tok_str(s->v, NULL));
-        } else {
-            if (s->c) {
-                /* define corresponding symbol. A size of
-                   1 is put. */
-                put_extern_sym(s, cur_text_section, s->jnext, 1);
-            }
-        }
-        /* remove label */
-        if (s->r != LABEL_GONE)
-            table_ident[s->v - TOK_IDENT]->sym_label = s->prev_tok;
-        if (!keep)
-            sym_free(s);
-        else
-            s->r = LABEL_GONE;
-    }
-    if (!keep)
-        *ptop = slast;
-}
-
 /* fake the nth "#if defined test_..." for tcc -dt -run */
 static void maybe_run_test(TCCState *s)
 {
@@ -1482,8 +1341,116 @@ static void maybe_run_test(TCCState *s)
     define_push(tok, MACRO_OBJ, NULL, NULL);
 }
 
+static CachedInclude *
+search_cached_include(TCCState *s1, const char *filename, int add);
+
+static int parse_include(TCCState *s1, int do_next, int test)
+{
+    int c, i;
+    char name[1024], buf[1024], *p;
+    CachedInclude *e;
+
+    c = skip_spaces();
+    if (c == '<' || c == '\"') {
+        cstr_reset(&tokcstr);
+        file->buf_ptr = parse_pp_string(file->buf_ptr, c == '<' ? '>' : c, &tokcstr);
+        i = tokcstr.size;
+        pstrncpy(name, tokcstr.data, i >= sizeof name ? sizeof name - 1 : i);
+        next_nomacro();
+    } else {
+        /* computed #include : concatenate tokens until result is one of
+           the two accepted forms.  Don't convert pp-tokens to tokens here. */
+	parse_flags = PARSE_FLAG_PREPROCESS
+                    | PARSE_FLAG_LINEFEED
+                    | (parse_flags & PARSE_FLAG_ASM_FILE);
+        name[0] = 0;
+        for (;;) {
+            next();
+            p = name, i = strlen(p) - 1;
+            if (i > 0
+                && ((p[0] == '"' && p[i] == '"')
+                 || (p[0] == '<' && p[i] == '>')))
+                break;
+            if (tok == TOK_LINEFEED)
+                tcc_error("'#include' expects \"FILENAME\" or <FILENAME>");
+            pstrcat(name, sizeof name, get_tok_str(tok, &tokc));
+	}
+        c = p[0];
+        /* remove '<>|""' */
+        memmove(p, p + 1, i - 1), p[i - 1] = 0;
+    }
+
+    i = do_next ? file->include_next_index : -1;
+    for (;;) {
+        ++i;
+        if (i == 0) {
+            /* check absolute include path */
+            if (!IS_ABSPATH(name))
+                continue;
+            buf[0] = '\0';
+        } else if (i == 1) {
+            /* search in file's dir if "header.h" */
+            if (c != '\"')
+                continue;
+            p = file->true_filename;
+            pstrncpy(buf, p, tcc_basename(p) - p);
+        } else {
+            int j = i - 2, k = j - s1->nb_include_paths;
+            if (k < 0)
+                p = s1->include_paths[j];
+            else if (k < s1->nb_sysinclude_paths)
+                p = s1->sysinclude_paths[k];
+            else if (test)
+                return 0;
+            else
+                tcc_error("include file '%s' not found", name);
+            pstrcpy(buf, sizeof buf, p);
+            pstrcat(buf, sizeof buf, "/");
+        }
+        pstrcat(buf, sizeof buf, name);
+        e = search_cached_include(s1, buf, 0);
+        if (e && (define_find(e->ifndef_macro) || e->once)) {
+            /* no need to parse the include because the 'ifndef macro'
+               is defined (or had #pragma once) */
+#ifdef INC_DEBUG
+            printf("%s: skipping cached %s\n", file->filename, buf);
+#endif
+            return 1;
+        }
+        if (tcc_open(s1, buf) >= 0)
+            break;
+    }
+
+    if (test) {
+        tcc_close();
+    } else {
+        if (s1->include_stack_ptr >= s1->include_stack + INCLUDE_STACK_SIZE)
+            tcc_error("#include recursion too deep");
+        /* push previous file on stack */
+        *s1->include_stack_ptr++ = file->prev;
+        file->include_next_index = i;
+#ifdef INC_DEBUG
+        printf("%s: including %s\n", file->prev->filename, file->filename);
+#endif
+        /* update target deps */
+        if (s1->gen_deps) {
+            BufferedFile *bf = file;
+            while (i == 1 && (bf = bf->prev))
+                i = bf->include_next_index;
+            /* skip system include files */
+            if (s1->include_sys_deps || i - 2 < s1->nb_include_paths)
+                dynarray_add(&s1->target_deps, &s1->nb_target_deps,
+                    tcc_strdup(buf));
+        }
+        /* add include file debug info */
+        tcc_debug_bincl(s1);
+        tok_flags |= TOK_FLAG_BOF | TOK_FLAG_BOL;
+    }
+    return 1;
+}
+
 /* eval an expression for #if/#elif */
-static int expr_preprocess(void)
+static int expr_preprocess(TCCState *s1)
 {
     int c, t;
     TokenString *str;
@@ -1493,16 +1460,23 @@ static int expr_preprocess(void)
     while (tok != TOK_LINEFEED && tok != TOK_EOF) {
         next(); /* do macro subst */
       redo:
-        if (tok == TOK_DEFINED) {
+        if (tok < TOK_IDENT) {
+            if (tok >= TOK_STR && tok <= TOK_CLDOUBLE)
+                tcc_error("invalid constant in preprocessor expression");
+        } else if (tok == TOK_DEFINED) {
             next_nomacro();
             t = tok;
             if (t == '(') 
                 next_nomacro();
             if (tok < TOK_IDENT)
                 expect("identifier");
-            if (tcc_state->run_test)
-                maybe_run_test(tcc_state);
-            c = define_find(tok) != 0;
+            if (s1->run_test)
+                maybe_run_test(s1);
+            c = 0;
+            if (define_find(tok)
+                || tok == TOK___HAS_INCLUDE
+                || tok == TOK___HAS_INCLUDE_NEXT)
+                c = 1;
             if (t == '(') {
                 next_nomacro();
                 if (tok != ')')
@@ -1510,16 +1484,18 @@ static int expr_preprocess(void)
             }
             tok = TOK_CINT;
             tokc.i = c;
-        } else if (1 && tok == TOK___HAS_INCLUDE) {
-            next();  /* XXX check if correct to use expansion */
-            skip('(');
-            while (tok != ')' && tok != TOK_EOF)
-              next();
+        } else if (tok == TOK___HAS_INCLUDE ||
+                   tok == TOK___HAS_INCLUDE_NEXT) {
+            t = tok;
+            next_nomacro();
+	    if (tok != '(')
+		expect("(");
+            c = parse_include(s1, t - TOK___HAS_INCLUDE, 1);
             if (tok != ')')
-              expect("')'");
+                expect("')'");
             tok = TOK_CINT;
-            tokc.i = 0;
-        } else if (tok >= TOK_IDENT) {
+            tokc.i = c;
+        } else {
             /* if undefined macro, replace with zero, check for func-like */
             t = tok;
             tok = TOK_CINT;
@@ -1638,18 +1614,18 @@ ST_FUNC void parse_define(void)
 
 static CachedInclude *search_cached_include(TCCState *s1, const char *filename, int add)
 {
-    const unsigned char *s;
+    const char *s, *basename;
     unsigned int h;
     CachedInclude *e;
-    int i;
+    int c, i, len;
 
+    s = basename = tcc_basename(filename);
     h = TOK_HASH_INIT;
-    s = (unsigned char *) filename;
-    while (*s) {
+    while ((c = (unsigned char)*s) != 0) {
 #ifdef _WIN32
-        h = TOK_HASH_FUNC(h, toup(*s));
+        h = TOK_HASH_FUNC(h, toup(c));
 #else
-        h = TOK_HASH_FUNC(h, *s);
+        h = TOK_HASH_FUNC(h, c);
 #endif
         s++;
     }
@@ -1660,15 +1636,20 @@ static CachedInclude *search_cached_include(TCCState *s1, const char *filename,
         if (i == 0)
             break;
         e = s1->cached_includes[i - 1];
-        if (0 == PATHCMP(e->filename, filename))
+        if (0 == PATHCMP(filename, e->filename))
+            return e;
+        if (e->once
+            && 0 == PATHCMP(basename, tcc_basename(e->filename))
+            && 0 == normalized_PATHCMP(filename, e->filename)
+            )
             return e;
         i = e->hash_next;
     }
     if (!add)
         return NULL;
 
-    e = tcc_malloc(sizeof(CachedInclude) + strlen(filename));
-    strcpy(e->filename, filename);
+    e = tcc_malloc(sizeof(CachedInclude) + (len = strlen(filename)));
+    memcpy(e->filename, filename, len + 1);
     e->ifndef_macro = e->once = 0;
     dynarray_add(&s1->cached_includes, &s1->nb_cached_includes, e);
     /* add in hash table */
@@ -1712,7 +1693,7 @@ static void pragma_parse(TCCState *s1)
         pp_debug_tok = t, pp_debug_symv = v;
 
     } else if (tok == TOK_once) {
-        search_cached_include(s1, file->filename, 1)->once = pp_once;
+        search_cached_include(s1, file->filename, 1)->once = 1;
 
     } else if (s1->output_type == TCC_OUTPUT_PREPROCESS) {
         /* tcc -E: keep pragmas below unchanged */
@@ -1796,7 +1777,7 @@ static void pragma_parse(TCCState *s1)
 ST_FUNC void preprocess(int is_bof)
 {
     TCCState *s1 = tcc_state;
-    int i, c, n, saved_parse_flags;
+    int c, n, saved_parse_flags;
     char buf[1024], *q;
     Sym *s;
 
@@ -1828,132 +1809,13 @@ ST_FUNC void preprocess(int is_bof)
         break;
     case TOK_INCLUDE:
     case TOK_INCLUDE_NEXT:
-        ch = file->buf_ptr[0];
-        /* XXX: incorrect if comments : use next_nomacro with a special mode */
-        skip_spaces();
-        if (ch == '<') {
-            c = '>';
-            goto read_name;
-        } else if (ch == '\"') {
-            c = ch;
-        read_name:
-            inp();
-            q = buf;
-            while (ch != c && ch != '\n' && ch != CH_EOF) {
-                if ((q - buf) < sizeof(buf) - 1)
-                    *q++ = ch;
-                if (ch == '\\') {
-                    if (handle_stray_noerror() == 0)
-                        --q;
-                } else
-                    inp();
-            }
-            *q = '\0';
-            minp();
-#if 0
-            /* eat all spaces and comments after include */
-            /* XXX: slightly incorrect */
-            while (ch1 != '\n' && ch1 != CH_EOF)
-                inp();
-#endif
-        } else {
-	    int len;
-            /* computed #include : concatenate everything up to linefeed,
-	       the result must be one of the two accepted forms.
-	       Don't convert pp-tokens to tokens here.  */
-	    parse_flags = (PARSE_FLAG_PREPROCESS
-			   | PARSE_FLAG_LINEFEED
-			   | (parse_flags & PARSE_FLAG_ASM_FILE));
-            next();
-            buf[0] = '\0';
-	    while (tok != TOK_LINEFEED) {
-		pstrcat(buf, sizeof(buf), get_tok_str(tok, &tokc));
-		next();
-	    }
-	    len = strlen(buf);
-	    /* check syntax and remove '<>|""' */
-	    if ((len < 2 || ((buf[0] != '"' || buf[len-1] != '"') &&
-			     (buf[0] != '<' || buf[len-1] != '>'))))
-	        tcc_error("'#include' expects \"FILENAME\" or <FILENAME>");
-	    c = buf[len-1];
-	    memmove(buf, buf + 1, len - 2);
-	    buf[len - 2] = '\0';
-        }
-
-        if (s1->include_stack_ptr >= s1->include_stack + INCLUDE_STACK_SIZE)
-            tcc_error("#include recursion too deep");
-        i = tok == TOK_INCLUDE_NEXT ? file->include_next_index + 1 : 0;
-        n = 2 + s1->nb_include_paths + s1->nb_sysinclude_paths;
-        for (; i < n; ++i) {
-            char buf1[sizeof file->filename];
-            CachedInclude *e;
-            const char *path;
-
-            if (i == 0) {
-                /* check absolute include path */
-                if (!IS_ABSPATH(buf))
-                    continue;
-                buf1[0] = 0;
-
-            } else if (i == 1) {
-                /* search in file's dir if "header.h" */
-                if (c != '\"')
-                    continue;
-                /* https://savannah.nongnu.org/bugs/index.php?50847 */
-                path = file->true_filename;
-                pstrncpy(buf1, path, tcc_basename(path) - path);
-
-            } else {
-                /* search in all the include paths */
-                int j = i - 2, k = j - s1->nb_include_paths;
-                path = k < 0 ? s1->include_paths[j] : s1->sysinclude_paths[k];
-                pstrcpy(buf1, sizeof(buf1), path);
-                pstrcat(buf1, sizeof(buf1), "/");
-            }
-
-            pstrcat(buf1, sizeof(buf1), buf);
-            e = search_cached_include(s1, buf1, 0);
-            if (e && (define_find(e->ifndef_macro) || e->once == pp_once)) {
-                /* no need to parse the include because the 'ifndef macro'
-                   is defined (or had #pragma once) */
-#ifdef INC_DEBUG
-                printf("%s: skipping cached %s\n", file->filename, buf1);
-#endif
-                goto include_done;
-            }
-
-            if (tcc_open(s1, buf1) < 0)
-                continue;
-            /* push previous file on stack */
-            *s1->include_stack_ptr++ = file->prev;
-            file->include_next_index = i;
-#ifdef INC_DEBUG
-            printf("%s: including %s\n", file->prev->filename, file->filename);
-#endif
-            /* update target deps */
-            if (s1->gen_deps) {
-                BufferedFile *bf = file;
-                while (i == 1 && (bf = bf->prev))
-                    i = bf->include_next_index;
-                /* skip system include files */
-                if (s1->include_sys_deps || n - i > s1->nb_sysinclude_paths)
-                    dynarray_add(&s1->target_deps, &s1->nb_target_deps,
-                        tcc_strdup(buf1));
-            }
-            /* add include file debug info */
-            tcc_debug_bincl(tcc_state);
-            tok_flags |= TOK_FLAG_BOF | TOK_FLAG_BOL;
-            ch = file->buf_ptr[0];
-            goto the_end;
-        }
-        tcc_error("include file '%s' not found", buf);
-include_done:
+        parse_include(s1, tok - TOK_INCLUDE, 0);
         break;
     case TOK_IFNDEF:
         c = 1;
         goto do_ifdef;
     case TOK_IF:
-        c = expr_preprocess();
+        c = expr_preprocess(s1);
         goto do_if;
     case TOK_IFDEF:
         c = 0;
@@ -1969,7 +1831,10 @@ ST_FUNC void preprocess(int is_bof)
                 file->ifndef_macro = tok;
             }
         }
-        c = (define_find(tok) != 0) ^ c;
+        if (define_find(tok)
+            || tok == TOK___HAS_INCLUDE
+            || tok == TOK___HAS_INCLUDE_NEXT)
+            c ^= 1;
     do_if:
         if (s1->ifdef_stack_ptr >= s1->ifdef_stack + IFDEF_STACK_SIZE)
             tcc_error("memory full (ifdef)");
@@ -1992,7 +1857,7 @@ ST_FUNC void preprocess(int is_bof)
         if (c == 1) {
             c = 0;
         } else {
-            c = expr_preprocess();
+            c = expr_preprocess(s1);
             s1->ifdef_stack_ptr[-1] = c;
         }
     test_else:
@@ -2038,10 +1903,14 @@ ST_FUNC void preprocess(int is_bof)
             if (tok == TOK_STR) {
                 if (file->true_filename == file->filename)
                     file->true_filename = tcc_strdup(file->filename);
-                /* prepend directory from real file */
-                pstrcpy(buf, sizeof buf, file->true_filename);
-                *tcc_basename(buf) = 0;
-                pstrcat(buf, sizeof buf, (char *)tokc.str.data);
+                q = (char *)tokc.str.data;
+                buf[0] = 0;
+                if (!IS_ABSPATH(q)) {
+                    /* prepend directory from real file */
+                    pstrcpy(buf, sizeof buf, file->true_filename);
+                    *tcc_basename(buf) = 0;
+                }
+                pstrcat(buf, sizeof buf, q);
                 tcc_debug_putfile(s1, buf);
             } else if (parse_flags & PARSE_FLAG_ASM_FILE)
                 break;
@@ -2055,21 +1924,15 @@ ST_FUNC void preprocess(int is_bof)
         break;
     case TOK_ERROR:
     case TOK_WARNING:
-        c = tok;
-        ch = file->buf_ptr[0];
-        skip_spaces();
         q = buf;
-        while (ch != '\n' && ch != CH_EOF) {
+        c = skip_spaces();
+        while (c != '\n' && c != CH_EOF) {
             if ((q - buf) < sizeof(buf) - 1)
-                *q++ = ch;
-            if (ch == '\\') {
-                if (handle_stray_noerror() == 0)
-                    --q;
-            } else
-                inp();
+                *q++ = c;
+            c = ninp();
         }
         *q = '\0';
-        if (c == TOK_ERROR)
+        if (tok == TOK_ERROR)
             tcc_error("#error %s", buf);
         else
             tcc_warning("#warning %s", buf);
@@ -2147,13 +2010,16 @@ static void parse_escape_string(CString *outstr, const uint8_t *buf, int is_long
                         c = c - '0';
                     else if (i > 0)
                         expect("more hex digits in universal-character-name");
-                    else {
-                        c = n;
-                        goto add_char_nonext;
-                    }
+                    else
+                        goto add_hex_or_ucn;
                     n = n * 16 + c;
                     p++;
                 } while (--i);
+		if (is_long) {
+    add_hex_or_ucn:
+                    c = n;
+		    goto add_char_nonext;
+		}
                 cstr_u8cat(outstr, n);
                 continue;
             case 'a':
@@ -2477,11 +2343,10 @@ static void parse_number(const char *p)
                 tokc.f = (float)d;
             } else if (t == 'L') {
                 ch = *p++;
+                tok = TOK_CLDOUBLE;
 #ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
-                tok = TOK_CDOUBLE;
                 tokc.d = d;
 #else
-                tok = TOK_CLDOUBLE;
                 /* XXX: not large enough */
                 tokc.ld = (long double)d;
 #endif
@@ -2533,11 +2398,10 @@ static void parse_number(const char *p)
                 tokc.f = strtof(token_buf, NULL);
             } else if (t == 'L') {
                 ch = *p++;
+                tok = TOK_CLDOUBLE;
 #ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
-                tok = TOK_CDOUBLE;
                 tokc.d = strtod(token_buf, NULL);
 #else
-                tok = TOK_CLDOUBLE;
                 tokc.ld = strtold(token_buf, NULL);
 #endif
             } else {
@@ -2678,13 +2542,10 @@ static inline void next_nomacro1(void)
         goto redo_no_start;
     case '\\':
         /* first look if it is in fact an end of buffer */
-        c = handle_stray1(p);
-        p = file->buf_ptr;
+        c = handle_stray(&p);
         if (c == '\\')
             goto parse_simple;
-        if (c != CH_EOF)
-            goto redo_no_start;
-        {
+        if (c == CH_EOF) {
             TCCState *s1 = tcc_state;
             if ((parse_flags & PARSE_FLAG_LINEFEED)
                 && !(tok_flags & TOK_FLAG_EOF)) {
@@ -2720,9 +2581,12 @@ static inline void next_nomacro1(void)
                 s1->include_stack_ptr--;
                 p = file->buf_ptr;
                 if (p == file->buffer)
-                    tok_flags = TOK_FLAG_BOF|TOK_FLAG_BOL;
+                    tok_flags = TOK_FLAG_BOF;
+                tok_flags |= TOK_FLAG_BOL;
                 goto redo_no_start;
             }
+        } else {
+            goto redo_no_start;
         }
         break;
 
@@ -3076,7 +2940,6 @@ static int *macro_arg_subst(Sym **nested_list, const int *macro_str, Sym *args)
     Sym *s;
     CValue cval;
     TokenString str;
-    CString cstr;
 
     tok_str_new(&str);
     t0 = t1 = 0;
@@ -3091,8 +2954,8 @@ static int *macro_arg_subst(Sym **nested_list, const int *macro_str, Sym *args)
                 goto bad_stringy;
             s = sym_find2(args, t);
             if (s) {
-                cstr_new(&cstr);
-                cstr_ccat(&cstr, '\"');
+                cstr_reset(&tokcstr);
+                cstr_ccat(&tokcstr, '\"');
                 st = s->d;
                 spc = 0;
                 while (*st >= 0) {
@@ -3103,24 +2966,23 @@ static int *macro_arg_subst(Sym **nested_list, const int *macro_str, Sym *args)
                         const char *s = get_tok_str(t, &cval);
                         while (*s) {
                             if (t == TOK_PPSTR && *s != '\'')
-                                add_char(&cstr, *s);
+                                add_char(&tokcstr, *s);
                             else
-                                cstr_ccat(&cstr, *s);
+                                cstr_ccat(&tokcstr, *s);
                             ++s;
                         }
                     }
                 }
-                cstr.size -= spc;
-                cstr_ccat(&cstr, '\"');
-                cstr_ccat(&cstr, '\0');
+                tokcstr.size -= spc;
+                cstr_ccat(&tokcstr, '\"');
+                cstr_ccat(&tokcstr, '\0');
 #ifdef PP_DEBUG
-                printf("\nstringize: <%s>\n", (char *)cstr.data);
+                printf("\nstringize: <%s>\n", (char *)tokcstr.data);
 #endif
                 /* add string */
-                cval.str.size = cstr.size;
-                cval.str.data = cstr.data;
+                cval.str.size = tokcstr.size;
+                cval.str.data = tokcstr.data;
                 tok_str_add2(&str, TOK_PPSTR, &cval);
-                cstr_free(&cstr);
             } else {
         bad_stringy:
                 expect("macro parameter after '#'");
@@ -3128,7 +2990,6 @@ static int *macro_arg_subst(Sym **nested_list, const int *macro_str, Sym *args)
         } else if (t >= TOK_IDENT) {
             s = sym_find2(args, t);
             if (s) {
-                int l0 = str.len;
                 st = s->d;
                 /* if '##' is present before or after, no arg substitution */
                 if (*macro_str == TOK_PPJOIN || t1 == TOK_PPJOIN) {
@@ -3160,15 +3021,17 @@ static int *macro_arg_subst(Sym **nested_list, const int *macro_str, Sym *args)
 		    }
 		    st = s->next->d;
                 }
-                for(;;) {
+                if (*st <= 0) {
+                    /* expanded to empty string */
+		    if (str.len)
+                        tok_str_add(&str, TOK_PLCHLDR);
+                } else for (;;) {
                     int t2;
                     TOK_GET(&t2, &st, &cval);
                     if (t2 <= 0)
                         break;
                     tok_str_add2(&str, t2, &cval);
                 }
-                if (str.len == l0) /* expanded to empty string */
-                    tok_str_add(&str, TOK_PLCHLDR);
             } else {
                 tok_str_add(&str, t);
             }
@@ -3189,19 +3052,19 @@ static char const ab_month_name[12][4] =
 
 static int paste_tokens(int t1, CValue *v1, int t2, CValue *v2)
 {
-    CString cstr;
     int n, ret = 1;
 
-    cstr_new(&cstr);
+    cstr_reset(&tokcstr);
     if (t1 != TOK_PLCHLDR)
-        cstr_cat(&cstr, get_tok_str(t1, v1), -1);
-    n = cstr.size;
+        cstr_cat(&tokcstr, get_tok_str(t1, v1), -1);
+    n = tokcstr.size;
     if (t2 != TOK_PLCHLDR)
-        cstr_cat(&cstr, get_tok_str(t2, v2), -1);
-    cstr_ccat(&cstr, '\0');
+        cstr_cat(&tokcstr, get_tok_str(t2, v2), -1);
+    cstr_ccat(&tokcstr, '\0');
+    //printf("paste <%s>\n", (char*)tokcstr.data);
 
-    tcc_open_bf(tcc_state, ":paste:", cstr.size);
-    memcpy(file->buffer, cstr.data, cstr.size);
+    tcc_open_bf(tcc_state, ":paste:", tokcstr.size);
+    memcpy(file->buffer, tokcstr.data, tokcstr.size);
     tok_flags = 0;
     for (;;) {
         next_nomacro1();
@@ -3210,13 +3073,11 @@ static int paste_tokens(int t1, CValue *v1, int t2, CValue *v2)
         if (is_space(tok))
             continue;
         tcc_warning("pasting \"%.*s\" and \"%s\" does not give a valid"
-            " preprocessing token", n, (char *)cstr.data, (char*)cstr.data + n);
+            " preprocessing token", n, file->buffer, file->buffer + n);
         ret = 0;
         break;
     }
     tcc_close();
-    //printf("paste <%s>\n", (char*)cstr.data);
-    cstr_free(&cstr);
     return ret;
 }
 
@@ -3307,30 +3168,31 @@ static int next_argstream(Sym **nested_list, TokenString *ws_str)
                 continue;
             }
         } else {
-            ch = handle_eob();
+            uint8_t *p = file->buf_ptr;
+            int ch = handle_bs(&p);
             if (ws_str) {
                 while (is_space(ch) || ch == '\n' || ch == '/') {
                     if (ch == '/') {
                         int c;
-                        uint8_t *p = file->buf_ptr;
                         PEEKC(c, p);
                         if (c == '*') {
-                            p = parse_comment(p);
-                            file->buf_ptr = p - 1;
+                            p = parse_comment(p) - 1;
                         } else if (c == '/') {
-                            p = parse_line_comment(p);
-                            file->buf_ptr = p - 1;
-                        } else
+                            p = parse_line_comment(p) - 1;
+                        } else {
+                            *--p = ch;
                             break;
+                        }
                         ch = ' ';
                     }
                     if (ch == '\n')
                         file->line_num++;
                     if (!(ch == '\f' || ch == '\v' || ch == '\r'))
                         tok_str_add(ws_str, ch);
-                    cinp();
+                    PEEKC(ch, p);
                 }
             }
+            file->buf_ptr = p;
             t = ch;
         }
 
@@ -3355,7 +3217,6 @@ static int macro_subst_tok(
     TokenString str;
     char *cstrval;
     CValue cval;
-    CString cstr;
     char buf[32];
 
     /* if symbol is a macro, prepare substitution */
@@ -3386,12 +3247,11 @@ static int macro_subst_tok(
     add_cstr:
         t1 = TOK_STR;
     add_cstr1:
-        cstr_new(&cstr);
-        cstr_cat(&cstr, cstrval, 0);
-        cval.str.size = cstr.size;
-        cval.str.data = cstr.data;
+        cstr_reset(&tokcstr);
+        cstr_cat(&tokcstr, cstrval, 0);
+        cval.str.size = tokcstr.size;
+        cval.str.data = tokcstr.data;
         tok_str_add2(tok_str, t1, &cval);
-        cstr_free(&cstr);
     } else if (s->d) {
         int saved_parse_flags = parse_flags;
 	int *joined_str = NULL;
@@ -3420,6 +3280,8 @@ static int macro_subst_tok(
                     for (i = 0; i < ws_str.len; i++)
                         tok_str_add(tok_str, ws_str.str[i]);
                 }
+		if (ws_str.len && ws_str.str[ws_str.len - 1] == '\n')
+		    tok_flags |= TOK_FLAG_BOL;
                 tok_str_free_str(ws_str.str);
                 return 0;
             } else {
@@ -3697,6 +3559,9 @@ static const char * const target_os_defs =
 # else
     "__linux__\0"
     "__linux\0"
+#  if TARGETOS_ANDROID
+    "__ANDROID__\0"
+#  endif
 # endif
     "__unix__\0"
     "__unix\0"
@@ -3708,17 +3573,22 @@ static void putdef(CString *cs, const char *p)
     cstr_printf(cs, "#define %s%s\n", p, &" 1"[!!strchr(p, ' ')*2]);
 }
 
+static void putdefs(CString *cs, const char *p)
+{
+    while (*p)
+        putdef(cs, p), p = strchr(p, 0) + 1;
+}
+
 static void tcc_predefs(TCCState *s1, CString *cs, int is_asm)
 {
     int a, b, c;
-    const char *defs[] = { target_machine_defs, target_os_defs, NULL };
-    const char *p;
 
     sscanf(TCC_VERSION, "%d.%d.%d", &a, &b, &c);
     cstr_printf(cs, "#define __TINYC__ %d\n", a*10000 + b*100 + c);
-    for (a = 0; defs[a]; ++a)
-        for (p = defs[a]; *p; p = strchr(p, 0) + 1)
-            putdef(cs, p);
+
+    putdefs(cs, target_machine_defs);
+    putdefs(cs, target_os_defs);
+
 #ifdef TCC_TARGET_ARM
     if (s1->float_abi == ARM_HARD_FLOAT)
       putdef(cs, "__ARM_PCS_VFP");
@@ -3729,20 +3599,22 @@ static void tcc_predefs(TCCState *s1, CString *cs, int is_asm)
       putdef(cs, "__TCC_PP__");
     if (s1->output_type == TCC_OUTPUT_MEMORY)
       putdef(cs, "__TCC_RUN__");
+#ifdef CONFIG_TCC_BACKTRACE
+    if (s1->do_backtrace)
+      putdef(cs, "__TCC_BACKTRACE__");
+#endif
+#ifdef CONFIG_TCC_BCHECK
+    if (s1->do_bounds_check)
+      putdef(cs, "__TCC_BCHECK__");
+#endif
     if (s1->char_is_unsigned)
       putdef(cs, "__CHAR_UNSIGNED__");
     if (s1->optimize > 0)
       putdef(cs, "__OPTIMIZE__");
-    if (s1->optimize == 's')
-          putdef(cs, "__OPTIMIZE_SIZE__");
     if (s1->option_pthread)
       putdef(cs, "_REENTRANT");
     if (s1->leading_underscore)
       putdef(cs, "__leading_underscore");
-#ifdef CONFIG_TCC_BCHECK
-    if (s1->do_bounds_check)
-      putdef(cs, "__BOUNDS_CHECKING_ON");
-#endif
     cstr_printf(cs, "#define __SIZEOF_POINTER__ %d\n", PTR_SIZE);
     cstr_printf(cs, "#define __SIZEOF_LONG__ %d\n", LONG_SIZE);
     if (!is_asm) {
@@ -3763,7 +3635,6 @@ static void tcc_predefs(TCCState *s1, CString *cs, int is_asm)
 ST_FUNC void preprocess_start(TCCState *s1, int filetype)
 {
     int is_asm = !!(filetype & (AFF_TYPE_ASM|AFF_TYPE_ASMPP));
-    CString cstr;
 
     tccpp_new(s1);
 
@@ -3773,7 +3644,6 @@ ST_FUNC void preprocess_start(TCCState *s1, int filetype)
     pp_expr = 0;
     pp_counter = 0;
     pp_debug_tok = pp_debug_symv = 0;
-    pp_once++;
     s1->pack_stack[0] = 0;
     s1->pack_stack_ptr = s1->pack_stack;
 
@@ -3781,6 +3651,7 @@ ST_FUNC void preprocess_start(TCCState *s1, int filetype)
     set_idnum('.', is_asm ? IS_ID : 0);
 
     if (!(filetype & AFF_TYPE_ASM)) {
+        CString cstr;
         cstr_new(&cstr);
         tcc_predefs(s1, &cstr, is_asm);
         if (s1->cmdline_defs.size)
@@ -3809,6 +3680,13 @@ ST_FUNC void preprocess_end(TCCState *s1)
     tccpp_delete(s1);
 }
 
+ST_FUNC int set_idnum(int c, int val)
+{
+    int prev = isidnum_table[c - CH_EOF];
+    isidnum_table[c - CH_EOF] = val;
+    return prev;
+}
+
 ST_FUNC void tccpp_new(TCCState *s)
 {
     int i, c;
@@ -3832,6 +3710,7 @@ ST_FUNC void tccpp_new(TCCState *s)
     memset(hash_ident, 0, TOK_HASH_SIZE * sizeof(TokenSym *));
     memset(s->cached_includes_hash, 0, sizeof s->cached_includes_hash);
 
+    cstr_new(&tokcstr);
     cstr_new(&cstr_buf);
     cstr_realloc(&cstr_buf, STRING_MAX_SIZE);
     tok_str_new(&tokstr_buf);
@@ -3877,7 +3756,6 @@ ST_FUNC void tccpp_delete(TCCState *s)
     /* free static buffers */
     cstr_free(&tokcstr);
     cstr_free(&cstr_buf);
-    cstr_free(&macro_equal_buf);
     tok_str_free_str(tokstr_buf.str);
 
     /* free allocators */
diff --git a/tccrun.c b/tccrun.c
index 9c9f4e079..b102d8290 100644
--- a/tccrun.c
+++ b/tccrun.c
@@ -23,12 +23,20 @@
 /* only native compiler supports -run */
 #ifdef TCC_IS_NATIVE
 
-#ifdef CONFIG_TCC_BACKTRACE
 typedef struct rt_context
 {
+#ifdef CONFIG_TCC_BACKTRACE
     /* --> tccelf.c:tcc_add_btstub wants those below in that order: */
-    Stab_Sym *stab_sym, *stab_sym_end;
-    char *stab_str;
+    union {
+	struct {
+    	    Stab_Sym *stab_sym, *stab_sym_end;
+    	    char *stab_str;
+	};
+	struct {
+    	    unsigned char *dwarf_line, *dwarf_line_end, *dwarf_line_str;
+	};
+    };
+    addr_t dwarf;
     ElfW(Sym) *esym_start, *esym_end;
     char *elf_str;
     addr_t prog_base;
@@ -38,14 +46,27 @@ typedef struct rt_context
     int num_callers;
     addr_t ip, fp, sp;
     void *top_func;
-    jmp_buf jmp_buf;
-    char do_jmp;
+#endif
+    jmp_buf jb;
+    int do_jmp;
+# define NR_AT_EXIT 32
+    int nr_exit;
+    void *exitfunc[NR_AT_EXIT];
+    void *exitarg[NR_AT_EXIT];
 } rt_context;
 
 static rt_context g_rtctxt;
+static void rt_exit(int code)
+{
+    rt_context *rc = &g_rtctxt;
+    if (rc->do_jmp)
+        longjmp(rc->jb, code ? code : 256);
+    exit(code);
+}
+
+#ifdef CONFIG_TCC_BACKTRACE
 static void set_exception_handler(void);
 static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap);
-static void rt_exit(int code);
 #endif /* CONFIG_TCC_BACKTRACE */
 
 /* defined when included from lib/bt-exe.c */
@@ -55,7 +76,7 @@ static void rt_exit(int code);
 # include <sys/mman.h>
 #endif
 
-static void set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned long length);
+static int set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned long length);
 static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff);
 
 #ifdef _WIN64
@@ -92,16 +113,17 @@ LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr)
     ptr = mmap(NULL, size * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
     /* mmap RX memory at a fixed distance */
     prx = mmap((char*)ptr + size, size, PROT_READ|PROT_EXEC, MAP_SHARED|MAP_FIXED, fd, 0);
+    close(fd);
     if (ptr == MAP_FAILED || prx == MAP_FAILED)
-	tcc_error("tccrun: could not map memory");
+	return tcc_error_noabort("tccrun: could not map memory");
     ptr_diff = (char*)prx - (char*)ptr;
-    close(fd);
     //printf("map %p %p %p\n", ptr, prx, (void*)ptr_diff);
 }
 #else
     ptr = tcc_malloc(size);
 #endif
-    tcc_relocate_ex(s1, ptr, ptr_diff); /* no more errors expected */
+    if (tcc_relocate_ex(s1, ptr, ptr_diff))
+        return -1;
     dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, (void*)(addr_t)size);
     dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, ptr);
     return 0;
@@ -137,13 +159,35 @@ static void run_cdtors(TCCState *s1, const char *start, const char *end,
         ((void(*)(int, char **, char **))*a++)(argc, argv, envp);
 }
 
+static void run_on_exit(int ret)
+{
+    rt_context *rc = &g_rtctxt;
+    int n = rc->nr_exit;
+    while (n)
+	--n, ((void(*)(int,void*))rc->exitfunc[n])(ret, rc->exitarg[n]);
+}
+
+static int rt_on_exit(void *function, void *arg)
+{
+    rt_context *rc = &g_rtctxt;
+    if (rc->nr_exit < NR_AT_EXIT) {
+	rc->exitfunc[rc->nr_exit] = function;
+	rc->exitarg[rc->nr_exit++] = arg;
+        return 0;
+    }
+    return 1;
+}
+
+static int rt_atexit(void *function)
+{
+    return rt_on_exit(function, NULL);
+}
+
 /* launch the compiled program with the given arguments */
 LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
 {
     int (*prog_main)(int, char **, char **), ret;
-#ifdef CONFIG_TCC_BACKTRACE
     rt_context *rc = &g_rtctxt;
-#endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__)
     char **envp = NULL;
@@ -157,30 +201,49 @@ LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
     s1->runtime_main = s1->nostdlib ? "_start" : "main";
     if ((s1->dflag & 16) && (addr_t)-1 == get_sym_addr(s1, s1->runtime_main, 0, 1))
         return 0;
-#ifdef CONFIG_TCC_BACKTRACE
-    if (s1->do_debug)
-        tcc_add_symbol(s1, "exit", rt_exit);
-#endif
+
+    tcc_add_symbol(s1, "exit", rt_exit);
+    tcc_add_symbol(s1, "atexit", rt_atexit);
+    tcc_add_symbol(s1, "on_exit", rt_on_exit);
     if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
         return -1;
+
     prog_main = (void*)get_sym_addr(s1, s1->runtime_main, 1, 1);
+    if ((addr_t)-1 == (addr_t)prog_main)
+        return -1;
 
-#ifdef CONFIG_TCC_BACKTRACE
     memset(rc, 0, sizeof *rc);
+    rc->do_jmp = 1;
+
+#ifdef CONFIG_TCC_BACKTRACE
     if (s1->do_debug) {
         void *p;
-        rc->stab_sym = (Stab_Sym *)stab_section->data;
-        rc->stab_sym_end = (Stab_Sym *)(stab_section->data + stab_section->data_offset);
-        rc->stab_str = (char *)stab_section->link->data;
+	if (s1->dwarf) {
+	    rc->dwarf_line = dwarf_line_section->data;
+	    rc->dwarf_line_end = dwarf_line_section->data + dwarf_line_section->data_offset;
+	    if (dwarf_line_str_section)
+		rc->dwarf_line_str = dwarf_line_str_section->data;
+	}
+	else
+	{
+            rc->stab_sym = (Stab_Sym *)stab_section->data;
+            rc->stab_sym_end = (Stab_Sym *)(stab_section->data + stab_section->data_offset);
+            rc->stab_str = (char *)stab_section->link->data;
+	}
+        rc->dwarf = s1->dwarf;
         rc->esym_start = (ElfW(Sym) *)(symtab_section->data);
         rc->esym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
         rc->elf_str = (char *)symtab_section->link->data;
 #if PTR_SIZE == 8
         rc->prog_base = text_section->sh_addr & 0xffffffff00000000ULL;
+#if defined TCC_TARGET_MACHO
+	if (s1->dwarf)
+	    rc->prog_base = (addr_t) -1;
+#else
+#endif
 #endif
         rc->top_func = tcc_get_symbol(s1, "main");
         rc->num_callers = s1->rt_num_callers;
-        rc->do_jmp = 1;
         if ((p = tcc_get_symbol(s1, "__rt_error")))
             *(void**)p = _rt_error;
 #ifdef CONFIG_TCC_BCHECK
@@ -197,16 +260,14 @@ LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
     errno = 0; /* clean errno value */
     fflush(stdout);
     fflush(stderr);
+
     /* These aren't C symbols, so don't need leading underscore handling.  */
     run_cdtors(s1, "__init_array_start", "__init_array_end", argc, argv, envp);
-#ifdef CONFIG_TCC_BACKTRACE
-    if (!rc->do_jmp || !(ret = setjmp(rc->jmp_buf)))
-#endif
-    {
+    if (!(ret = setjmp(rc->jb)))
         ret = prog_main(argc, argv, envp);
-    }
     run_cdtors(s1, "__fini_array_start", "__fini_array_end", 0, NULL, NULL);
-    if ((s1->dflag & 16) && ret)
+    run_on_exit(ret);
+    if (s1->dflag & 16 && ret) /* tcc -dt -run ... */
         fprintf(s1->ppfp, "[returns %d]\n", ret), fflush(s1->ppfp);
     return ret;
 }
@@ -243,7 +304,7 @@ static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff)
 #else
         tcc_add_runtime(s1);
 	resolve_common_syms(s1);
-        build_got_entries(s1);
+        build_got_entries(s1, 0);
 #endif
         if (s1->nb_errors)
             return -1;
@@ -315,8 +376,10 @@ static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff)
 #if DEBUG_RUNMEN
             printf("protect %d %p %04x\n", f, (void*)addr, n);
 #endif
-            if (n)
-                set_pages_executable(s1, f, (void*)addr, n);
+            if (n) {
+                if (set_pages_executable(s1, f, (void*)addr, n))
+                    return -1;
+            }
         }
     }
 
@@ -346,7 +409,7 @@ static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff)
 /* ------------------------------------------------------------- */
 /* allow to run code in memory */
 
-static void set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned long length)
+static int set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned long length)
 {
 #ifdef _WIN32
     static const unsigned char protect[] = {
@@ -356,7 +419,9 @@ static void set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned lon
         PAGE_EXECUTE_READWRITE
         };
     DWORD old;
-    VirtualProtect(ptr, length, protect[mode], &old);
+    if (!VirtualProtect(ptr, length, protect[mode], &old))
+        return -1;
+    return 0;
 #else
     static const unsigned char protect[] = {
         PROT_READ | PROT_EXEC,
@@ -369,16 +434,15 @@ static void set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned lon
     end = (addr_t)ptr + length;
     end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
     if (mprotect((void *)start, end - start, protect[mode]))
-        tcc_error("mprotect failed: did you mean to configure --with-selinux?");
-
+        return tcc_error_noabort("mprotect failed: did you mean to configure --with-selinux?");
 /* XXX: BSD sometimes dump core with bad system call */
-# if (TCC_TARGET_ARM && !TARGETOS_BSD) || TCC_TARGET_ARM64
+# if (defined TCC_TARGET_ARM && !TARGETOS_BSD) || defined TCC_TARGET_ARM64
     if (mode == 0 || mode == 3) {
         void __clear_cache(void *beginning, void *end);
         __clear_cache(ptr, (char *)ptr + length);
     }
 # endif
-
+    return 0;
 #endif
 }
 
@@ -426,7 +490,21 @@ static int rt_printf(const char *fmt, ...)
     return r;
 }
 
-#define INCLUDE_STACK_SIZE 32
+static char *rt_elfsym(rt_context *rc, addr_t wanted_pc, addr_t *func_addr)
+{
+    ElfW(Sym) *esym;
+    for (esym = rc->esym_start + 1; esym < rc->esym_end; ++esym) {
+        int type = ELFW(ST_TYPE)(esym->st_info);
+        if ((type == STT_FUNC || type == STT_GNU_IFUNC)
+            && wanted_pc >= esym->st_value
+            && wanted_pc < esym->st_value + esym->st_size) {
+            *func_addr = esym->st_value;
+            return rc->elf_str + esym->st_name;
+        }
+    }
+    return NULL;
+}
+
 
 /* print the position in the source file of PC value 'pc' by reading
    the stabs debug information */
@@ -438,7 +516,6 @@ static addr_t rt_printline (rt_context *rc, addr_t wanted_pc,
     const char *incl_files[INCLUDE_STACK_SIZE];
     int incl_index, last_incl_index, len, last_line_num, i;
     const char *str, *p;
-    ElfW(Sym) *esym;
     Stab_Sym *sym;
 
 next:
@@ -528,24 +605,14 @@ static addr_t rt_printline (rt_context *rc, addr_t wanted_pc,
     func_name[0] = '\0';
     func_addr = 0;
     last_incl_index = 0;
-
     /* we try symtab symbols (no line number info) */
-    for (esym = rc->esym_start + 1; esym < rc->esym_end; ++esym) {
-        int type = ELFW(ST_TYPE)(esym->st_info);
-        if (type == STT_FUNC || type == STT_GNU_IFUNC) {
-            if (wanted_pc >= esym->st_value &&
-                wanted_pc < esym->st_value + esym->st_size) {
-                pstrcpy(func_name, sizeof(func_name),
-                    rc->elf_str + esym->st_name);
-                func_addr = esym->st_value;
-                goto found;
-            }
-        }
+    p = rt_elfsym(rc, wanted_pc, &func_addr);
+    if (p) {
+        pstrcpy(func_name, sizeof func_name, p);
+        goto found;
     }
-
     if ((rc = rc->next))
         goto next;
-
 found:
     i = last_incl_index;
     if (i > 0) {
@@ -571,6 +638,366 @@ static addr_t rt_printline (rt_context *rc, addr_t wanted_pc,
     return func_addr;
 }
 
+/* ------------------------------------------------------------- */
+/* rt_printline - dwarf version */
+
+#define MAX_128	((8 * sizeof (long long) + 6) / 7)
+
+#define DIR_TABLE_SIZE	(64)
+#define FILE_TABLE_SIZE	(512)
+
+#define	dwarf_read_1(ln,end) \
+	((ln) < (end) ? *(ln)++ : 0)
+#define	dwarf_read_2(ln,end) \
+	((ln) + 2 < (end) ? (ln) += 2, read16le((ln) - 2) : 0)
+#define	dwarf_read_4(ln,end) \
+	((ln) + 4 < (end) ? (ln) += 4, read32le((ln) - 4) : 0)
+#define	dwarf_read_8(ln,end) \
+	((ln) + 8 < (end) ? (ln) += 8, read64le((ln) - 8) : 0)
+#define	dwarf_ignore_type(ln, end) /* timestamp/size/md5/... */ \
+	switch (entry_format[j].form) { \
+	case DW_FORM_data1: (ln) += 1; break; \
+	case DW_FORM_data2: (ln) += 2; break; \
+	case DW_FORM_data4: (ln) += 3; break; \
+	case DW_FORM_data8: (ln) += 8; break; \
+	case DW_FORM_data16: (ln) += 16; break; \
+	case DW_FORM_udata: dwarf_read_uleb128(&(ln), (end)); break; \
+	default: goto next_line; \
+	}
+
+static unsigned long long
+dwarf_read_uleb128(unsigned char **ln, unsigned char *end)
+{
+    unsigned char *cp = *ln;
+    unsigned long long retval = 0;
+    int i;
+
+    for (i = 0; i < MAX_128; i++) {
+	unsigned long long byte = dwarf_read_1(cp, end);
+
+        retval |= (byte & 0x7f) << (i * 7);
+	if ((byte & 0x80) == 0)
+	    break;
+    }
+    *ln = cp;
+    return retval;
+}
+
+static long long
+dwarf_read_sleb128(unsigned char **ln, unsigned char *end)
+{
+    unsigned char *cp = *ln;
+    long long retval = 0;
+    int i;
+
+    for (i = 0; i < MAX_128; i++) {
+	unsigned long long byte = dwarf_read_1(cp, end);
+
+        retval |= (byte & 0x7f) << (i * 7);
+	if ((byte & 0x80) == 0) {
+	    if ((byte & 0x40) && (i + 1) * 7 < 64)
+		retval |= -1LL << ((i + 1) * 7);
+	    break;
+	}
+    }
+    *ln = cp;
+    return retval;
+}
+
+static addr_t rt_printline_dwarf (rt_context *rc, addr_t wanted_pc,
+    const char *msg, const char *skip)
+{
+    unsigned char *ln;
+    unsigned char *cp;
+    unsigned char *end;
+    unsigned char *opcode_length;
+    unsigned long long size;
+    unsigned int length;
+    unsigned char version;
+    unsigned int min_insn_length;
+    unsigned int max_ops_per_insn;
+    int line_base;
+    unsigned int line_range;
+    unsigned int opcode_base;
+    unsigned int opindex;
+    unsigned int col;
+    unsigned int i;
+    unsigned int j;
+    unsigned int len;
+    unsigned long long value;
+    struct {
+	unsigned int type;
+	unsigned int form;
+    } entry_format[256];
+    unsigned int dir_size;
+#if 0
+    char *dirs[DIR_TABLE_SIZE];
+#endif
+    unsigned int filename_size;
+    struct dwarf_filename_struct {
+        unsigned int dir_entry;
+        char *name;
+    } filename_table[FILE_TABLE_SIZE];
+    addr_t last_pc;
+    addr_t pc;
+    addr_t func_addr;
+    int line;
+    char *filename;
+    char *function;
+
+next:
+    ln = rc->dwarf_line;
+    while (ln < rc->dwarf_line_end) {
+	dir_size = 0;
+	filename_size = 0;
+        last_pc = 0;
+        pc = 0;
+        func_addr = 0;
+        line = 1;
+        filename = NULL;
+        function = NULL;
+	length = 4;
+	size = dwarf_read_4(ln, rc->dwarf_line_end);
+	if (size == 0xffffffffu) // dwarf 64
+	    length = 8, size = dwarf_read_8(ln, rc->dwarf_line_end);
+	end = ln + size;
+	if (end < ln || end > rc->dwarf_line_end)
+	    break;
+	version = dwarf_read_2(ln, end);
+	if (version >= 5)
+	    ln += length + 2; // address size, segment selector, prologue Length
+	else
+	    ln += length; // prologue Length
+	min_insn_length = dwarf_read_1(ln, end);
+	if (version >= 4)
+	    max_ops_per_insn = dwarf_read_1(ln, end);
+	else
+	    max_ops_per_insn = 1;
+	ln++; // Initial value of 'is_stmt'
+	line_base = dwarf_read_1(ln, end);
+	line_base |= line_base >= 0x80 ? ~0xff : 0;
+	line_range = dwarf_read_1(ln, end);
+	opcode_base = dwarf_read_1(ln, end);
+	opcode_length = ln;
+	ln += opcode_base - 1;
+	opindex = 0;
+	if (version >= 5) {
+	    col = dwarf_read_1(ln, end);
+	    for (i = 0; i < col; i++) {
+	        entry_format[i].type = dwarf_read_uleb128(&ln, end);
+	        entry_format[i].form = dwarf_read_uleb128(&ln, end);
+	    }
+	    dir_size = dwarf_read_uleb128(&ln, end);
+	    for (i = 0; i < dir_size; i++) {
+		for (j = 0; j < col; j++) {
+		    if (entry_format[j].type == DW_LNCT_path) {
+		        if (entry_format[j].form != DW_FORM_line_strp)
+			    goto next_line;
+#if 0
+		        value = length == 4 ? dwarf_read_4(ln, end)
+					    : dwarf_read_8(ln, end);
+		        if (i < DIR_TABLE_SIZE)
+		            dirs[i] = (char *)rc->dwarf_line_str + value;
+#else
+			length == 4 ? dwarf_read_4(ln, end)
+				    : dwarf_read_8(ln, end);
+#endif
+		    }
+		    else 
+			dwarf_ignore_type(ln, end);
+		}
+	    }
+	    col = dwarf_read_1(ln, end);
+	    for (i = 0; i < col; i++) {
+	        entry_format[i].type = dwarf_read_uleb128(&ln, end);
+	        entry_format[i].form = dwarf_read_uleb128(&ln, end);
+	    }
+	    filename_size = dwarf_read_uleb128(&ln, end);
+	    for (i = 0; i < filename_size; i++)
+		for (j = 0; j < col; j++) {
+		    if (entry_format[j].type == DW_LNCT_path) {
+			if (entry_format[j].form != DW_FORM_line_strp)
+			    goto next_line;
+			value = length == 4 ? dwarf_read_4(ln, end)
+					    : dwarf_read_8(ln, end);
+		        if (i < FILE_TABLE_SIZE)
+		            filename_table[i].name =
+				(char *)rc->dwarf_line_str + value;
+	            }
+		    else if (entry_format[j].type == DW_LNCT_directory_index) {
+			switch (entry_format[j].form) {
+			case DW_FORM_data1: value = dwarf_read_1(ln, end); break;
+			case DW_FORM_data2: value = dwarf_read_2(ln, end); break;
+			case DW_FORM_data4: value = dwarf_read_4(ln, end); break;
+			case DW_FORM_udata: value = dwarf_read_uleb128(&ln, end); break;
+			default: goto next_line;
+			}
+		        if (i < FILE_TABLE_SIZE)
+		            filename_table[i].dir_entry = value;
+		    }
+		    else 
+			dwarf_ignore_type(ln, end);
+	    }
+	}
+	else {
+	    while ((dwarf_read_1(ln, end))) {
+#if 0
+		if (++dir_size < DIR_TABLE_SIZE)
+		    dirs[dir_size - 1] = (char *)ln - 1;
+#endif
+		while (dwarf_read_1(ln, end)) {}
+	    }
+	    while ((dwarf_read_1(ln, end))) {
+		if (++filename_size < FILE_TABLE_SIZE) {
+		    filename_table[filename_size - 1].name = (char *)ln - 1;
+		    while (dwarf_read_1(ln, end)) {}
+		    filename_table[filename_size - 1].dir_entry =
+		        dwarf_read_uleb128(&ln, end);
+		}
+		else {
+		    while (dwarf_read_1(ln, end)) {}
+		    dwarf_read_uleb128(&ln, end);
+		}
+		dwarf_read_uleb128(&ln, end); // time
+		dwarf_read_uleb128(&ln, end); // size
+	    }
+	}
+	if (filename_size >= 1)
+	    filename = filename_table[0].name;
+	while (ln < end) {
+	    last_pc = pc;
+	    i = dwarf_read_1(ln, end);
+	    if (i >= opcode_base) {
+	        if (max_ops_per_insn == 1)
+		    pc += ((i - opcode_base) / line_range) * min_insn_length;
+		else {
+		    pc += (opindex + (i - opcode_base) / line_range) /
+			  max_ops_per_insn * min_insn_length;
+		    opindex = (opindex + (i - opcode_base) / line_range) %
+			       max_ops_per_insn;
+		}
+		i = (int)((i - opcode_base) % line_range) + line_base;
+check_pc:
+		if (pc >= wanted_pc && wanted_pc >= last_pc)
+		    goto found;
+		line += i;
+	    }
+	    else {
+	        switch (i) {
+	        case 0:
+		    len = dwarf_read_uleb128(&ln, end);
+		    cp = ln;
+		    ln += len;
+		    if (len == 0)
+		        goto next_line;
+		    switch (dwarf_read_1(cp, end)) {
+		    case DW_LNE_end_sequence:
+		        break;
+		    case DW_LNE_set_address:
+#if PTR_SIZE == 4
+		        pc = dwarf_read_4(cp, end);
+#else
+		        pc = dwarf_read_8(cp, end);
+#endif
+#if defined TCC_TARGET_MACHO
+			if (rc->prog_base != (addr_t) -1)
+			    pc += rc->prog_base;
+#endif
+		        opindex = 0;
+		        break;
+		    case DW_LNE_define_file: /* deprecated */
+		        if (++filename_size < FILE_TABLE_SIZE) {
+		            filename_table[filename_size - 1].name = (char *)ln - 1;
+		            while (dwarf_read_1(ln, end)) {}
+		            filename_table[filename_size - 1].dir_entry =
+		                dwarf_read_uleb128(&ln, end);
+		        }
+		        else {
+		            while (dwarf_read_1(ln, end)) {}
+		            dwarf_read_uleb128(&ln, end);
+		        }
+		        dwarf_read_uleb128(&ln, end); // time
+		        dwarf_read_uleb128(&ln, end); // size
+		        break;
+		    case DW_LNE_hi_user - 1:
+		        function = (char *)cp;
+		        func_addr = pc;
+		        break;
+		    default:
+		        break;
+		    }
+		    break;
+	        case DW_LNS_advance_pc:
+		    if (max_ops_per_insn == 1)
+		        pc += dwarf_read_uleb128(&ln, end) * min_insn_length;
+		    else {
+		        unsigned long long off = dwarf_read_uleb128(&ln, end);
+
+		        pc += (opindex + off) / max_ops_per_insn *
+			      min_insn_length;
+		        opindex = (opindex + off) % max_ops_per_insn;
+		    }
+		    i = 0;
+		    goto check_pc;
+	        case DW_LNS_advance_line:
+		    line += dwarf_read_sleb128(&ln, end);
+		    break;
+	        case DW_LNS_set_file:
+		    i = dwarf_read_uleb128(&ln, end);
+		    i -= i > 0 && version < 5;
+		    if (i < FILE_TABLE_SIZE && i < filename_size)
+		        filename = filename_table[i].name;
+		    break;
+	        case DW_LNS_const_add_pc:
+		    if (max_ops_per_insn ==  1)
+		        pc += ((255 - opcode_base) / line_range) * min_insn_length;
+		    else {
+		        unsigned int off = (255 - opcode_base) / line_range;
+
+		        pc += ((opindex + off) / max_ops_per_insn) *
+			      min_insn_length;
+		        opindex = (opindex + off) % max_ops_per_insn;
+		    }
+		    i = 0;
+		    goto check_pc;
+	        case DW_LNS_fixed_advance_pc:
+		    i = dwarf_read_2(ln, end);
+		    pc += i;
+		    opindex = 0;
+		    i = 0;
+		    goto check_pc;
+	        default:
+		    for (j = 0; j < opcode_length[i - 1]; j++)
+                        dwarf_read_uleb128 (&ln, end);
+		    break;
+		}
+	    }
+	}
+next_line:
+	ln = end;
+    }
+
+    filename = NULL;
+    func_addr = 0;
+    /* we try symtab symbols (no line number info) */
+    function = rt_elfsym(rc, wanted_pc, &func_addr);
+    if (function)
+        goto found;
+    if ((rc = rc->next))
+        goto next;
+found:
+    if (filename) {
+	if (skip[0] && strstr(filename, skip))
+	    return (addr_t)-1;
+	rt_printf("%s:%d: ", filename, line);
+    }
+    else
+	rt_printf("0x%08llx : ", (long long)wanted_pc);
+    rt_printf("%s %s", msg, function ? function : "???");
+    return (addr_t)func_addr;
+}
+/* ------------------------------------------------------------- */
+
 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level);
 
 static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap)
@@ -578,7 +1005,7 @@ static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap)
     rt_context *rc = &g_rtctxt;
     addr_t pc = 0;
     char skip[100];
-    int i, level, ret, n;
+    int i, level, ret, n, one;
     const char *a, *b, *msg;
 
     if (fp) {
@@ -597,13 +1024,20 @@ static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap)
         memcpy(skip, a, b - a), skip[b - a] = 0;
         fmt = b + 1;
     }
+    one = 0;
+    /* hack for bcheck.c:dprintf(): one level, no newline */
+    if (fmt[0] == '\001')
+        ++fmt, one = 1;
 
     n = rc->num_callers ? rc->num_callers : 6;
     for (i = level = 0; level < n; i++) {
         ret = rt_get_caller_pc(&pc, rc, i);
         a = "%s";
         if (ret != -1) {
-            pc = rt_printline(rc, pc, level ? "by" : "at", skip);
+	    if (rc->dwarf)
+                pc = rt_printline_dwarf(rc, pc, level ? "by" : "at", skip);
+	    else
+                pc = rt_printline(rc, pc, level ? "by" : "at", skip);
             if (pc == (addr_t)-1)
                 continue;
             a = ": %s";
@@ -613,6 +1047,8 @@ static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap)
             rt_vprintf(fmt, ap);
         } else if (ret == -1)
             break;
+        if (one)
+            break;
         rt_printf("\n");
         if (ret == -1 || (pc == (addr_t)rc->top_func && pc))
             break;
@@ -634,14 +1070,6 @@ static int rt_error(const char *fmt, ...)
     return ret;
 }
 
-static void rt_exit(int code)
-{
-    rt_context *rc = &g_rtctxt;
-    if (rc->do_jmp)
-        longjmp(rc->jmp_buf, code ? code : 256);
-    exit(code);
-}
-
 /* ------------------------------------------------------------- */
 
 #ifndef _WIN32
diff --git a/tcctok.h b/tcctok.h
index d4c1ef5c8..cfdc60dcc 100644
--- a/tcctok.h
+++ b/tcctok.h
@@ -38,6 +38,7 @@
      DEF(TOK_RESTRICT2, "__restrict")
      DEF(TOK_RESTRICT3, "__restrict__")
      DEF(TOK_EXTENSION, "__extension__") /* gcc keyword */
+     DEF(TOK_THREAD_LOCAL, "_Thread_local") /* C11 thread-local storage */
 
      DEF(TOK_GENERIC, "_Generic")
      DEF(TOK_STATIC_ASSERT, "_Static_assert")
@@ -45,6 +46,7 @@
      DEF(TOK_FLOAT, "float")
      DEF(TOK_DOUBLE, "double")
      DEF(TOK_BOOL, "_Bool")
+     DEF(TOK_COMPLEX, "_Complex")
      DEF(TOK_SHORT, "short")
      DEF(TOK_STRUCT, "struct")
      DEF(TOK_UNION, "union")
@@ -94,6 +96,7 @@
      DEF(TOK___VA_ARGS__, "__VA_ARGS__")
      DEF(TOK___COUNTER__, "__COUNTER__")
      DEF(TOK___HAS_INCLUDE, "__has_include")
+     DEF(TOK___HAS_INCLUDE_NEXT, "__has_include_next")
 
 /* special identifiers */
      DEF(TOK___FUNC__, "__func__")
@@ -121,6 +124,8 @@
      DEF(TOK_ALIAS2, "__alias__")
      DEF(TOK_UNUSED1, "unused")
      DEF(TOK_UNUSED2, "__unused__")
+     DEF(TOK_NODEBUG1, "nodebug")
+     DEF(TOK_NODEBUG2, "__nodebug__")
      DEF(TOK_CDECL1, "cdecl")
      DEF(TOK_CDECL2, "__cdecl")
      DEF(TOK_CDECL3, "__cdecl__")
@@ -186,6 +191,13 @@
      DEF_ATOMIC(atomic_fetch_or)
      DEF_ATOMIC(atomic_fetch_xor)
      DEF_ATOMIC(atomic_fetch_and)
+     DEF_ATOMIC(atomic_fetch_nand)
+     DEF_ATOMIC(atomic_add_fetch)
+     DEF_ATOMIC(atomic_sub_fetch)
+     DEF_ATOMIC(atomic_or_fetch)
+     DEF_ATOMIC(atomic_xor_fetch)
+     DEF_ATOMIC(atomic_and_fetch)
+     DEF_ATOMIC(atomic_nand_fetch)
 
 /* pragma */
      DEF(TOK_pack, "pack")
diff --git a/tcctools.c b/tcctools.c
index 2bcc990d4..5eb4349dc 100644
--- a/tcctools.c
+++ b/tcctools.c
@@ -61,8 +61,8 @@ static int contains_any(const char *s, const char *list) {
 }
 
 static int ar_usage(int ret) {
-    fprintf(stderr, "usage: tcc -ar [rcsv] lib [file...]\n");
-    fprintf(stderr, "create library ([abdioptxN] not supported).\n");
+    fprintf(stderr, "usage: tcc -ar [crstvx] lib [files]\n");
+    fprintf(stderr, "create library ([abdiopN] not supported).\n");
     return ret;
 }
 
@@ -70,11 +70,11 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
 {
     static const ArHdr arhdr_init = {
         "/               ",
-        "            ",
+        "0           ",
         "0     ",
         "0     ",
         "0       ",
-        "          ",
+        "0         ",
         ARFMAG
         };
 
@@ -82,6 +82,7 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
     ArHdr arhdro = arhdr_init;
 
     FILE *fi, *fh = NULL, *fo = NULL;
+    const char *created_file = NULL; // must delete on error
     ElfW(Ehdr) *ehdr;
     ElfW(Shdr) *shdr;
     ElfW(Sym) *sym;
@@ -94,7 +95,9 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
     char tfile[260], stmp[20];
     char *file, *name;
     int ret = 2;
-    const char *ops_conflict = "habdioptxN";  // unsupported but destructive if ignored.
+    const char *ops_conflict = "habdiopN";  // unsupported but destructive if ignored.
+    int extract = 0;
+    int table = 0;
     int verbose = 0;
 
     i_lib = 0; i_obj = 0;  // will hold the index of the lib and first obj
@@ -105,6 +108,10 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
         if ((*a == '-') || (i == 1 && !strstr(a, "."))) {  // options argument
             if (contains_any(a, ops_conflict))
                 ret = 1;
+            if (strstr(a, "x"))
+                extract = 1;
+            if (strstr(a, "t"))
+                table = 1;
             if (strstr(a, "v"))
                 verbose = 1;
         } else {  // lib or obj files: don't abort - keep validating all args.
@@ -122,11 +129,66 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
     if (ret == 1)
         return ar_usage(ret);
 
+    if (extract || table) {
+        if ((fh = fopen(argv[i_lib], "rb")) == NULL)
+        {
+            fprintf(stderr, "tcc: ar: can't open file %s\n", argv[i_lib]);
+            goto finish;
+        }
+        fread(stmp, 1, 8, fh);
+	if (memcmp(stmp,ARMAG,8))
+	{
+no_ar:
+            fprintf(stderr, "tcc: ar: not an ar archive %s\n", argv[i_lib]);
+            goto finish;
+	}
+	while (fread(&arhdr, 1, sizeof(arhdr), fh) == sizeof(arhdr)) {
+	    char *p, *e;
+
+	    if (memcmp(arhdr.ar_fmag, ARFMAG, 2))
+		goto no_ar;
+	    p = arhdr.ar_name;
+	    for (e = p + sizeof arhdr.ar_name; e > p && e[-1] == ' ';)
+		e--;
+	    *e = '\0';
+	    arhdr.ar_size[sizeof arhdr.ar_size-1] = 0;
+	    fsize = atoi(arhdr.ar_size);
+	    buf = tcc_malloc(fsize + 1);
+	    fread(buf, fsize, 1, fh);
+	    if (strcmp(arhdr.ar_name,"/") && strcmp(arhdr.ar_name,"/SYM64/")) {
+		if (e > p && e[-1] == '/')
+		    e[-1] = '\0';
+		/* tv not implemented */
+	        if (table || verbose)
+		    printf("%s%s\n", extract ? "x - " : "", arhdr.ar_name);
+		if (extract) {
+		    if ((fo = fopen(arhdr.ar_name, "wb")) == NULL)
+		    {
+			fprintf(stderr, "tcc: ar: can't create file %s\n",
+				arhdr.ar_name);
+		        tcc_free(buf);
+			goto finish;
+		    }
+		    fwrite(buf, fsize, 1, fo);
+		    fclose(fo);
+		    /* ignore date/uid/gid/mode */
+		}
+	    }
+            tcc_free(buf);
+	}
+	ret = 0;
+finish:
+	if (fh)
+		fclose(fh);
+	return ret;
+    }
+
     if ((fh = fopen(argv[i_lib], "wb")) == NULL)
     {
-        fprintf(stderr, "tcc: ar: can't open file %s \n", argv[i_lib]);
+        fprintf(stderr, "tcc: ar: can't create file %s\n", argv[i_lib]);
         goto the_end;
     }
+    created_file = argv[i_lib];
 
     sprintf(tfile, "%s.tmp", argv[i_lib]);
     if ((fo = fopen(tfile, "wb+")) == NULL)
@@ -137,7 +199,7 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
 
     funcmax = 250;
     afpos = tcc_realloc(NULL, funcmax * sizeof *afpos); // 250 func
-    memcpy(&arhdro.ar_mode, "100666", 6);
+    memcpy(&arhdro.ar_mode, "100644", 6);
 
     // i_obj = first input object file
     while (i_obj < argc)
@@ -242,13 +304,13 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
     if ((hofs & 1)) // align
         hofs++, fpos = 1;
     // write header
-    fwrite("!<arch>\n", 8, 1, fh);
+    fwrite(ARMAG, 8, 1, fh);
     // create an empty archive
     if (!funccnt) {
         ret = 0;
         goto the_end;
     }
-    sprintf(stmp, "%-10d", (int)(strpos + (funccnt+1) * sizeof(int)));
+    sprintf(stmp, "%-10d", (int)(strpos + (funccnt+1) * sizeof(int)) + fpos);
     memcpy(&arhdr.ar_size, stmp, 10);
     fwrite(&arhdr, sizeof(arhdr), 1, fh);
     afpos[0] = le2belong(funccnt);
@@ -274,6 +336,8 @@ ST_FUNC int tcc_tool_ar(TCCState *s1, int argc, char **argv)
         tcc_free(afpos);
     if (fh)
         fclose(fh);
+    if (created_file && ret != 0)
+        remove(created_file);
     if (fo)
         fclose(fo), remove(tfile);
     return ret;
@@ -430,9 +494,10 @@ ST_FUNC int tcc_tool_impdef(TCCState *s1, int argc, char **argv)
 
 #if !defined TCC_TARGET_I386 && !defined TCC_TARGET_X86_64
 
-ST_FUNC void tcc_tool_cross(TCCState *s1, char **argv, int option)
+ST_FUNC int tcc_tool_cross(TCCState *s1, char **argv, int option)
 {
-    tcc_error("-m%d not implemented.", option);
+    tcc_error_noabort("-m%d not implemented.", option);
+    return 1;
 }
 
 #else
@@ -479,7 +544,7 @@ static int execvp_win32(const char *prog, char **argv)
 #define execvp execvp_win32
 #endif /* _WIN32 */
 
-ST_FUNC void tcc_tool_cross(TCCState *s1, char **argv, int target)
+ST_FUNC int tcc_tool_cross(TCCState *s1, char **argv, int target)
 {
     char program[4096];
     char *a0 = argv[0];
@@ -498,7 +563,8 @@ ST_FUNC void tcc_tool_cross(TCCState *s1, char **argv, int target)
 
     if (strcmp(a0, program))
         execvp(argv[0] = program, argv);
-    tcc_error("could not run '%s'", program);
+    tcc_error_noabort("could not run '%s'", program);
+    return 1;
 }
 
 #endif /* TCC_TARGET_I386 && TCC_TARGET_X86_64 */
@@ -528,11 +594,12 @@ static char *escape_target_dep(const char *s) {
     return res;
 }
 
-ST_FUNC void gen_makedeps(TCCState *s1, const char *target, const char *filename)
+ST_FUNC int gen_makedeps(TCCState *s1, const char *target, const char *filename)
 {
     FILE *depout;
-    char buf[1024], *escaped_target;
-    int i, k;
+    char buf[1024];
+    char **escaped_targets;
+    int i, k, num_targets;
 
     if (!filename) {
         /* compute filename automatically: dir/file.o -> dir/file.d */
@@ -541,28 +608,42 @@ ST_FUNC void gen_makedeps(TCCState *s1, const char *target, const char *filename
         filename = buf;
     }
 
-    if (s1->verbose)
-        printf("<- %s\n", filename);
-
     if(!strcmp(filename, "-"))
         depout = fdopen(1, "w");
     else
         /* XXX return err codes instead of error() ? */
         depout = fopen(filename, "w");
     if (!depout)
-        tcc_error("could not open '%s'", filename);
-    fprintf(depout, "%s:", target);
+        return tcc_error_noabort("could not open '%s'", filename);
+    if (s1->verbose)
+        printf("<- %s\n", filename);
+
+    escaped_targets = tcc_malloc(s1->nb_target_deps * sizeof(*escaped_targets));
+    num_targets = 0;
     for (i = 0; i<s1->nb_target_deps; ++i) {
         for (k = 0; k < i; ++k)
             if (0 == strcmp(s1->target_deps[i], s1->target_deps[k]))
                 goto next;
-        escaped_target = escape_target_dep(s1->target_deps[i]);
-        fprintf(depout, " \\\n  %s", escaped_target);
-        tcc_free(escaped_target);
+        escaped_targets[num_targets++] = escape_target_dep(s1->target_deps[i]);
     next:;
     }
+
+    fprintf(depout, "%s:", target);
+    for (i = 0; i < num_targets; ++i)
+        fprintf(depout, " \\\n  %s", escaped_targets[i]);
     fprintf(depout, "\n");
+    if (s1->gen_phony_deps) {
+        /* Skip first file, which is the c file.
+         * Only works for single file give on command-line,
+         * but other compilers have the same limitation */
+        for (i = 1; i < num_targets; ++i)
+            fprintf(depout, "%s:\n", escaped_targets[i]);
+    }
+    for (i = 0; i < num_targets; ++i)
+        tcc_free(escaped_targets[i]);
+    tcc_free(escaped_targets);
     fclose(depout);
+    return 0;
 }
 
 /* -------------------------------------------------------------- */
diff --git a/tests/Makefile b/tests/Makefile
index 8cc2e36cb..a46c85243 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -5,7 +5,7 @@
 TOP = ..
 include $(TOP)/Makefile
 VPATH = $(TOPSRC)/tests $(TOPSRC) $(TOP)
-CFLAGS := $(filter-out -W% -g% -O%,$(CFLAGS)) -I$(TOPSRC) $(LDFLAGS)
+CFLAGS := $(filter-out -g% -O%,$(CFLAGS)) -I$(TOPSRC) $(LDFLAGS)
 
 # what tests to run
 TESTS = \
@@ -32,11 +32,8 @@ endif
 ifeq ($(CONFIG_dll),no)
  TESTS := $(filter-out dlltest, $(TESTS))
 endif
-ifeq (,$(filter arm64 i386 x86_64,$(ARCH)))
- TESTS := $(filter-out vla_test-run,$(TESTS))
-endif
-ifeq ($(CONFIG_arm_eabi),yes)
- TESTS := $(filter-out test3,$(TESTS))
+ifeq (-$(CONFIG_arm_eabi)-$(CONFIG_arm_vfp)-,-yes--)
+ TESTS := $(filter-out test3 test1b,$(TESTS))
 endif
 ifeq (,$(filter i386 x86_64,$(ARCH)))
  TESTS := $(filter-out asm-c-connect-test,$(TESTS))
@@ -161,7 +158,7 @@ dlltest:
 	$(TCC) $(NATIVE_DEFINES) -DLIBTCC_AS_DLL $(TOPSRC)/libtcc.c $(LIBS) -shared -o libtcc2$(DLLSUF)
 	$(TCC) $(NATIVE_DEFINES) -DONE_SOURCE=0 $(TOPSRC)/tcc.c libtcc2$(DLLSUF) $(LIBS) -Wl,-rpath=. -o tcc2$(EXESUF)
 	./tcc2$(EXESUF) $(TCCFLAGS) $(RUN_TCC) -run $(TOPSRC)/examples/ex1.c
-ifndef CONFIG_WIN32
+ifeq (,$(filter Darwin WIN32,$(TARGETOS)))
 	@echo ------------ $@ with PIC ------------
 	$(CC) $(CFLAGS) -fPIC $(NATIVE_DEFINES) -DLIBTCC_AS_DLL -c $(TOPSRC)/libtcc.c
 	$(TCC) libtcc.o $(LIBS) -shared -o libtcc2$(DLLSUF)
@@ -220,7 +217,7 @@ ex%: $(TOPSRC)/examples/ex%.c
 
 # tiny assembler testing
 asmtest.ref: asmtest.S
-	$(CC) -Wa,-W -o asmtest.ref.o -c asmtest.S
+	$(CC) -Wa,-W -Wa,-mx86-used-note=no -o asmtest.ref.o -c asmtest.S
 	objdump -D asmtest.ref.o > asmtest.ref
 
 ifeq ($(ARCH),arm)
@@ -250,7 +247,7 @@ abitest-% : abitest-%.exe
 	./$< $(TCCFLAGS)
 
 abitest: abitest-cc
-ifneq ($(CONFIG_arm_eabi),yes) # not ARM soft-float
+ifneq (-$(CONFIG_arm_eabi)-$(CONFIG_arm_vfp)-,-yes--)
 abitest: abitest-tcc
 endif
 
@@ -261,6 +258,8 @@ vla_test-run: vla_test$(EXESUF)
 	@echo ------------ $@ ------------
 	./vla_test$(EXESUF)
 
+.PHONY: abitest vla_test
+
 asm-c-connect$(EXESUF): asm-c-connect-1.c asm-c-connect-2.c
 	$(TCC) -o $@ $^
 
diff --git a/tests/asmtest.S b/tests/asmtest.S
index e9c0e32f4..7f31ce59b 100644
--- a/tests/asmtest.S
+++ b/tests/asmtest.S
@@ -425,7 +425,7 @@ L3:
 
  fsubp %st(5)
  fsubp
- fsubp %st(1), %st
+ //fsubp %st(1), %st # not accepted by new GAS anymore
 
  fsubs 0x1000
  fisubs 0x1002
@@ -438,7 +438,7 @@ L3:
 
  fsubrp %st(5)
  fsubrp
- fsubrp %st(1), %st
+ //fsubrp %st(1), %st # not accepted by new GAS anymore
 
  fsubrs 0x1000
  fisubrs 0x1002
@@ -451,7 +451,7 @@ L3:
 
  fdivp %st(5)
  fdivp
- fdivp %st(1), %st
+ //fdivp %st(1), %st # not accepted by new GAS anymore
 
  fdivs 0x1000
  fidivs 0x1002
@@ -632,10 +632,19 @@ int $0x10
     leave
     int3
     iret
+    iretw
+    iretl
+#ifdef __x86_64__
+    iretq
+#endif
     rsm
     hlt
     wait
     nop
+    vmcall
+    vmlaunch
+    vmresume
+    vmxoff
 
     /* XXX: handle prefixes */
 #if 0
@@ -692,6 +701,10 @@ int $0x10
     fxsaveq (%r11)
     fxrstorq (%rcx)
     fxrstorq (%r10)
+    movnti %ebx, (%rdi)
+    movntil %ecx, (%rdi)
+    movnti %rax, (%rdi)
+    movntiq %r8, (%rdi)
 
 #endif
 
@@ -745,8 +758,37 @@ int $0x10
     bts %edx, 0x1000
     btsl $2, 0x1000
 
-        
-        
+    popcnt %ax, %si
+    popcntw %ax, %si
+    popcnt 0x1000, %edx
+    popcntl 0x1000, %edx
+#ifdef __x86_64__
+    popcnt %rbx, %rdi
+    popcntq %rcx, %r8
+#endif
+
+    lzcnt %cx, %ax
+    lzcntw %cx, %ax
+    lzcnt %edx, %ebx
+    lzcntl 8(%edi), %ecx
+#ifdef __x86_64__
+    lzcnt %rdi, %rdx
+    lzcntq %r12, %r15
+    lzcnt 0x40(%rcx), %r11
+    lzcntq (%r8), %rsi
+#endif
+
+    tzcnt %cx, %ax
+    tzcntw %cx, %ax
+    tzcnt %edx, %ebx
+    tzcntl -24(%edi), %ecx
+#ifdef __x86_64__
+    tzcnt %rbp, %rdx
+    tzcntq %rax, %r15
+    tzcnt -8(%rbp), %rcx
+    tzcntq (%r8), %r12
+#endif
+
 #ifdef __i386__
     boundl %edx, 0x10000
     boundw %bx, 0x1000
@@ -768,8 +810,13 @@ int $0x10
 
     swapgs
 
-    str %rdx
-    str %r9
+    /* Newer gas assemble 'str %rdx' as 'str %edx', based on the observation
+       that the 16bit value of the task register is zero-extended into the
+       destination anyway, and hence storing into %edx is the same as storing
+       into %rdx.  TCC doesn't do that micro-optimization, hence just store
+       into the 32bit reg as well.  */
+    str %edx
+    str %r9d
 #endif
 
     lmsw 0x1000
diff --git a/tests/bug.c b/tests/bug.c
index d4e61bcc7..b0bc2d547 100644
--- a/tests/bug.c
+++ b/tests/bug.c
@@ -25,12 +25,6 @@ int compile_errors(void)
    l1: return 1;
    l2: return 2;
   }
-#endif
-#if TEST == 4
-  {
-    /* Only integer allowed */
-     __builtin_return_address(0 + 1) != NULL;
-  }
 #endif
   return 0;
 }
diff --git a/tests/gcctestsuite.sh b/tests/gcctestsuite.sh
old mode 100644
new mode 100755
index 2be274ca3..b6f9ec213
--- a/tests/gcctestsuite.sh
+++ b/tests/gcctestsuite.sh
@@ -1,31 +1,114 @@
 #!/bin/sh
 
-TESTSUITE_PATH=$HOME/gcc/gcc-3.2/gcc/testsuite/gcc.c-torture
-TCC="./tcc -B. -I. -DNO_TRAMPOLINES"
+if [ -z "$TESTSUITE_PATH" ]
+then
+  if [ -d "$HOME/gcc/gcc-3.2/gcc/testsuite/gcc.c-torture" ]
+  then
+    TESTSUITE_PATH="$HOME/gcc/gcc-3.2/gcc/testsuite/gcc.c-torture"
+  fi
+fi
+
+if [ -z "$TESTSUITE_PATH" ]
+then
+  echo "gcc testsuite not found."
+  echo "define TESTSUITE_PATH to point to the gcc.c-torture directory"
+  exit 1
+fi
+
+if [ -z "$TCC_SOURCE_PATH" ]
+then
+  if [ -f "include/tccdefs.h" ]
+  then
+    TCC_SOURCE_PATH="."
+  elif [ -f "../include/tccdefs.h" ]
+  then
+    TCC_SOURCE_PATH=".."
+  elif [ -f "../tinycc/include/tccdefs.h" ]
+  then
+    TCC_SOURCE_PATH="../tinycc"
+  fi
+fi
+
+if [ -z "$RUNTIME_DIR" ]
+then
+   RUNTIME_DIR=$XDG_RUNTIME_DIR
+fi
+if [ -z "$RUNTIME_DIR" ]
+then
+  RUNTIME_DIR="/tmp"
+fi
+
+if [ -z "$CC" ]
+then
+  if [ -z "$TCC_SOURCE_PATH" ]
+  then
+      echo "tcc not found."
+      echo "define TCC_SOURCE_PATH to point to the tcc source path"
+      exit 1
+  fi
+
+  TCC="./tcc -B. -I$TCC_SOURCE_PATH/ -I$TCC_SOURCE_PATH/include -DNO_TRAMPOLINES"
+else
+  TCC="$CC -O1 -Wno-implicit-int $CFLAGS"
+fi
+
 rm -f tcc.sum tcc.fail
 nb_ok="0"
+nb_skipped="0"
 nb_failed="0"
 nb_exe_failed="0"
 
+# skip some failed tests not implemented in tcc
+# builtin: gcc "__builtins_*"
+# ieee: gcc "__builtins_*" in the ieee directory
+# complex: C99 "_Complex" and gcc "__complex__"
+# misc: stdc features, other arch, gcc extensions (example: gnu_inline in c89)
+#
+
+old_pwd="`pwd`"
+cd "$TESTSUITE_PATH"
+
+skip_builtin="`grep "_builtin_"  compile/*.c  execute/*.c  execute/ieee/*.c | cut -d ':' -f1 | cut -d '/' -f2 |  sort -u `"
+skip_ieee="`grep "_builtin_"   execute/ieee/*.c | cut -d ':' -f1 | cut -d '/' -f3 |  sort -u `"
+skip_complex="`grep -i "_Complex"  compile/*.c  execute/*.c  execute/ieee/*.c | cut -d ':' -f1 | cut -d '/' -f2 |  sort -u `"
+skip_misc="20000120-2.c mipscop-1.c mipscop-2.c mipscop-3.c mipscop-4.c
+   fp-cmp-4f.c fp-cmp-4l.c fp-cmp-8f.c fp-cmp-8l.c pr38016.c "
+
+cd "$old_pwd"
+
 for src in $TESTSUITE_PATH/compile/*.c ; do
-  echo $TCC -o /tmp/tst.o -c $src 
-  $TCC -o /tmp/tst.o -c $src >> tcc.fail 2>&1
+  echo $TCC -o $RUNTIME_DIR/tst.o -c $src
+  $TCC -o $RUNTIME_DIR/tst.o -c $src >> tcc.fail 2>&1
   if [ "$?" = "0" ] ; then
     result="PASS"
     nb_ok=$(( $nb_ok + 1 ))
   else
-    result="FAIL"
-    nb_failed=$(( $nb_failed + 1 ))
+    base=`basename "$src"`
+    skip_me="`echo  $skip_builtin $skip_ieee $skip_complex $skip_misc | grep -w $base`"
+
+    if [ -n "$skip_me" ]
+    then
+      result="SKIP"
+      nb_skipped=$(( $nb_skipped + 1 ))
+    else
+      result="FAIL"
+      nb_failed=$(( $nb_failed + 1 ))
+    fi
   fi
   echo "$result: $src"  >> tcc.sum
 done
 
-for src in $TESTSUITE_PATH/execute/*.c ; do
-  echo $TCC $src -o /tmp/tst -lm
-  $TCC $src -o /tmp/tst -lm >> tcc.fail 2>&1
+if [ -f "$RUNTIME_DIR/tst.o" ]
+then
+    rm -f "$RUNTIME_DIR/tst.o"
+fi
+
+for src in $TESTSUITE_PATH/execute/*.c  $TESTSUITE_PATH/execute/ieee/*.c ; do
+  echo $TCC $src -o $RUNTIME_DIR/tst -lm
+  $TCC $src -o $RUNTIME_DIR/tst -lm >> tcc.fail 2>&1
   if [ "$?" = "0" ] ; then
     result="PASS"
-    if /tmp/tst >> tcc.fail 2>&1
+    if $RUNTIME_DIR/tst >> tcc.fail 2>&1
     then
       result="PASS"
       nb_ok=$(( $nb_ok + 1 ))
@@ -34,14 +117,34 @@ for src in $TESTSUITE_PATH/execute/*.c ; do
       nb_exe_failed=$(( $nb_exe_failed + 1 ))
     fi
   else
-    result="FAIL"
-    nb_failed=$(( $nb_failed + 1 ))
+    base=`basename "$src"`
+    skip_me="`echo $skip_builtin $skip_ieee $skip_complex $skip_misc | grep -w $base`"
+
+    if [ -n "$skip_me" ]
+    then
+      result="SKIP"
+      nb_skipped=$(( $nb_skipped + 1 ))
+    else
+      result="FAIL"
+      nb_failed=$(( $nb_failed + 1 ))
+    fi
   fi
   echo "$result: $src"  >> tcc.sum
 done
 
+if [ -f "$RUNTIME_DIR/tst.o" ]
+then
+    rm -f "$RUNTIME_DIR/tst.o"
+fi
+if [ -f "$RUNTIME_DIR/tst" ]
+then
+    rm -f "$RUNTIME_DIR/tst"
+fi
+
 echo "$nb_ok test(s) ok." >> tcc.sum
 echo "$nb_ok test(s) ok."
+echo "$nb_skipped test(s) skipped." >> tcc.sum
+echo "$nb_skipped test(s) skipped."
 echo "$nb_failed test(s) failed." >> tcc.sum
 echo "$nb_failed test(s) failed."
 echo "$nb_exe_failed test(s) exe failed." >> tcc.sum
diff --git a/tests/libtcc_test_mt.c b/tests/libtcc_test_mt.c
index 6892bfef2..7af8f3e8f 100644
--- a/tests/libtcc_test_mt.c
+++ b/tests/libtcc_test_mt.c
@@ -209,9 +209,8 @@ TF_TYPE(thread_test_complex, vn)
     sleep_ms(2);
     ret = tcc_add_file(s, argv[0]);
     sleep_ms(3);
-    if (ret < 0)
-        exit(1);
-    tcc_run(s, argc, argv);
+    if (ret == 0)
+        tcc_run(s, argc, argv);
     tcc_delete(s);
     fflush(stdout);
     return 0;
@@ -288,6 +287,9 @@ int main(int argc, char **argv)
 
 #else
 #include <tcclib.h>
+
+unsigned int sleep(unsigned int seconds);
+
 int fib(n)
 {
     return (n <= 2) ? 1 : fib(n-1) + fib(n-2);
@@ -295,7 +297,8 @@ int fib(n)
 
 int main(int argc, char **argv)
 {
-    printf(" %d", fib(atoi(argv[1]), 2));
+    sleep(1);
+    printf(" %d", fib(atoi(argv[1])));
     return 0;
 }
 #endif
diff --git a/tests/pp/11.c b/tests/pp/11.c
index c0edf629c..5ce868b11 100644
--- a/tests/pp/11.c
+++ b/tests/pp/11.c
@@ -29,3 +29,8 @@ __NORETURN
 #define X(...)
 #define Y(...)  1 __VA_ARGS__ 2
 Y(X X() ())
+
+#define DDD(A, B) D_ ## B ## _D_ ## A
+#define CCC(X, ...) DDD(X, ##__VA_ARGS__)
+/* must be D_B_D_A (not D_B _D_A) */
+CCC(A,B)
diff --git a/tests/pp/11.expect b/tests/pp/11.expect
index 6b9806c6c..bb5d6b780 100644
--- a/tests/pp/11.expect
+++ b/tests/pp/11.expect
@@ -13,3 +13,4 @@ x A y
 x y
 __attribute__((__noreturn__))
 1 2
+D_B_D_A
diff --git a/tests/pp/22.c b/tests/pp/22.c
new file mode 100644
index 000000000..76e23154b
--- /dev/null
+++ b/tests/pp/22.c
@@ -0,0 +1,12 @@
+#define TRACE(a,b,c) X a X b X c X
+#define rettrue(x) 1
+A rettrue(bla) B
+TRACE(
+      ARG_1,
+#if rettrue(bla)
+      ARG_2,
+#else
+      ARG_2_wrong,
+#endif
+      ARG_3
+);
diff --git a/tests/pp/22.expect b/tests/pp/22.expect
new file mode 100644
index 000000000..ceaea0301
--- /dev/null
+++ b/tests/pp/22.expect
@@ -0,0 +1,2 @@
+A 1 B
+X ARG_1 X ARG_2 X ARG_3 X;
diff --git a/tests/pp/23.c b/tests/pp/23.c
new file mode 100644
index 000000000..1df233f76
--- /dev/null
+++ b/tests/pp/23.c
@@ -0,0 +1,117 @@
+#define M_DEFERRED_COMMA            ,
+
+#define M_EAT(...)
+#define M_APPLY(a, ...)             a (__VA_ARGS__)
+#define M_ID(...)                 __VA_ARGS__
+
+#define M_C2I(a, ...)       a ## __VA_ARGS__
+#define M_C(a, ...)         M_C2I(a, __VA_ARGS__)
+#define M_C3I(a, b, ...)    a ## b ## __VA_ARGS__
+#define M_C3(a, b, ...)     M_C3I(a ,b, __VA_ARGS__)
+#define M_C4I(a, b, c, ...) a ## b ## c ## __VA_ARGS__
+#define M_C4(a, b, c, ...)  M_C4I(a ,b, c, __VA_ARGS__)
+
+#define M_INVI_0                    1
+#define M_INVI_1                    0
+#define M_INV(x)                    M_C(M_INVI_, x)
+
+#define M_ANDI_00                   0
+#define M_ANDI_01                   0
+#define M_ANDI_10                   0
+#define M_ANDI_11                   1
+#define M_AND(x,y)                  M_C3(M_ANDI_, x, y)
+
+#define M_ANDI_000                  0
+#define M_ANDI_001                  0
+#define M_ANDI_010                  0
+#define M_ANDI_011                  0
+#define M_ANDI_100                  0
+#define M_ANDI_101                  0
+#define M_ANDI_110                  0
+#define M_ANDI_111                  1
+#define M_AND3(x,y,z)               M_C4(M_ANDI_, x, y, z)
+
+#define M_ORI_00                    0
+#define M_ORI_01                    1
+#define M_ORI_10                    1
+#define M_ORI_11                    1
+#define M_OR(x,y)                   M_C3(M_ORI_, x, y)
+
+#define M_ORI_000                   0
+#define M_ORI_001                   1
+#define M_ORI_010                   1
+#define M_ORI_011                   1
+#define M_ORI_100                   1
+#define M_ORI_101                   1
+#define M_ORI_110                   1
+#define M_ORI_111                   1
+#define M_OR3(x,y,z)                M_C4(M_ORI_, x, y, z)
+
+#define M_RETI_ARG2(_1, _2, ...) _2
+#define M_RET_ARG2(...) M_RETI_ARG2(__VA_ARGS__,)
+
+#define M_RETI_ARG4(_1, _2, _3, _4, ...) _4
+#define M_RET_ARG4(...) M_RETI_ARG4(__VA_ARGS__,)
+
+#define M_TOBOOLI_0                 1, 0,
+#define M_BOOL(x)                   M_RET_ARG2(M_C(M_TOBOOLI_, x), 1, useless)
+
+#define M_IFI_0(true_c, ...)        __VA_ARGS__
+#define M_IFI_1(true_c, ...)        true_c
+#define M_IF(c)                     M_C(M_IFI_, M_BOOL(c))
+
+#define M_NARGS(...) M_RET_ARG4(__VA_ARGS__, 3, 2, 1, useless)
+
+#define M_MAP(...)        M_MAP_0(__VA_ARGS__)
+#define M_MAP_0(f, ...)   M_C(M_MAP_, M_NARGS(__VA_ARGS__))(f, __VA_ARGS__)
+#define M_MAP_1(f, _1) f(_1) 
+#define M_MAP_2(f, _1, _2) f(_1) f(_2) 
+#define M_MAP_3(f, _1, _2, _3) f(_1) f(_2) f(_3) 
+
+#define M_MAP2(...)        M_MAP2I_0(__VA_ARGS__)
+#define M_MAP2I_0(f, d, ...)  M_C(M_MAP2I_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP2I_1(f, d, _1) f(d, _1) 
+#define M_MAP2I_2(f, d, _1, _2) f(d, _1) f(d, _2) 
+#define M_MAP2I_3(f, d, _1, _2, _3) f(d, _1) f(d, _2) f(d, _3) 
+
+#define M_CROSS_MAP(f, alist, blist)    M_CROSSI_MAP1(f, alist, blist)
+#define M_CROSSI_MAP1(f, alist, blist)  M_C(M_CROSSI_MAP1_, M_NARGS alist)(f, blist, M_ID alist)
+#define M_CROSSI_MAP1_1(...) M_CROSSI_MAP1_1b(__VA_ARGS__)
+#define M_CROSSI_MAP1_1b(f, blist, a1) M_MAP2(f, a1, M_ID blist) 
+#define M_CROSSI_MAP1_2(...) M_CROSSI_MAP1_2b(__VA_ARGS__)
+#define M_CROSSI_MAP1_2b(f, blist, a1, a2) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) 
+#define M_CROSSI_MAP1_3(...) M_CROSSI_MAP1_3b(__VA_ARGS__)
+#define M_CROSSI_MAP1_3b(f, blist, a1, a2, a3) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) 
+
+#define M_COMMA_P(...)              M_RETI_ARG4(__VA_ARGS__, 1, 1, 0, useless)
+
+#define M_PARENTHESISI_DETECT1(...)  ,
+#define M_PARENTHESIS_P(...)                                              \
+  M_AND3(M_COMMA_P(M_PARENTHESISI_DETECT1 __VA_ARGS__),                   \
+         M_INV(M_COMMA_P(__VA_ARGS__)),                                   \
+         M_EMPTY_P(M_EAT __VA_ARGS__))
+
+#define M_EMPTYI_DETECT(...)        ,
+#define M_EMPTYI_P_C1(...)          M_COMMA_P(M_EMPTYI_DETECT __VA_ARGS__ () )
+#define M_EMPTYI_P_C2(...)          M_COMMA_P(M_EMPTYI_DETECT __VA_ARGS__)
+#define M_EMPTYI_P_C3(...)          M_COMMA_P(__VA_ARGS__ () )
+#define M_EMPTY_P(...)              M_AND(M_EMPTYI_P_C1(__VA_ARGS__), M_INV(M_OR3(M_EMPTYI_P_C2(__VA_ARGS__), M_COMMA_P(__VA_ARGS__),M_EMPTYI_P_C3(__VA_ARGS__))))
+
+#define M_G3N_IS_PRESENT(num)                                              \
+  M_IF(M_PARENTHESIS_P(M_C(M_GENERIC_ORG_, num)() ))(M_DEFERRED_COMMA M_ID M_C(M_GENERIC_ORG_, num)(), )
+
+#define M_G3N_IS_PRESENT2(el1, num)                                        \
+  M_IF(M_PARENTHESIS_P(M_C4(M_GENERIC_ORG_, el1, _COMP_, num)()))(M_DEFERRED_COMMA M_APPLY(M_C3, el1, _COMP_, M_ID M_C4(M_GENERIC_ORG_, el1, _COMP_, num)()), )
+
+#define FLT1 (GENTYPE(float), TYPE(float) )
+
+#define M_GENERIC_ORG_2() (USER)
+#define M_GENERIC_ORG_USER_COMP_1() (CORE)
+#define M_GENERIC_ORG_USER_COMP_CORE_OPLIST_6() FLT1
+
+// Shall expand to ", USER"
+M_MAP(M_G3N_IS_PRESENT, 1, 2, 3)
+// Shall expand to ", USER_COMP_CORE"
+M_CROSS_MAP(M_G3N_IS_PRESENT2, (MLIB , USER), ( 1, 2, 3 ) )
+// Shall expand to ", USER_COMP_CORE" (composition of both) [fail]
+M_CROSS_MAP(M_G3N_IS_PRESENT2, (MLIB M_MAP(M_G3N_IS_PRESENT, 1, 2, 3)), ( 1, 2, 3 ) )
diff --git a/tests/pp/23.expect b/tests/pp/23.expect
new file mode 100644
index 000000000..303e410ad
--- /dev/null
+++ b/tests/pp/23.expect
@@ -0,0 +1,3 @@
+ , USER
+ , USER_COMP_CORE
+ , USER_COMP_CORE
diff --git a/tests/tcctest.c b/tests/tcctest.c
index 8db76d5d1..a982aba68 100644
--- a/tests/tcctest.c
+++ b/tests/tcctest.c
@@ -21,14 +21,19 @@
 typedef __SIZE_TYPE__ uintptr_t;
 #endif
 
-#if defined(_WIN32) || \
-    (defined(__arm__) && \
-     (defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)))
+#if defined(_WIN32) \
+    || (defined(__arm__) \
+        && (defined(__FreeBSD__) \
+         || defined(__OpenBSD__) \
+         || defined(__NetBSD__) \
+         || defined __ANDROID__))
 #define LONG_LONG_FORMAT "%lld"
 #define ULONG_LONG_FORMAT "%llu"
+#define XLONG_LONG_FORMAT "%llx"
 #else
 #define LONG_LONG_FORMAT "%Ld"
 #define ULONG_LONG_FORMAT "%Lu"
+#define XLONG_LONG_FORMAT "%Lx"
 #endif
 
 // MinGW has 80-bit rather than 64-bit long double which isn't compatible with TCC or MSVC
@@ -78,6 +83,9 @@ typedef __SIZE_TYPE__ uintptr_t;
 #include incname
 #include stringify(funnyname)
 
+int puts(const char *s);
+void *alloca(size_t size);
+
 int fib(int n);
 void num(int n);
 void forward_ref(void);
@@ -549,11 +557,17 @@ void goto_test()
 {
     int i;
     static void *label_table[3] = { &&label1, &&label2, &&label3 };
+    struct {
+        int bla;
+        /* This needs to parse as typedef, not as label.  */
+        typedef_and_label : 32;
+    } y = {1};
 
     printf("\ngoto:\n");
     i = 0;
+    /* This is a normal decl.  */
+    typedef_and_label x;
     /* This needs to parse as label, not as start of decl.  */
- typedef_and_label x;
  typedef_and_label:
  s_loop:
     if (i >= 10) 
@@ -1206,6 +1220,13 @@ static unsigned int calc_vm_flags(unsigned int prot)
   return prot_bits;
 }
 
+enum cast_enum { FIRST, LAST };
+
+static void tst_cast(enum cast_enum ce)
+{
+    printf("%d\n", ce);
+}
+
 void bool_test()
 {
     int *s, a, b, t, f, i;
@@ -1251,6 +1272,12 @@ void bool_test()
     printf("exp=%d\n", f == (32 <= a && a <= 3));
     printf("r=%d\n", (t || f) + (t && f));
 
+    /* check that types of casted &&/|| are preserved (here the unsignedness) */
+    t = 1;
+    printf("type of bool: %d\n", (int) ( (~ ((unsigned int) (t && 1))) / 2) );
+    tst_cast(t >= 0 ? FIRST : LAST);
+
+    printf("type of cond: %d\n", (~(t ? 0U : (unsigned int)0)) / 2 );
     /* test ? : cast */
     {
         int aspect_on;
@@ -1404,6 +1431,13 @@ void optimize_out_test(void)
       undefined_function();
   }
 
+  if (0) {
+      switch (defined_function()) {
+          case 0: undefined_function(); break;
+          default: undefined_function(); break;
+      }
+  }
+
   /* Leave the "if(1)return; printf()" in this order and last in the function */
   if (1)
     return;
@@ -1516,8 +1550,6 @@ struct structa1 {
     char f2;
 };
 
-struct structa1 ssta1;
-
 void struct_assign_test1(struct structa1 s1, int t, float f)
 {
     printf("%d %d %d %f\n", s1.f1, s1.f2, t, f);
@@ -1535,22 +1567,12 @@ void struct_assign_test(void)
     struct S {
       struct structa1 lsta1, lsta2;
       int i;
-    } s, *ps;
+    } s = {{1,2}, {3,4}}, *ps;
     
     ps = &s;
     ps->i = 4;
-#if 0
-    s.lsta1.f1 = 1;
-    s.lsta1.f2 = 2;
-    printf("%d %d\n", s.lsta1.f1, s.lsta1.f2);
-    s.lsta2 = s.lsta1;
-    printf("%d %d\n", s.lsta2.f1, s.lsta2.f2);
-#else
-    s.lsta2.f1 = 1;
-    s.lsta2.f2 = 2;
-#endif
+
     struct_assign_test1(ps->lsta2, 3, 4.5);
-    
     printf("before call: %d %d\n", s.lsta2.f1, s.lsta2.f2);
     ps->lsta2 = struct_assign_test2(ps->lsta2, ps->i);
     printf("after call: %d %d\n", ps->lsta2.f1, ps->lsta2.f2);
@@ -1562,6 +1584,9 @@ void struct_assign_test(void)
         { struct_assign_test }
     };
     printf("%d\n", struct_assign_test == t[0].elem);
+
+    s.lsta1 = s.lsta2 = struct_assign_test2(s.lsta1, 1);
+    printf("%d %d\n", s.lsta1.f1, s.lsta1.f2);
 }
 
 /* casts to short/char */
@@ -2271,7 +2296,7 @@ double ftab1[3] = { 1.2, 3.4, -5.6 };
 
 void float_test(void)
 {
-#if !defined(__arm__) || defined(__ARM_PCS_VFP)
+#if !defined(__arm__) || defined(__ARM_PCS_VFP) || defined __ANDROID__
     volatile float fa, fb;
     volatile double da, db;
     int a;
@@ -2537,7 +2562,7 @@ void longlong_test(void)
     b = 0x12345678;
     a = -1;
     c = a + b;
-    printf("%Lx\n", c);
+    printf(XLONG_LONG_FORMAT"\n", c);
 #endif
 
     /* long long reg spill test */
@@ -2864,7 +2889,8 @@ void relocation_test(void)
     printf("*rel2=%d\n", *rel2);
     fptr();
 #ifdef __LP64__
-    printf("pa_symbol=0x%lx\n", __pa_symbol() >> 63);
+    // compare 'addend' displacement versus conventional arithmetics
+    printf("pa_symbol: %d\n", (long)&rel1 == __pa_symbol() - 0x80000000);
 #endif
 }
 
@@ -2888,7 +2914,15 @@ int cmpfn();
 
 void old_style_function_test(void)
 {
+#if CC_NAME == CC_clang
+    /* recent clang versions (at least 15.0) raise an error:
+       incompatible pointer to integer conversion passing 'void *'
+       For the purpose of this test, pass 1 instead.
+     */
+    old_style_f(1, 2, 3.0);
+#else
     old_style_f((void *)1, 2, 3.0);
+#endif
     decl_func1(NULL);
     decl_func2(NULL);
 }
@@ -2967,6 +3001,7 @@ void c99_vla_test_2(int d, int h, int w)
     int x, y, z;
     int (*arr)[h][w] = malloc(sizeof(int) * d*h*w);
     int c = 1;
+    static int (*starr)[h][w];
 
     printf("Test C99 VLA 6 (pointer)\n");
 
@@ -2986,13 +3021,15 @@ void c99_vla_test_2(int d, int h, int w)
         }
         puts("");
     }
+    starr = &arr[1];
     printf(" sizes : %d %d %d\n"
            " pdiff : %d %d\n"
-           " tests : %d %d\n",
+           " tests : %d %d %d\n",
         sizeof (*arr), sizeof (*arr)[0], sizeof (*arr)[0][0],
         arr + 2 - arr, *arr + 3 - *arr,
         0 == sizeof (*arr + 1) - sizeof arr,
-        0 == sizeof sizeof *arr - sizeof arr
+        0 == sizeof sizeof *arr - sizeof arr,
+        starr[0][2][3] == arr[1][2][3]
         );
     free (arr);
 }
@@ -3017,9 +3054,9 @@ void c99_vla_test_3d(int s, int arr[2][3][s])
     printf ("%d\n", arr[1][2][3]);
 }
 
-void c99_vla_test_3e(int s, int arr[][3][s])
+void c99_vla_test_3e(int s, int arr[][3][--s])
 {
-    printf ("%d\n", arr[1][2][3]);
+    printf ("%d %d\n", s, arr[1][2][3]);
 }
 
 void c99_vla_test_3(void)
@@ -3027,12 +3064,12 @@ void c99_vla_test_3(void)
     int a[2][3][4];
 
     memset (a, 0, sizeof(a));
-    a[1][2][3] = 2;
+    a[1][2][3] = 123;
     c99_vla_test_3a(a);
     c99_vla_test_3b(2, a);
     c99_vla_test_3c(3, a);
     c99_vla_test_3d(4, a);
-    c99_vla_test_3e(4, a);
+    c99_vla_test_3e(5, a);
 }
 
 void c99_vla_test(void)
@@ -3236,10 +3273,12 @@ void local_label_test(void)
 /* inline assembler test */
 #if defined(__i386__) || defined(__x86_64__)
 
+typedef __SIZE_TYPE__ word;
+
 /* from linux kernel */
 static char * strncat1(char * dest,const char * src,size_t count)
 {
-long d0, d1, d2, d3;
+word d0, d1, d2, d3;
 __asm__ __volatile__(
 	"repne\n\t"
 	"scasb\n\t"
@@ -3261,7 +3300,7 @@ return dest;
 
 static char * strncat2(char * dest,const char * src,size_t count)
 {
-long d0, d1, d2, d3;
+word d0, d1, d2, d3;
 __asm__ __volatile__(
 	"repne scasb\n\t" /* one-line repne prefix + string op */
 	"dec %1\n\t"
@@ -3282,7 +3321,7 @@ return dest;
 
 static inline void * memcpy1(void * to, const void * from, size_t n)
 {
-size_t d0, d1, d2;
+word d0, d1, d2;
 __asm__ __volatile__(
 	"rep ; movsl\n\t"
 	"testb $2,%b4\n\t"
@@ -3293,14 +3332,14 @@ __asm__ __volatile__(
 	"movsb\n"
 	"2:"
 	: "=&c" (d0), "=&D" (d1), "=&S" (d2)
-	:"0" (n/4), "q" (n),"1" ((size_t) to),"2" ((size_t) from)
+	:"0" (n/4), "q" (n),"1" ((word) to),"2" ((word) from)
 	: "memory");
 return (to);
 }
 
 static inline void * memcpy2(void * to, const void * from, size_t n)
 {
-size_t d0, d1, d2;
+word d0, d1, d2;
 __asm__ __volatile__(
 	"rep movsl\n\t"  /* one-line rep prefix + string op */
 	"testb $2,%b4\n\t"
@@ -3311,7 +3350,7 @@ __asm__ __volatile__(
 	"movsb\n"
 	"2:"
 	: "=&c" (d0), "=&D" (d1), "=&S" (d2)
-	:"0" (n/4), "q" (n),"1" ((size_t) to),"2" ((size_t) from)
+	:"0" (n/4), "q" (n),"1" ((word) to),"2" ((word) from)
 	: "memory");
 return (to);
 }
@@ -3380,12 +3419,12 @@ struct struct123 {
     int b;
 };
 struct struct1231 {
-    unsigned long addr;
+    word addr;
 };
 
-unsigned long mconstraint_test(struct struct1231 *r)
+word mconstraint_test(struct struct1231 *r)
 {
-    unsigned long ret;
+    word ret;
     unsigned int a[2];
     a[0] = 0;
     __asm__ volatile ("lea %2,%0; movl 4(%0),%k0; addl %2,%k0; movl $51,%2; movl $52,4%2; movl $63,%1"
@@ -3407,11 +3446,11 @@ int fls64(unsigned long long x)
 
 void other_constraints_test(void)
 {
-    unsigned long ret;
+    word ret;
     int var;
-#ifndef _WIN64
+#if CC_NAME != CC_clang
     __asm__ volatile ("mov %P1,%0" : "=r" (ret) : "p" (&var));
-    printf ("oc1: %d\n", ret == (unsigned long)&var);
+    printf ("oc1: %d\n", ret == (word)&var);
 #endif
 }
 
@@ -3495,6 +3534,7 @@ void asm_local_label_diff (void)
   printf ("asm_local_label_diff: %d %d\n", alld_stuff[0], alld_stuff[1]);
 }
 #endif
+#endif
 
 /* This checks that static local variables are available from assembler.  */
 void asm_local_statics (void)
@@ -3503,7 +3543,6 @@ void asm_local_statics (void)
   asm("incl %0" : "+m" (localint));
   printf ("asm_local_statics: %d\n", localint);
 }
-#endif
 
 static
 unsigned int set;
@@ -3518,7 +3557,7 @@ void fancy_copy2 (unsigned *in, unsigned *out)
   asm volatile ("mov %0,(%1)" : : "r" (*in), "r" (out) : "memory");
 }
 
-#if defined __x86_64__ && !defined _WIN64
+#if defined __x86_64__
 void clobber_r12(void)
 {
     asm volatile("mov $1, %%r12" ::: "r12");
@@ -3527,9 +3566,9 @@ void clobber_r12(void)
 
 void test_high_clobbers_really(void)
 {
-#if defined __x86_64__ && !defined _WIN64
-    register long val asm("r12");
-    long val2;
+#if defined __x86_64__
+    register word val asm("r12");
+    word val2;
     /* This tests if asm clobbers correctly save/restore callee saved
        registers if they are clobbered and if it's the high 8 x86-64
        registers.  This is fragile for GCC as the constraints do not
@@ -3543,8 +3582,8 @@ void test_high_clobbers_really(void)
 
 void test_high_clobbers(void)
 {
-#if defined __x86_64__ && !defined _WIN64
-    long x1, x2;
+#if defined __x86_64__
+    word x1, x2;
     asm volatile("mov %%r12,%0" :: "m" (x1)); /* save r12 */
     test_high_clobbers_really();
     asm volatile("mov %%r12,%0" :: "m" (x2)); /* new r12 */
@@ -3610,7 +3649,7 @@ void trace_console(long len, long len2)
 
 void test_asm_dead_code(void)
 {
-  long rdi;
+  word rdi;
   /* Try to make sure that xdi contains a zero, and hence will
      lead to a segfault if the next asm is evaluated without
      arguments being set up.  */
@@ -3631,7 +3670,7 @@ void test_asm_dead_code(void)
 
 void test_asm_call(void)
 {
-#if defined __x86_64__ && !defined _WIN64
+#if defined __x86_64__ && !defined _WIN64  && !defined(__APPLE__)
   static char str[] = "PATH";
   char *s;
   /* This tests if a reference to an undefined symbol from an asm
@@ -3643,10 +3682,8 @@ void test_asm_call(void)
      tested here).  */
   /* two pushes so stack remains aligned */
   asm volatile ("push %%rdi; push %%rdi; mov %0, %%rdi;"
-#if 1 && !defined(__TINYC__) && (defined(__PIC__) || defined(__PIE__)) && !defined(__APPLE__)
+#if 1 && !defined(__TINYC__) && (defined(__PIC__) || defined(__PIE__))
 		"call getenv@plt;"
-#elif defined(__APPLE__)
-                "call _getenv;"
 #else
 		"call getenv;"
 #endif
@@ -3712,12 +3749,12 @@ void asm_test(void)
     char buf[128];
     unsigned int val, val2;
     struct struct123 s1;
-    struct struct1231 s2 = { (unsigned long)&s1 };
+    struct struct1231 s2 = { (word)&s1 };
     /* Hide the outer base_func, but check later that the inline
        asm block gets the outer one.  */
     int base_func = 42;
     void override_func3 (void);
-    unsigned long asmret;
+    word asmret;
 #ifdef BOOL_ISOC99
     _Bool somebool;
 #endif
@@ -3768,8 +3805,8 @@ void asm_test(void)
     printf("asmstr: %s\n", get_asm_string());
     asm_local_label_diff();
 #endif
-    asm_local_statics();
 #endif
+    asm_local_statics();
 #ifndef __clang__
     /* clang can't deal with the type change */
     /* Check that we can also load structs of appropriate layout
@@ -3821,6 +3858,40 @@ int constant_p_var;
 
 int func(void);
 
+
+/* __builtin_clz and __builtin_ctz return random values for 0 */
+static void builtin_test_bits(unsigned long long x, int cnt[])
+{
+#if GCC_MAJOR >= 4
+    cnt[0] += __builtin_ffs(x);
+    cnt[1] += __builtin_ffsl(x);
+    cnt[2] += __builtin_ffsll(x);
+
+    if ((unsigned int) x) cnt[3] += __builtin_clz(x);
+    if ((unsigned long) x) cnt[4] += __builtin_clzl(x);
+    if ((unsigned long long) x) cnt[5] += __builtin_clzll(x);
+
+    if ((unsigned int) x) cnt[6] += __builtin_ctz(x);
+    if ((unsigned long) x) cnt[7] += __builtin_ctzl(x);
+    if ((unsigned long long) x) cnt[8] += __builtin_ctzll(x);
+
+#if CC_NAME != CC_clang || GCC_MAJOR >= 11
+/* Apple clang 10 does not have __builtin_clrsb[l[l]] */
+    cnt[9] += __builtin_clrsb(x);
+    cnt[10] += __builtin_clrsbl(x);
+    cnt[11] += __builtin_clrsbll(x);
+#endif
+
+    cnt[12] += __builtin_popcount(x);
+    cnt[13] += __builtin_popcountl(x);
+    cnt[14] += __builtin_popcountll(x);
+
+    cnt[15] += __builtin_parity(x);
+    cnt[16] += __builtin_parityl(x);
+    cnt[17] += __builtin_parityll(x);
+#endif
+}
+
 void builtin_test(void)
 {
     short s;
@@ -3861,6 +3932,7 @@ void builtin_test(void)
 #endif
     printf("res9 = %d\n", __builtin_constant_p("hi"));
     printf("res10 = %d\n", __builtin_constant_p(func()));
+    printf("res11 = %d\n", __builtin_constant_p((i++, 7)));
     s = 1;
     ll = 2;
     i = __builtin_choose_expr (1 != 0, ll, s);
@@ -3873,9 +3945,26 @@ void builtin_test(void)
     printf("bce: %d\n", i);
 
     //printf("bera: %p\n", __builtin_extract_return_addr((void*)43));
+
+    {
+	int cnt[18];
+	unsigned long long r = 0;
+
+	memset(cnt, 0, sizeof(cnt));
+	builtin_test_bits(0, cnt);
+	builtin_test_bits(0xffffffffffffffffull, cnt);
+        for (i = 0; i < 64; i++)
+	    builtin_test_bits(1ull << i, cnt);
+        for (i = 0; i < 1000; i++) {
+	    r = 0x5851f42d4c957f2dull * r + 0x14057b7ef767814full;
+	    builtin_test_bits(r, cnt);
+	}
+	for (i = 0; i < 18; i++)
+	    printf ("%d %d\n", i, cnt[i]);
+    }
 }
 
-#ifdef _WIN32
+#if defined _WIN32
 void weak_test(void) {}
 #else
 extern int __attribute__((weak)) weak_f1(void);
@@ -4251,15 +4340,19 @@ void func_arg_test(void)
 #define CORRECT_CR_HANDLING
 
 /* deprecated and no longer supported in gcc 3.3 */
+/* no longer supported by default in TinyCC */
 #ifdef __TINYC__
-# define ACCEPT_CR_IN_STRINGS
+/* # define ACCEPT_LF_IN_STRINGS */
 #endif
 
+#define	tcc_test()
+
 /* keep this as the last test because GCC messes up line-numbers
    with the ^L^K^M characters below */
 void whitespace_test(void)
 {
     char *str;
+    int tcc_test = 1;
 
 
#if 1
     pri\
@@ -4276,7 +4369,7 @@ ntf("aaa=%d\n", 3);
 \
 ntf("min=%d\n", 4);
 
-#ifdef ACCEPT_CR_IN_STRINGS
+#ifdef ACCEPT_LF_IN_STRINGS
     printf("len1=%d\n", strlen("
 "));
 #ifdef CORRECT_CR_HANDLING
@@ -4288,7 +4381,7 @@ ntf("min=%d\n", 4);
 "));
 #else
     printf("len1=1\nlen1=1 str[0]=10\nlen1=3\n");
-#endif /* ACCEPT_CR_IN_STRINGS */
+#endif /* ACCEPT_LF_IN_STRINGS */
 
 #ifdef __LINE__
     printf("__LINE__ defined\n");
@@ -4302,6 +4395,18 @@ ntf("min=%d\n", 4);
 #line 2222 "test"
     printf("__LINE__=%d __FILE__=%s\n", __LINE__, __FILE__);
 #endif
+
+    printf("\\
+"12\\
+063\\
+n 456\"\n");
+
+    printf ("%d\n",
+#if 1
+	    tcc_test
+#endif
+            );
+
 }
 
 #define RUN(test) puts("---- " #test " ----"), test(), puts("")
diff --git a/tests/tests2/104+_inline.c b/tests/tests2/104+_inline.c
index 1209fd466..3c48eb83d 100644
--- a/tests/tests2/104+_inline.c
+++ b/tests/tests2/104+_inline.c
@@ -1,7 +1,7 @@
 
 #define GOT(f) \
     __attribute__((weak)) void f(void); \
-    printf("%d %s\n", !!f, #f);
+    printf("%d %s\n", !!((__SIZE_TYPE__)f & ~0u), #f);
 
 int printf(const char*, ...);
 
diff --git a/tests/tests2/112_backtrace.c b/tests/tests2/112_backtrace.c
index 8489bd32a..0b596d080 100644
--- a/tests/tests2/112_backtrace.c
+++ b/tests/tests2/112_backtrace.c
@@ -156,8 +156,18 @@ int main()
 #elif defined test_bcheck_125
     strcat(&a[3], &a[0]);
 #elif defined test_bcheck_126
-    strchr(&b[0], 'a');
+    strncat(&a[7], &a[0], 3);
 #elif defined test_bcheck_127
+    strncat(&a[0], &b[3], 8);
+#elif defined test_bcheck_128
+    strncat(&a[0], &a[4], 3);
+#elif defined test_bcheck_129
+    strncat(&a[3], &a[0], 10);
+#elif defined test_bcheck_130
+    strchr(&b[0], 'a');
+#elif defined test_bcheck_131
+    strrchr(&b[0], 'a');
+#elif defined test_bcheck_132
     free(strdup(&b[0]));
 #endif
 }
diff --git a/tests/tests2/112_backtrace.expect b/tests/tests2/112_backtrace.expect
index 68986c6e0..ec2c6b8e5 100644
--- a/tests/tests2/112_backtrace.expect
+++ b/tests/tests2/112_backtrace.expect
@@ -134,9 +134,29 @@
 [returns 255]
 
 [test_bcheck_126]
-112_backtrace.c:159: at main: BCHECK: invalid pointer ........, size 0x? in strchr
+112_backtrace.c:159: at main: BCHECK: invalid pointer ........, size 0x? in strncat dest
 [returns 255]
 
 [test_bcheck_127]
-112_backtrace.c:161: at main: BCHECK: invalid pointer ........, size 0x? in strdup
+112_backtrace.c:161: at main: BCHECK: invalid pointer ........, size 0x? in strncat dest
+[returns 255]
+
+[test_bcheck_128]
+112_backtrace.c:163: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strncat
+[returns 255]
+
+[test_bcheck_129]
+112_backtrace.c:165: at main: BCHECK: overlapping regions ........(0x?), ........(0x?) in strncat
+[returns 255]
+
+[test_bcheck_130]
+112_backtrace.c:167: at main: BCHECK: invalid pointer ........, size 0x? in strchr
+[returns 255]
+
+[test_bcheck_131]
+112_backtrace.c:169: at main: BCHECK: invalid pointer ........, size 0x? in strrchr
+[returns 255]
+
+[test_bcheck_132]
+112_backtrace.c:171: at main: BCHECK: invalid pointer ........, size 0x? in strdup
 [returns 255]
diff --git a/tests/tests2/117_builtins.c b/tests/tests2/117_builtins.c
index 4da28ff58..b57a73ed8 100644
--- a/tests/tests2/117_builtins.c
+++ b/tests/tests2/117_builtins.c
@@ -11,7 +11,7 @@ main (void)
   char tmp[100];
   int r = 0;
 
-#if defined __BOUNDS_CHECKING_ON || defined BC_ON
+#if defined __TCC_BCHECK__
   printf("BOUNDS ON:\n");
 #else
   printf("BOUNDS OFF:\n");
@@ -60,12 +60,20 @@ main (void)
   r = (__builtin_memcmp (p, str, sizeof(str)));
   printf(" 11:%d", !r);
 
-  r = (__builtin_strchr(p, 'z') != &p[25]);
+  tmp[0] = '\0';
+  p = __builtin_strncat(tmp, str, __builtin_strlen(str));
+  r = (__builtin_memcmp (p, str, sizeof(str)));
   printf(" 12:%d", !r);
 
+  r = (__builtin_strchr(p, 'z') != &p[25]);
+  printf(" 13:%d", !r);
+
+  r = (__builtin_strrchr(p, 'z') != &p[25]);
+  printf(" 14:%d", !r);
+
   p = __builtin_strdup (str);
   r = (__builtin_memcmp (p, str, sizeof(str)));
-  printf(" 13:%d", !r);
+  printf(" 15:%d", !r);
   __builtin_free(p);
 
   p = __builtin_malloc (100);
diff --git a/tests/tests2/117_builtins.expect b/tests/tests2/117_builtins.expect
index 776e4329e..f2c78ba79 100644
--- a/tests/tests2/117_builtins.expect
+++ b/tests/tests2/117_builtins.expect
@@ -1,4 +1,4 @@
 BOUNDS OFF:
- 1:1 2:1 3:1 4:1 5:1 6:1 7:1 8:1 9:1 10:1 11:1 12:1 13:1
+ 1:1 2:1 3:1 4:1 5:1 6:1 7:1 8:1 9:1 10:1 11:1 12:1 13:1 14:1 15:1
 BOUNDS ON:
- 1:1 2:1 3:1 4:1 5:1 6:1 7:1 8:1 9:1 10:1 11:1 12:1 13:1
+ 1:1 2:1 3:1 4:1 5:1 6:1 7:1 8:1 9:1 10:1 11:1 12:1 13:1 14:1 15:1
diff --git a/tests/tests2/119_random_stuff.c b/tests/tests2/119_random_stuff.c
index 95097b82d..5530c096c 100644
--- a/tests/tests2/119_random_stuff.c
+++ b/tests/tests2/119_random_stuff.c
@@ -88,6 +88,37 @@ void tst_cast(void)
   printf ("schar to ushort cast: %x\n", r);
 }
 
+struct {
+    int (*print)(const char *format, ...);
+} tst_indir = {
+    printf
+};
+
+void tst_indir_func(void)
+{
+    tst_indir.print("tst_indir_func %d\n", 10);
+}
+
+struct V {
+  int x, y, z;
+};
+
+struct V vec(void)
+{
+  return (struct V) { 1, 2, 3 };
+}
+
+void func(float f, struct V v)
+{
+  printf("%g\n", f);
+}
+
+void tst_struct_return_align(void)
+{
+  float d = 5.0f;
+  func(d, vec());
+}
+
 int
 main (void)
 {
@@ -105,4 +136,6 @@ main (void)
   tst_compare();
   tst_pack();
   tst_cast();
+  tst_indir_func();
+  tst_struct_return_align();
 }
diff --git a/tests/tests2/119_random_stuff.expect b/tests/tests2/119_random_stuff.expect
index 0ad779eab..02ce2282e 100644
--- a/tests/tests2/119_random_stuff.expect
+++ b/tests/tests2/119_random_stuff.expect
@@ -3,3 +3,5 @@ tst_adr 5
 tst_compare: ok
 tst_pack: j.f = 5, i.f = 5
 schar to ushort cast: ffff0033
+tst_indir_func 10
+5
diff --git a/tests/tests2/122_vla_reuse.c b/tests/tests2/122_vla_reuse.c
index d894af87a..feb47de50 100644
--- a/tests/tests2/122_vla_reuse.c
+++ b/tests/tests2/122_vla_reuse.c
@@ -12,7 +12,7 @@ main (void)
     int x[n % 100 + 1];
     if (first == 0) {
         if (&x[0] != p[n % 100 + 1]) {
-            printf ("ERROR: %d %p $p\n", &x[0], p[n % 100 + 1]);
+            printf ("ERROR: %p %p\n", &x[0], p[n % 100 + 1]);
             return(1);
         }
     }
diff --git a/tests/tests2/124_atomic_counter.c b/tests/tests2/124_atomic_counter.c
index a817fc268..67a500a7c 100644
--- a/tests/tests2/124_atomic_counter.c
+++ b/tests/tests2/124_atomic_counter.c
@@ -6,7 +6,7 @@
 #include <stdatomic.h>
 
 #define NR_THREADS 16
-#define NR_STEPS   ((uint32_t)UINT16_MAX * 4)
+#define NR_STEPS   ((uint32_t)UINT16_MAX)
 
 #define BUG_ON(COND) \
     do { \
@@ -14,14 +14,34 @@
             abort(); \
     } while (0)
 
+#if defined __x86_64__ || defined __aarch64__ || defined __riscv
+#define HAS_64BITS
+#endif
+
+typedef struct {
+    atomic_flag flag;
+    atomic_uchar uc;
+    atomic_ushort us;
+    atomic_uint ui;
+#ifdef HAS_64BITS
+    atomic_size_t ul;
+#endif
+} counter_type;
+
 static
 void *adder_simple(void *arg)
 {
     size_t step;
-    atomic_size_t *counter = arg;
+    counter_type *counter = arg;
 
-    for (step = 0; step < NR_STEPS; ++step)
-        atomic_fetch_add_explicit(counter, 1, memory_order_relaxed);
+    for (step = 0; step < NR_STEPS; ++step) {
+        atomic_fetch_add_explicit(&counter->uc, 1, memory_order_relaxed);
+        atomic_fetch_add_explicit(&counter->us, 1, memory_order_relaxed);
+        atomic_fetch_add_explicit(&counter->ui, 1, memory_order_relaxed);
+#ifdef HAS_64BITS
+        atomic_fetch_add_explicit(&counter->ul, 1, memory_order_relaxed);
+#endif
+    }
 
     return NULL;
 }
@@ -30,16 +50,60 @@ static
 void *adder_cmpxchg(void *arg)
 {
     size_t step;
-    atomic_size_t *counter = arg;
+    counter_type *counter = arg;
 
     for (step = 0; step < NR_STEPS; ++step) {
-        size_t xchg;
-        size_t cmp = atomic_load_explicit(counter, memory_order_relaxed);
+        unsigned char xchgc;
+        unsigned short xchgs;
+        unsigned int xchgi;
+#ifdef HAS_64BITS
+        size_t xchgl;
+#endif
+        unsigned char cmpc = atomic_load_explicit(&counter->uc, memory_order_relaxed);
+        unsigned short cmps = atomic_load_explicit(&counter->us, memory_order_relaxed);
+        unsigned int cmpi = atomic_load_explicit(&counter->ui, memory_order_relaxed);
+#ifdef HAS_64BITS
+        size_t cmpl = atomic_load_explicit(&counter->ul, memory_order_relaxed);
+#endif
 
         do {
-            xchg = (cmp + 1);
-        } while (!atomic_compare_exchange_strong_explicit(counter,
-            &cmp, xchg, memory_order_relaxed, memory_order_relaxed));
+            xchgc = (cmpc + 1);
+        } while (!atomic_compare_exchange_strong_explicit(&counter->uc,
+            &cmpc, xchgc, memory_order_relaxed, memory_order_relaxed));
+        do {
+            xchgs = (cmps + 1);
+        } while (!atomic_compare_exchange_strong_explicit(&counter->us,
+            &cmps, xchgs, memory_order_relaxed, memory_order_relaxed));
+        do {
+            xchgi = (cmpi + 1);
+        } while (!atomic_compare_exchange_strong_explicit(&counter->ui,
+            &cmpi, xchgi, memory_order_relaxed, memory_order_relaxed));
+#ifdef HAS_64BITS
+        do {
+            xchgl = (cmpl + 1);
+        } while (!atomic_compare_exchange_strong_explicit(&counter->ul,
+            &cmpl, xchgl, memory_order_relaxed, memory_order_relaxed));
+#endif
+    }
+
+    return NULL;
+}
+
+static
+void *adder_test_and_set(void *arg)
+{
+    size_t step;
+    counter_type *counter = arg;
+
+    for (step = 0; step < NR_STEPS; ++step) {
+        while (atomic_flag_test_and_set(&counter->flag));
+        ++counter->uc;
+        ++counter->us;
+        ++counter->ui;
+#ifdef HAS_64BITS
+        ++counter->ul;
+#endif
+        atomic_flag_clear(&counter->flag);
     }
 
     return NULL;
@@ -49,10 +113,16 @@ static
 void atomic_counter_test(void *(*adder)(void *arg))
 {
     size_t index;
-    atomic_size_t counter;
+    counter_type counter;
     pthread_t thread[NR_THREADS];
 
-    atomic_init(&counter, 0);
+    atomic_flag_clear(&counter.flag);
+    atomic_init(&counter.uc, 0);
+    atomic_init(&counter.us, 0);
+    atomic_init(&counter.ui, 0);
+#ifdef HAS_64BITS
+    atomic_init(&counter.ul, 0);
+#endif
 
     for (index = 0; index < NR_THREADS; ++index)
         BUG_ON(pthread_create(&thread[index], NULL, adder, (void *)&counter));
@@ -60,7 +130,13 @@ void atomic_counter_test(void *(*adder)(void *arg))
     for (index = 0; index < NR_THREADS; ++index)
         BUG_ON(pthread_join(thread[index], NULL));
 
-    if (atomic_load(&counter) == (NR_THREADS * NR_STEPS))
+    if (atomic_load(&counter.uc) == ((NR_THREADS * NR_STEPS) & 0xffu)
+        && atomic_load(&counter.us) == ((NR_THREADS * NR_STEPS) & 0xffffu)
+        && atomic_load(&counter.ui) == (NR_THREADS * NR_STEPS)
+#ifdef HAS_64BITS
+        && atomic_load(&counter.ul) == (NR_THREADS * NR_STEPS)
+#endif
+        )
         printf("SUCCESS\n");
     else
         printf("FAILURE\n");
@@ -70,6 +146,7 @@ int main(void)
 {
     atomic_counter_test(adder_simple);
     atomic_counter_test(adder_cmpxchg);
+    atomic_counter_test(adder_test_and_set);
 
     return 0;
 }
diff --git a/tests/tests2/124_atomic_counter.expect b/tests/tests2/124_atomic_counter.expect
index 1db2652c4..21667a71d 100644
--- a/tests/tests2/124_atomic_counter.expect
+++ b/tests/tests2/124_atomic_counter.expect
@@ -1,2 +1,3 @@
 SUCCESS
 SUCCESS
+SUCCESS
diff --git a/tests/tests2/125_atomic_misc.c b/tests/tests2/125_atomic_misc.c
index 40e7cba84..2d1063169 100644
--- a/tests/tests2/125_atomic_misc.c
+++ b/tests/tests2/125_atomic_misc.c
@@ -16,6 +16,14 @@ int main()
     r = atomic_compare_exchange_strong(&a, &b, 99);
     printf("%d %d %d\n", r, a, b);
 
+    atomic_store(&a, b + 5);
+    r = atomic_exchange(&a,  33);
+    printf("%d %d %d\n", r, a, b);
+
+    atomic_store(&a, b + 10);
+    r = atomic_exchange(&a, 66);
+    printf("%d %d %d\n", r, a, b);
+
     return 0;
 }
 
@@ -50,6 +58,117 @@ int main()
     printf("%d %d %d %d\n", p.c[0], p.c[1], p.c[2], p.c[3]);
 }
 
+#elif defined test_atomic_op
+
+#define OP1(func, v, e1, e2) atomic_##func(&c, v) == e1 && c == e2
+#define OP2(func, v, e1, e2) atomic_##func(&s, v) == e1 && s == e2
+#define OP4(func, v, e1, e2) atomic_##func(&i, v) == e1 && i == e2
+#if defined __x86_64__ || defined __aarch64__ || defined __riscv
+#define OP8(func, v, e1, e2) atomic_##func(&l, v) == e1 && l == e2
+#define HAS_64BITS
+#else
+#define OP8(func, v, e1, e2) 1
+#endif
+
+#define OP(func, v, e1, e2) printf ("%s: %s\n", #func,                        \
+                                    OP1(func,v,e1,e2) && OP2(func,v,e1,e2) && \
+                                    OP4(func,v,e1,e2) && OP8(func,v,e1,e2)    \
+                                    ? "SUCCESS" : "FAIL");
+ 
+int main()
+{
+    atomic_char c;
+    atomic_short s;
+    atomic_int i;
+#ifdef HAS_64BITS
+    atomic_size_t l;
+#endif
+
+    atomic_init(&c, 0);
+    atomic_init(&s, 0);
+    atomic_init(&i, 0);
+#ifdef HAS_64BITS
+    atomic_init(&l, 0);
+#endif
+
+    OP(fetch_add, 10, 0, 10);
+    OP(fetch_sub, 5, 10, 5);
+    OP(fetch_or, 0x10, 5, 21);
+    OP(fetch_xor, 0x20, 21, 53);
+    OP(fetch_and, 0x0f, 53, 5);
+}
+
+#elif defined test_atomic_op2
+
+typedef __SIZE_TYPE__ size64_t;
+
+#define OP1(func, v, e1, e2) \
+    __atomic_##func(&c, v, __ATOMIC_SEQ_CST) == e1 && c == e2
+#define OP2(func, v, e1, e2)\
+    __atomic_##func(&s, v, __ATOMIC_SEQ_CST) == e1 && s == e2
+#define OP4(func, v, e1, e2)\
+    __atomic_##func(&i, v, __ATOMIC_SEQ_CST) == e1 && i == e2
+#if defined __x86_64__ || defined __aarch64__ || defined __riscv
+#define OP8(func, v, e1, e2)\
+    __atomic_##func(&l, v, __ATOMIC_SEQ_CST) == e1 && l == e2
+#define HAS_64BITS
+#else
+#define OP8(func, v, e1, e2) 1
+#endif
+
+#define OP(func, v, e1, e2) printf ("%s: %s\n", #func,                        \
+                                    OP1(func,v,e1,e2) && OP2(func,v,e1,e2) && \
+                                    OP4(func,v,e1,e2) && OP8(func,v,e1,e2)    \
+                                    ? "SUCCESS" : "FAIL");
+
+int main()
+{
+    signed char c;
+    short s;
+    int i;
+#ifdef HAS_64BITS
+    size64_t l;
+#endif
+
+    atomic_init(&c, 0);
+    atomic_init(&s, 0);
+    atomic_init(&i, 0);
+#ifdef HAS_64BITS
+    atomic_init(&l, 0);
+#endif
+
+    OP(fetch_add, 10, 0, 10);
+    OP(fetch_sub, 5, 10, 5);
+    OP(fetch_or, 0x10, 5, 21);
+    OP(fetch_xor, 0x20, 21, 53);
+    OP(fetch_and, 0x0f, 53, 5);
+    OP(fetch_nand, 0x01, 5, -2);
+
+    atomic_init(&c, 0);
+    atomic_init(&s, 0);
+    atomic_init(&i, 0);
+#ifdef HAS_64BITS
+    atomic_init(&l, 0);
+#endif
+
+    OP(add_fetch, 10, 10, 10);
+    OP(sub_fetch, 5, 5, 5);
+    OP(or_fetch, 0x10, 21, 21);
+    OP(xor_fetch, 0x20, 53, 53);
+    OP(and_fetch, 0x0f, 5, 5);
+    OP(nand_fetch, 0x01, -2, -2);
+}
+
+#elif defined test_atomic_thread_signal
+int main()
+{
+    int c;
+
+    atomic_thread_fence(__ATOMIC_SEQ_CST);
+    atomic_signal_fence(__ATOMIC_SEQ_CST);
+    printf ("%d\n", atomic_is_lock_free(&c));
+}
+
 #elif defined test_atomic_error_1
 int main()
 {
diff --git a/tests/tests2/125_atomic_misc.expect b/tests/tests2/125_atomic_misc.expect
index 7aa03eba5..61bd29f4e 100644
--- a/tests/tests2/125_atomic_misc.expect
+++ b/tests/tests2/125_atomic_misc.expect
@@ -1,6 +1,8 @@
 [test_atomic_compare_exchange]
 1 99 77
 0 80 80
+85 33 80
+90 66 80
 
 [test_atomic_store]
 r = 12, i = 24
@@ -11,23 +13,47 @@ r = 12, i = 24
 [test_atomic_store_struct]
 1 2 3 4
 
+[test_atomic_op]
+fetch_add: SUCCESS
+fetch_sub: SUCCESS
+fetch_or: SUCCESS
+fetch_xor: SUCCESS
+fetch_and: SUCCESS
+
+[test_atomic_op2]
+fetch_add: SUCCESS
+fetch_sub: SUCCESS
+fetch_or: SUCCESS
+fetch_xor: SUCCESS
+fetch_and: SUCCESS
+fetch_nand: SUCCESS
+add_fetch: SUCCESS
+sub_fetch: SUCCESS
+or_fetch: SUCCESS
+xor_fetch: SUCCESS
+and_fetch: SUCCESS
+nand_fetch: SUCCESS
+
+[test_atomic_thread_signal]
+1
+
 [test_atomic_error_1]
-125_atomic_misc.c:57: error: pointer expected
+125_atomic_misc.c:176: error: pointer expected
 
 [test_atomic_error_2]
-125_atomic_misc.c:64: error: integral or integer-sized pointer target type expected
+125_atomic_misc.c:183: error: integral or integer-sized pointer target type expected
 
 [test_atomic_error_3]
-125_atomic_misc.c:71: error: integral or integer-sized pointer target type expected
+125_atomic_misc.c:190: error: integral or integer-sized pointer target type expected
 
 [test_atomic_error_4]
-125_atomic_misc.c:79: error: pointer target type mismatch in argument 2
+125_atomic_misc.c:198: error: pointer target type mismatch in argument 2
 
 [test_atomic_warn_1]
-125_atomic_misc.c:87: warning: assignment makes integer from pointer without a cast
+125_atomic_misc.c:206: warning: assignment makes integer from pointer without a cast
 
 [test_atomic_warn_2]
-125_atomic_misc.c:97: warning: assignment from incompatible pointer type
+125_atomic_misc.c:216: warning: assignment from incompatible pointer type
 
 [test_atomic_warn_3]
-125_atomic_misc.c:105: warning: assignment of read-only location
+125_atomic_misc.c:224: warning: assignment of read-only location
diff --git a/tests/tests2/126_bound_global.c b/tests/tests2/126_bound_global.c
new file mode 100644
index 000000000..d3a5c3b4f
--- /dev/null
+++ b/tests/tests2/126_bound_global.c
@@ -0,0 +1,13 @@
+/* test bound checking code without -run */
+
+int arr[10];
+
+int
+main(int argc, char **argv)
+{
+  int i;
+
+  for (i = 0; i <= sizeof(arr)/sizeof(arr[0]); i++)
+        arr[i] = 0;
+  return 0;
+}
diff --git a/tests/tests2/126_bound_global.expect b/tests/tests2/126_bound_global.expect
new file mode 100644
index 000000000..fcdea9002
--- /dev/null
+++ b/tests/tests2/126_bound_global.expect
@@ -0,0 +1,2 @@
+126_bound_global.c:11: at main: BCHECK: ........ is outside of the region
+126_bound_global.c:11: at main: RUNTIME ERROR: invalid memory access
diff --git a/tests/tests2/127_asm_goto.c b/tests/tests2/127_asm_goto.c
new file mode 100644
index 000000000..de631aa32
--- /dev/null
+++ b/tests/tests2/127_asm_goto.c
@@ -0,0 +1,62 @@
+static int simple_jump(void)
+{
+  asm goto ("jmp %l[label]" : : : : label);
+  return 0;
+label:
+  return 1;
+}
+
+static int three_way_jump(int val, int *addr)
+{
+  *addr = 42;
+  asm goto ("cmp $0, %1\n\t"
+            "jg %l[larger]\n\t"
+            "jl %l[smaller]\n\t"
+            "incl %0\n\t"
+            : "=m" (*addr)
+            : "r" (val)
+            :
+            : smaller, larger);
+  return 1;
+smaller:
+  return 2;
+larger:
+  return 3;
+}
+
+static int another_jump(void)
+{
+  asm goto ("jmp %l[label]" : : : : label);
+  return 70;
+  /* Use the same label name as in simple_jump to check that
+     that doesn't confuse our C/ASM symbol tables */
+label:
+  return 71;
+}
+
+extern int printf (const char *, ...);
+int main(void)
+{
+  int i;
+  if (simple_jump () == 1)
+    printf ("simple_jump: okay\n");
+  else
+    printf ("simple_jump: wrong\n");
+  if (another_jump () == 71)
+    printf ("another_jump: okay\n");
+  else
+    printf ("another_jump: wrong\n");
+  if (three_way_jump(0, &i) == 1 && i == 43)
+    printf ("three_way_jump(0): okay\n");
+  else
+    printf ("three_way_jump(0): wrong (i=%d)\n", i);
+  if (three_way_jump(1, &i) == 3 && i == 42)
+    printf ("three_way_jump(1): okay\n");
+  else
+    printf ("three_way_jump(1): wrong (i=%d)\n", i);
+  if (three_way_jump(-1, &i) == 2 && i == 42)
+    printf ("three_way_jump(-1): okay\n");
+  else
+    printf ("three_way_jump(-1): wrong (i=%d)\n", i);
+  return 0;
+}
diff --git a/tests/tests2/127_asm_goto.expect b/tests/tests2/127_asm_goto.expect
new file mode 100644
index 000000000..e1b716996
--- /dev/null
+++ b/tests/tests2/127_asm_goto.expect
@@ -0,0 +1,5 @@
+simple_jump: okay
+another_jump: okay
+three_way_jump(0): okay
+three_way_jump(1): okay
+three_way_jump(-1): okay
diff --git a/tests/tests2/128_run_atexit.c b/tests/tests2/128_run_atexit.c
new file mode 100644
index 000000000..0748c86f1
--- /dev/null
+++ b/tests/tests2/128_run_atexit.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+
+int atexit(void (*function)(void));
+int on_exit(void (*function)(int, void *), void *arg);
+void exit(int status);
+
+void cleanup1(void)
+{
+    printf ("cleanup1\n");
+    fflush(stdout);
+}
+
+void cleanup2(void)
+{
+    printf ("cleanup2\n");
+}
+
+void cleanup3(int ret, void *arg)
+{
+    printf ("%d %s\n", ret, (char *) arg);
+}
+
+void cleanup4(int ret, void *arg)
+{
+    printf ("%d %s\n", ret, (char *) arg);
+}
+
+void __attribute((destructor)) cleanup5(void)
+{
+    printf ("cleanup5\n");
+}
+
+void test(void)
+{
+    atexit(cleanup1);
+    atexit(cleanup2);
+    on_exit(cleanup3, "cleanup3");
+    on_exit(cleanup4, "cleanup4");
+}
+
+#if defined test_128_return
+int main(int argc, char **argv)
+{
+    test();
+    return 1;
+} 
+
+#elif defined test_128_exit
+int main(int argc, char **argv)
+{
+    test();
+    exit(2);
+} 
+#endif
diff --git a/tests/tests2/128_run_atexit.expect b/tests/tests2/128_run_atexit.expect
new file mode 100644
index 000000000..3305785f9
--- /dev/null
+++ b/tests/tests2/128_run_atexit.expect
@@ -0,0 +1,15 @@
+[test_128_return]
+cleanup5
+1 cleanup4
+1 cleanup3
+cleanup2
+cleanup1
+[returns 1]
+
+[test_128_exit]
+cleanup5
+2 cleanup4
+2 cleanup3
+cleanup2
+cleanup1
+[returns 2]
diff --git a/tests/tests2/129_scopes.c b/tests/tests2/129_scopes.c
new file mode 100644
index 000000000..b63b68229
--- /dev/null
+++ b/tests/tests2/129_scopes.c
@@ -0,0 +1,43 @@
+#include <stdio.h>
+enum{ in = 0};
+#define myassert(X) do{ if(!X) printf("%d: assertion failed\n", __LINE__); }while(0)
+int main(){
+    {
+        myassert(!in);
+        if(sizeof(enum{in=1})) myassert(in);
+        myassert(!in); //OOPS
+    }
+    {
+        myassert(!in);
+        switch(sizeof(enum{in=1})) { default: myassert(in); }
+        myassert(!in); //OOPS
+    }
+    {
+        myassert(!in);
+        while(sizeof(enum{in=1})) { myassert(in); break; }
+        myassert(!in); //OOPS
+    }
+    {
+        myassert(!in);
+        do{ myassert(!in);}while(0*sizeof(enum{in=1}));
+        myassert(!in); //OOPS
+    }
+
+    {
+        myassert(!in);
+        for(sizeof(enum{in=1});;){ myassert(in); break; }
+        myassert(!in); //OK
+    }
+    {
+        myassert(!in);
+        for(;;sizeof(enum{in=1})){ myassert(in); break; }
+        myassert(!in); //OK
+    }
+    {
+        myassert(!in);
+        for(;sizeof(enum{in=1});){ myassert(in); break; }
+        myassert(!in); //OK
+    }
+
+}
+
diff --git a/tests/tests2/129_scopes.expect b/tests/tests2/129_scopes.expect
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/tests2/130_large_argument.c b/tests/tests2/130_large_argument.c
new file mode 100644
index 000000000..8415c85e9
--- /dev/null
+++ b/tests/tests2/130_large_argument.c
@@ -0,0 +1,41 @@
+#include<stdio.h>
+
+struct large1 {
+    int a[768];
+};
+
+struct large2 {
+    int a[1920];
+};
+
+void pass_large_struct1(struct large1 in)
+{
+    printf("%d %d\n", in.a[200], in.a[767]);
+    return;
+}
+
+void pass_large_struct2(struct large2 in)
+{
+    printf("%d %d %d\n", in.a[200], in.a[1023], in.a[1919]);
+    return;
+}
+
+void pass_many_args(int a, int b, int c, int d, int e, int f, int g, int h, int i,
+                    int j, int k, int l, int m)
+{
+    printf("%d %d %d %d %d %d %d %d %d %d %d %d %d\n", a, b, c, d, e, f, g, h, i,
+           j, k, l, m);
+    return;
+}
+
+struct large1 l1 = { .a = { [200] = 1, [767] = 2 } };
+struct large2 l2 = { .a = { [200] = 3, [1023] = 4, [1919] = 5} };
+
+int main(void)
+{
+    pass_large_struct1(l1);
+    pass_large_struct2(l2);
+    pass_many_args(13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
+
+    return 0;
+}
diff --git a/tests/tests2/130_large_argument.expect b/tests/tests2/130_large_argument.expect
new file mode 100644
index 000000000..8c5d9cd78
--- /dev/null
+++ b/tests/tests2/130_large_argument.expect
@@ -0,0 +1,3 @@
+1 2
+3 4 5
+13 12 11 10 9 8 7 6 5 4 3 2 1
diff --git a/tests/tests2/131_return_struct_in_reg.c b/tests/tests2/131_return_struct_in_reg.c
new file mode 100644
index 000000000..2cb00b53a
--- /dev/null
+++ b/tests/tests2/131_return_struct_in_reg.c
@@ -0,0 +1,70 @@
+#include<stdio.h>
+
+struct s1 {
+    unsigned char a:4, b:4;
+} g1 = { 0x05, 0x0a };
+
+struct s2 {
+    unsigned char a, b;
+} g2 = { 0x12, 0x34 };
+
+struct s4 {
+    unsigned short a, b;
+} g4 = { 0x1245, 0x5678 };
+
+struct s8 {
+    unsigned a, b;
+} g8 = { 0x12345678, 0x9abcdef0 };
+
+/* returned in 2 registers on riscv64 */
+struct s16 {
+    unsigned long long a, b;
+} g16 = { 0x123456789abcdef0ULL, 0xfedcba9876543210ULL };
+
+/* Homogeneous float aggregate on ARM hard-float */
+struct s_f4 {
+    double a, b, c, d;
+} g_f4 = { 1,2,3,4 };
+
+#define def(S) \
+struct s##S f##S(int x) \
+{ \
+    struct s##S l##S = g##S, *p##S = &l##S; \
+    if (x == 0) \
+        return g##S; \
+    else if (x == 1) \
+        return l##S; \
+    else \
+        return *p##S; \
+}
+
+def(1)
+def(2)
+def(4)
+def(8)
+def(16)
+def(_f4)
+
+#define chk(S,x) \
+    struct s##S l##S = f##S(x); \
+    printf("%02llx %02llx\n", \
+        (unsigned long long)l##S.a, \
+        (unsigned long long)l##S.b \
+        );
+
+int main()
+{
+    for (int x = 0;;) {
+        chk(1,x);
+        chk(2,x);
+        chk(4,x);
+        chk(8,x);
+        chk(16,x);
+        struct s_f4 l_f4 = f_f4(x);
+        printf("%.1f %.1f %.1f %.1f\n", l_f4.a, l_f4.b, l_f4.c, l_f4.d);
+        if (++x > 2)
+            break;
+        printf("\n");
+    }
+    return 0;
+}
diff --git a/tests/tests2/131_return_struct_in_reg.expect b/tests/tests2/131_return_struct_in_reg.expect
new file mode 100644
index 000000000..2341c57c3
--- /dev/null
+++ b/tests/tests2/131_return_struct_in_reg.expect
@@ -0,0 +1,20 @@
+05 0a
+12 34
+1245 5678
+12345678 9abcdef0
+123456789abcdef0 fedcba9876543210
+1.0 2.0 3.0 4.0
+
+05 0a
+12 34
+1245 5678
+12345678 9abcdef0
+123456789abcdef0 fedcba9876543210
+1.0 2.0 3.0 4.0
+
+05 0a
+12 34
+1245 5678
+12345678 9abcdef0
+123456789abcdef0 fedcba9876543210
+1.0 2.0 3.0 4.0
diff --git a/tests/tests2/132_bound_test.c b/tests/tests2/132_bound_test.c
new file mode 100644
index 000000000..4898e8d72
--- /dev/null
+++ b/tests/tests2/132_bound_test.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <float.h>
+
+union ieee_double_extract
+{
+    struct {
+        unsigned int manl:32;
+        unsigned int manh:20;
+        unsigned int exp:11;
+        unsigned int sig:1;
+    } s;
+    double d;
+};
+
+double scale(double d)
+{
+    union ieee_double_extract x;
+
+    x.d = d;
+    x.d *= 1000;
+    return x.d;
+}
+
+int
+main(void)
+{
+    printf("%g\n", scale(42));
+    return 0;
+}
diff --git a/tests/tests2/132_bound_test.expect b/tests/tests2/132_bound_test.expect
new file mode 100644
index 000000000..6096bd1be
--- /dev/null
+++ b/tests/tests2/132_bound_test.expect
@@ -0,0 +1 @@
+42000
diff --git a/tests/tests2/18_include.c b/tests/tests2/18_include.c
index dbae3aa2e..9ff60c96f 100644
--- a/tests/tests2/18_include.c
+++ b/tests/tests2/18_include.c
@@ -4,8 +4,43 @@ int main()
 {
    printf("including\n");
 #include "18_include.h"
+#define  test_missing_nl
    printf("done\n");
 
+#define  INC   "18_include.h"
+
+#ifdef __has_include
+#if defined __has_include
+#if __has_include("18_include.h")
+   printf("has_include\n");
+#endif
+#if __has_include(INC)
+   printf("has_include\n");
+#endif
+#if __has_include("not_found_18_include.h")
+   printf("has_include not found\n");
+#endif
+#endif
+#endif
+
+#ifdef __has_include_next
+#if defined __has_include_next
+#if __has_include_next("18_include.h")
+   printf("has_include_next\n");
+#endif
+#if __has_include_next(INC)
+   printf("has_include_next\n");
+#endif
+#if __has_include_next("not_found_18_include.h")
+   printf("has_include_next not found\n");
+#endif
+#endif
+#endif
+
+#include "18_include2.h"
+#include "./18_include2.h"
+#include "../tests2/18_include2.h"
+
    return 0;
 }
 
diff --git a/tests/tests2/18_include.expect b/tests/tests2/18_include.expect
index 58c6d29a0..fbc6d1342 100644
--- a/tests/tests2/18_include.expect
+++ b/tests/tests2/18_include.expect
@@ -1,3 +1,8 @@
 including
 included
 done
+has_include
+has_include
+has_include_next
+has_include_next
+counter 0
diff --git a/tests/tests2/18_include.h b/tests/tests2/18_include.h
index dc8608025..cad2433fd 100644
--- a/tests/tests2/18_include.h
+++ b/tests/tests2/18_include.h
@@ -1 +1,5 @@
 printf("included\n");
+/* test file with missing newline */
+#ifndef INCLUDE
+#define INCLUDE
+#endif /* INCLUDE */
\ No newline at end of file
diff --git a/tests/tests2/18_include2.h b/tests/tests2/18_include2.h
new file mode 100644
index 000000000..2a89c3d1f
--- /dev/null
+++ b/tests/tests2/18_include2.h
@@ -0,0 +1,2 @@
+#pragma once
+printf ("counter %d\n", __COUNTER__);
diff --git a/tests/tests2/22_floating_point.c b/tests/tests2/22_floating_point.c
index 2eb062c3f..d6d4028f9 100644
--- a/tests/tests2/22_floating_point.c
+++ b/tests/tests2/22_floating_point.c
@@ -14,47 +14,108 @@ test()
    }
 }
 
+float f1 = 12.34f, f2 = 56.78f;
+double d1 = 12.34, d2 = 56.78;
+long double ld1 = 12.34l, ld2 = 56.78l;
+
+float tf = 12.34f + 56.78f - 12.34f * 56.78f + 12.34f / 56.78f;
+double td = 12.34 + 56.78 - 12.34 * 56.78 + 12.34 / 56.78;
+long double tld = 12.34l + 56.78l - 12.34l * 56.78l + 12.34l / 56.78l;
+
 int main()
 {
+   static int e1 = -1.0 == 0.0;
+   static int e2 = -1.0 != 0.0;
+   static int e3 = -1.0 < 0.0;
+   static int e4 = -1.0 >= 0.0;
+   static int e5 = -1.0 <= 0.0;
+   static int e6 = -1.0 > 0.0;
    // variables
-   float a = 12.34 + 56.78;
-   printf("%f\n", a);
+   float af = 12.34f + 56.78f;
+   double ad = 12.34 + 56.78;
+   long double ald = 12.34l + 56.78l;
+   printf("%f %f \n", af, tf);
+   printf("%g %g\n", ad, td);
+   printf("%Lf %Lf\n", ald, tld);
 
    // infix operators
-   printf("%f\n", 12.34 + 56.78);
-   printf("%f\n", 12.34 - 56.78);
-   printf("%f\n", 12.34 * 56.78);
-   printf("%f\n", 12.34 / 56.78);
+   printf("%f %f %f %f\n", 12.34f + 56.78f, 12.34f - 56.78f, 12.34f * 56.78f, 12.34f / 56.78f);
+   printf("%g %g %g %g\n", 12.34 + 56.78, 12.34 - 56.78, 12.34 * 56.78, 12.34 / 56.78);
+   printf("%Lf %Lf %Lf %Lf\n", 12.34l + 56.78l, 12.34l - 56.78l, 12.34l * 56.78l, 12.34l / 56.78l);
+#ifdef __i386__
+   // gcc/clang -m32 -mno-sse and tcc all fail for + and * but all have the same value
+   printf("%f %f %f %f\n", 12.34f + 56.78f, f1 - f2, 12.34f * 56.78f, f1 / f2);
+#else
+   printf("%f %f %f %f\n", f1 + f2, f1 - f2, f1 * f2, f1 / f2);
+#endif
+   printf("%g %g %g %g\n", d1 + d2, d1 - d2, d1 * d2, d1 / d2);
+   printf("%Lf %Lf %Lf %Lf\n", ld1 + ld2, ld1 - ld2, ld1 * ld2, ld1 / ld2);
 
    // comparison operators
+   printf("%d %d %d %d %d %d\n", 12.34f < 56.78f, 12.34f <= 56.78f, 12.34f == 56.78f, 12.34f >= 56.78f, 12.34f > 56.78f, 12.34f != 56.78f);
+   printf("%d %d %d %d %d %d\n", 12.34f < 12.34f, 12.34f <= 12.34f, 12.34f == 12.34f, 12.34f >= 12.34f, 12.34f > 12.34f, 12.34f != 12.34f);
+   printf("%d %d %d %d %d %d\n", 56.78f < 12.34f, 56.78f <= 12.34f, 56.78f == 12.34f, 56.78f >= 12.34f, 56.78f > 12.34f, 56.78f != 12.34f);
    printf("%d %d %d %d %d %d\n", 12.34 < 56.78, 12.34 <= 56.78, 12.34 == 56.78, 12.34 >= 56.78, 12.34 > 56.78, 12.34 != 56.78);
    printf("%d %d %d %d %d %d\n", 12.34 < 12.34, 12.34 <= 12.34, 12.34 == 12.34, 12.34 >= 12.34, 12.34 > 12.34, 12.34 != 12.34);
    printf("%d %d %d %d %d %d\n", 56.78 < 12.34, 56.78 <= 12.34, 56.78 == 12.34, 56.78 >= 12.34, 56.78 > 12.34, 56.78 != 12.34);
+   printf("%d %d %d %d %d %d\n", 12.34l < 56.78l, 12.34l <= 56.78l, 12.34l == 56.78l, 12.34l >= 56.78l, 12.34l > 56.78l, 12.34l != 56.78l);
+   printf("%d %d %d %d %d %d\n", 12.34l < 12.34l, 12.34l <= 12.34l, 12.34l == 12.34l, 12.34l >= 12.34l, 12.34l > 12.34l, 12.34l != 12.34l);
+   printf("%d %d %d %d %d %d\n", 56.78l < 12.34l, 56.78l <= 12.34l, 56.78l == 12.34l, 56.78l >= 12.34l, 56.78l > 12.34l, 56.78l != 12.34l);
+   printf("%d %d %d %d %d %d\n", f1 < f2, f1 <= f2, f1 == f2, f1 >= f2, f1 > f2, f1 != f2);
+   printf("%d %d %d %d %d %d\n", f1 < f1, f1 <= f1, f1 == f1, f1 >= f1, f1 > f1, f1 != f1);
+   printf("%d %d %d %d %d %d\n", f2 < f1, f2 <= f1, f2 == f1, f2 >= f1, f2 > f1, f2 != f1);
+   printf("%d %d %d %d %d %d\n", d1 < d2, d1 <= d2, d1 == d2, d1 >= d2, d1 > d2, d1 != d2);
+   printf("%d %d %d %d %d %d\n", d1 < d1, d1 <= d1, d1 == d1, d1 >= d1, d1 > d1, d1 != d1);
+   printf("%d %d %d %d %d %d\n", d2 < d1, d2 <= d1, d2 == d1, d2 >= d1, d2 > d1, d2 != d1);
+   printf("%d %d %d %d %d %d\n", ld1 < ld2, ld1 <= ld2, ld1 == ld2, ld1 >= ld2, ld1 > ld2, ld1 != ld2);
+   printf("%d %d %d %d %d %d\n", ld1 < ld1, ld1 <= ld1, ld1 == ld1, ld1 >= ld1, ld1 > ld1, ld1 != ld1);
+   printf("%d %d %d %d %d %d\n", ld2 < ld1, ld2 <= ld1, ld2 == ld1, ld2 >= ld1, ld2 > ld1, ld2 != ld1);
+   printf("%d %d %d %d %d %d\n", e1, e2, e3, e4, e5, e6);
 
    // assignment operators
-   a = 12.34;
-   a += 56.78;
-   printf("%f\n", a);
+   af = 12.34f; ad = 12.34; ald = 12.34l;
+   af += 56.78f; ad += 56.78; ald += 56.78l;
+   printf("%f %g %Lf\n", af, ad, ald);
+#ifdef __i386__
+   printf("%f %g %Lf\n", af, ad, ald);
+#else
+   af = f1; ad = d1; ald = ld1;
+   af += f2; ad += d2; ald += ld2;
+   printf("%f %g %Lf\n", af, ad, ald);
+#endif
 
-   a = 12.34;
-   a -= 56.78;
-   printf("%f\n", a);
+   af = 12.34f; ad = 12.34; ald = 12.34l;
+   af -= 56.78f; ad -= 56.78; ald -= 56.78l;
+   printf("%f %g %Lf\n", af, ad, ald);
+   af = f1; ad = d1; ald = ld1;
+   af -= f2; ad -= d2; ald -= ld2;
+   printf("%f %g %Lf\n", af, ad, ald);
 
-   a = 12.34;
-   a *= 56.78;
-   printf("%f\n", a);
+   af = 12.34f; ad = 12.34; ald = 12.34l;
+   af *= 56.78f; ad *= 56.78; ald *= 56.78l;
+   printf("%f %g %Lf\n", af, ad, ald);
+#ifdef __i386__
+   printf("%f %g %Lf\n", af, ad, ald);
+#else
+   af = f1; ad = d1; ald = ld1;
+   af *= f2; ad *= d2; ald *= ld2;
+   printf("%f %g %Lf\n", af, ad, ald);
+#endif
 
-   a = 12.34;
-   a /= 56.78;
-   printf("%f\n", a);
+   af = 12.34f; ad = 12.34; ald = 12.34l;
+   af /= 56.78f; ad /= 56.78; ald /= 56.78l;
+   printf("%f %g %Lf\n", af, ad, ald);
+   af = f1; ad = d1; ald = ld1;
+   af /= f2; ad /= d2; ald /= ld2;
+   printf("%f %g %Lf\n", af, ad, ald);
 
    // prefix operators
-   printf("%f\n", +12.34);
-   printf("%f\n", -12.34);
+   printf("%f %g %Lf\n", +12.34f, +12.34, +12.34l);
+   printf("%f %g %Lf\n", -12.34f, -12.34, -12.34l);
 
    // type coercion
-   a = 2;
-   printf("%f\n", a);
+   af = 2;
+   printf("%f\n", af);
    printf("%f\n", sin(2));
 
    return 0;
diff --git a/tests/tests2/22_floating_point.expect b/tests/tests2/22_floating_point.expect
index 75ea3a7e2..d9c803e08 100644
--- a/tests/tests2/22_floating_point.expect
+++ b/tests/tests2/22_floating_point.expect
@@ -1,16 +1,40 @@
-69.120003
-69.120000
--44.440000
-700.665200
-0.217330
+69.119995 -631.327881 
+69.12 -631.328
+69.120000 -631.327870
+69.119995 -44.439999 700.665222 0.217330
+69.12 -44.44 700.665 0.21733
+69.120000 -44.440000 700.665200 0.217330
+69.119995 -44.439999 700.665222 0.217330
+69.12 -44.44 700.665 0.21733
+69.120000 -44.440000 700.665200 0.217330
 1 1 0 0 0 1
 0 1 1 1 0 0
 0 0 0 1 1 1
-69.120003
--44.439999
-700.665222
-0.217330
-12.340000
--12.340000
+1 1 0 0 0 1
+0 1 1 1 0 0
+0 0 0 1 1 1
+1 1 0 0 0 1
+0 1 1 1 0 0
+0 0 0 1 1 1
+1 1 0 0 0 1
+0 1 1 1 0 0
+0 0 0 1 1 1
+1 1 0 0 0 1
+0 1 1 1 0 0
+0 0 0 1 1 1
+1 1 0 0 0 1
+0 1 1 1 0 0
+0 0 0 1 1 1
+0 1 1 0 1 0
+69.119995 69.12 69.120000
+69.119995 69.12 69.120000
+-44.439999 -44.44 -44.440000
+-44.439999 -44.44 -44.440000
+700.665222 700.665 700.665200
+700.665222 700.665 700.665200
+0.217330 0.21733 0.217330
+0.217330 0.21733 0.217330
+12.340000 12.34 12.340000
+-12.340000 -12.34 -12.340000
 2.000000
 0.909297
diff --git a/tests/tests2/33_ternary_op.c b/tests/tests2/33_ternary_op.c
index 1e6b56d66..8305438c4 100644
--- a/tests/tests2/33_ternary_op.c
+++ b/tests/tests2/33_ternary_op.c
@@ -39,6 +39,42 @@ static int getme(struct condstruct* s, int i)
     return i1 + i2 + i3 + i4;
 }
 
+int someglobal;
+
+void constantcond(void)
+{
+  /* This was broken by 8227db3a2, it saved/restored the CODE_OFF state
+     during the expression and that bled out to the outer one disabling
+     codegen for if-body.  */
+  if (( (someglobal ? 0 : 0) ? 8 : 9))
+    printf("okay\n");
+}
+
+unsigned short tf_4_var_2 = 29886;
+const unsigned short tf_4_var_34 = 54077;
+const unsigned short tf_4_var_86 = 1129;
+long int tf_4_var_98 = -4448775496354969734L;
+
+unsigned short tf_4_array_8 [9] =
+    {52593, 34626, 28127, 8124, 11473, 14634, 8370, 31153, 31060};
+unsigned short tf_4_array_2 [6] =
+    {7493, 64504, 22566, 54931, 44752, 18026};
+unsigned short tf_4_array_3 [9] =
+    {22671, 46595, 24007, 22460, 12020, 19732, 46148, 3906, 26139};
+unsigned short tf_4_array_7 [9] =
+    {24530, 26236, 61122, 9019, 26099, 31028, 1078, 27042, 36756};
+unsigned short tf_4_array_4 [9] =
+    {32711, 2853, 55531, 52731, 6621, 38797, 23543, 64627, 55640};
+
+long int tf_4_var_132 = -6396431410421938408L;
+
+static void tst_yarpgen(void)
+{
+    /* generated by yarpgen */
+    tf_4_var_132 = (long int) (((unsigned long long int) (((((((int) (tf_4_var_86)) && ((int) (tf_4_array_8 [0]))) ? (((int) (tf_4_var_2)) || ((int) (8))) : (((int) (tf_4_array_2 [0])) || (-4096)))) || ((((int) (tf_4_array_3 [6])) || ((int) (tf_4_var_34))) && (((int) (tf_4_array_3 [7])) || ((int) (tf_4_var_98))))) % ((+((int) ((unsigned short) (-6)))) && ((((int) (tf_4_array_7 [5])) & ((int) (tf_4_array_7 [1]))) | (((int) (tf_4_array_4 [0])) & ((int) (tf_4_array_4 [0]))))))) <= (((unsigned long long int) ((int) ((unsigned short) (((7192886880476152731ULL) * (7192886880476152731ULL)) * ((unsigned long long int) (((-9223372036854775807L - 1L)) * ((long int) ((int) (0))))))))) * (((unsigned long long int) (((-6) * ((int) (3))) * (-((int) (4))))) * (((8ULL) * (4ULL)) * ((unsigned long long int) (((long int) (-6)) * (-3L)))))));
+    printf("%ld\n", tf_4_var_132);
+}
+
 int main()
 {
    int Count;
@@ -73,6 +109,9 @@ int main()
     //0 ? a : 0.0;
    }
 
+   constantcond();
+
+   tst_yarpgen();
 
    return 0;
 }
diff --git a/tests/tests2/33_ternary_op.expect b/tests/tests2/33_ternary_op.expect
index 497be0e4a..c21f5fbb8 100644
--- a/tests/tests2/33_ternary_op.expect
+++ b/tests/tests2/33_ternary_op.expect
@@ -10,3 +10,5 @@
 24
 27
 152
+okay
+1
diff --git a/tests/tests2/60_errors_and_warnings.c b/tests/tests2/60_errors_and_warnings.c
index 9cede3286..6513ee1b3 100644
--- a/tests/tests2/60_errors_and_warnings.c
+++ b/tests/tests2/60_errors_and_warnings.c
@@ -191,15 +191,18 @@ void * _Alignas(16) p1;
 
 #define ONE 0
  _Static_assert(ONE == 0, "don't show me this");
- _Static_assert(ONE == 1, "ONE is not 1");
+ struct x{ _Static_assert(ONE == 1, "ONE is not 1"); };
 
 #elif defined test_static_assert_2
  _Static_assert(1, "1"" is 1");
- _Static_assert(0, "0"" is 0");
+struct y {  _Static_assert(0, "0"" is 0"); };
 
 #elif defined test_static_assert_c2x
  _Static_assert(1);
- _Static_assert(0);
+struct z {  _Static_assert(0); }
+
+#elif defined test_static_assert_empty_string
+ _Static_assert(0,"");
 
 #elif defined test_void_array
  void t[3];
@@ -395,6 +398,14 @@ struct S2 {
 extern int array[2];
 int array[] = { 1, 2, 3 };
 
+#elif defined test_incompatible_local_redef
+void foo (void)
+{
+  typedef int localfunctype (int);
+  extern localfunctype func2;
+  typedef void localfunctype (int, int);
+}
+
 #elif defined test_cast_from_void
 void v() {}
 int f() { return v(); }
@@ -442,4 +453,27 @@ int f() { ({ return 78; }); }
 int main() { return f(); }
 
 /******************************************************************/
+
+#elif defined test_illegal_unicode
+int main() {
+    char *str = "\Uffffffff";
+}
+
+#elif defined test_error_string
+#error \123\\
+456
+
+#elif defined test_error_incomplete_type
+struct A;
+void f(struct A *);
+
+int main()
+{
+    f(&(struct A){});
+}
+
+struct A {
+    int x;
+};
+
 #endif
diff --git a/tests/tests2/60_errors_and_warnings.expect b/tests/tests2/60_errors_and_warnings.expect
index ac8a96531..25a76245c 100644
--- a/tests/tests2/60_errors_and_warnings.expect
+++ b/tests/tests2/60_errors_and_warnings.expect
@@ -23,7 +23,7 @@
 [returns 1]
 
 [test_61_undefined_enum]
-60_errors_and_warnings.c:46: error: unknown type size
+60_errors_and_warnings.c:46: error: initialization of incomplete type
 
 [test_74_non_const_init]
 60_errors_and_warnings.c:49: error: initializer element is not constant
@@ -100,22 +100,25 @@
 [test_static_assert_c2x]
 60_errors_and_warnings.c:202: error: _Static_assert fail
 
+[test_static_assert_empty_string]
+60_errors_and_warnings.c:205: error: 
+
 [test_void_array]
-60_errors_and_warnings.c:205: error: declaration of an array of incomplete type elements
+60_errors_and_warnings.c:208: error: declaration of an array of incomplete type elements
 
 [test_incomplete_enum_array]
-60_errors_and_warnings.c:208: error: declaration of an array of incomplete type elements
+60_errors_and_warnings.c:211: error: declaration of an array of incomplete type elements
 
 [test_incomplete_struct_array]
-60_errors_and_warnings.c:211: error: declaration of an array of incomplete type elements
+60_errors_and_warnings.c:214: error: declaration of an array of incomplete type elements
 
 [test_const_fun_array]
-60_errors_and_warnings.c:215: error: declaration of an array of functions
+60_errors_and_warnings.c:218: error: declaration of an array of functions
 
 [test_incomplete_array_array]
 
 [test_extern_array]
-60_errors_and_warnings.c:231: error: incompatible types for redefinition of 'x'
+60_errors_and_warnings.c:234: error: incompatible types for redefinition of 'x'
 
 [test_func_1]
 hello: a = 123
@@ -124,17 +127,17 @@ hello: a = 123
 hello: a = 123
 
 [test_func_3]
-60_errors_and_warnings.c:261: warning: static storage ignored for redefinition of 'hello'
+60_errors_and_warnings.c:264: warning: static storage ignored for redefinition of 'hello'
 hello: a = 123
 
 [test_func_4]
 hello: a = 123
 
 [test_func_5]
-60_errors_and_warnings.c:261: error: incompatible types for redefinition of 'hello'
+60_errors_and_warnings.c:264: error: incompatible types for redefinition of 'hello'
 
 [test_func_6]
-60_errors_and_warnings.c:249: error: function without file scope cannot be static
+60_errors_and_warnings.c:252: error: function without file scope cannot be static
 
 [test_var_1]
 main : 1 ; 1
@@ -147,68 +150,71 @@ main : 2 ; 2
 bar  : 3 ; 3
 
 [test_var_3]
-60_errors_and_warnings.c:293: error: incompatible types for redefinition of 'xxx'
+60_errors_and_warnings.c:296: error: incompatible types for redefinition of 'xxx'
 
 [test_var_4]
 
 [test_long_double_type_for_win32]
-60_errors_and_warnings.c:324: warning: assignment from incompatible pointer type
+60_errors_and_warnings.c:327: warning: assignment from incompatible pointer type
 
 [test_stray_backslash]
-60_errors_and_warnings.c:330: error: stray '\' in program
+60_errors_and_warnings.c:333: error: stray '\' in program
 
 [test_stray_backslash2]
 \n
 
 [test_var_array]
-60_errors_and_warnings.c:345: error: flexible array has zero size in this context
+60_errors_and_warnings.c:348: error: flexible array has zero size in this context
 
 [test_var_array2]
-60_errors_and_warnings.c:355: error: flexible array has zero size in this context
+60_errors_and_warnings.c:358: error: flexible array has zero size in this context
 
 [test_var_array3]
-60_errors_and_warnings.c:362: error: flexible array has zero size in this context
+60_errors_and_warnings.c:365: error: flexible array has zero size in this context
 
 [test_default_int_type]
-60_errors_and_warnings.c:365: warning: type defaults to int
+60_errors_and_warnings.c:368: warning: type defaults to int
 
 [test_invalid_global_stmtexpr]
-60_errors_and_warnings.c:369: error: statement expression outside of function
+60_errors_and_warnings.c:372: error: statement expression outside of function
 
 [test_invalid_tokckill]
-60_errors_and_warnings.c:372: error: ';' expected (got "3")
+60_errors_and_warnings.c:375: error: ';' expected (got "3")
 
 [test_duplicate_member]
-60_errors_and_warnings.c:378: error: duplicate member 'a'
+60_errors_and_warnings.c:381: error: duplicate member 'a'
 
 [test_duplicate_member_anon]
-60_errors_and_warnings.c:391: error: duplicate member 'd'
+60_errors_and_warnings.c:394: error: duplicate member 'd'
 
 [test_conflicting_array_definition]
-60_errors_and_warnings.c:396: error: incompatible types for redefinition of 'array'
+60_errors_and_warnings.c:399: error: incompatible types for redefinition of 'array'
+
+[test_incompatible_local_redef]
+60_errors_and_warnings.c:406: error: incompatible redefinition of 'localfunctype'
 
 [test_cast_from_void]
-60_errors_and_warnings.c:400: error: cannot convert 'void' to 'int'
+60_errors_and_warnings.c:411: error: cannot convert 'void' to 'int'
 
 [test_switch_W1]
-60_errors_and_warnings.c:416: warning: implicit declaration of function 'fink'
+60_errors_and_warnings.c:427: warning: implicit declaration of function 'fink'
 
 [test_switch_W2]
-60_errors_and_warnings.c:407: warning: unsupported option '-Wstuff'
-60_errors_and_warnings.c:418: warning: 'stuff' attribute ignored
+60_errors_and_warnings.c:418: warning: unsupported option '-Wstuff'
+60_errors_and_warnings.c:429: warning: 'stuff' attribute ignored
 
 [test_switch_W3]
-60_errors_and_warnings.c:415: error: assignment discards qualifiers from pointer target type
+60_errors_and_warnings.c:426: error: assignment discards qualifiers from pointer target type
 
 [test_switch_W4]
-60_errors_and_warnings.c:416: warning: implicit declaration of function 'fink'
-60_errors_and_warnings.c:418: error: 'stuff' attribute ignored
+60_errors_and_warnings.c:427: warning: implicit declaration of function 'fink'
+60_errors_and_warnings.c:429: error: 'stuff' attribute ignored
 
 [test_invalid_funcparam_1]
-60_errors_and_warnings.c:421: error: redeclaration of 'a'
+60_errors_and_warnings.c:432: error: redeclaration of 'a'
 
 [test_invalid_funcparam_2]
-60_errors_and_warnings.c:424: error: identifier expected
+60_errors_and_warnings.c:435: error: identifier expected
 
 [test_array_funcparam]
 arg[0] = "X"
@@ -216,3 +222,12 @@ arg[1] = "Y"
 
 [test_return_from_statement_expr]
 [returns 78]
+
+[test_illegal_unicode]
+60_errors_and_warnings.c:459: error: 0xffffffff is not a valid universal character
+
+[test_error_string]
+60_errors_and_warnings.c:464: error: #error \123\456
+
+[test_error_incomplete_type]
+60_errors_and_warnings.c:472: error: initialization of incomplete type
diff --git a/tests/tests2/80_flexarray.c b/tests/tests2/80_flexarray.c
index 1fc1a60a7..864d4298f 100644
--- a/tests/tests2/80_flexarray.c
+++ b/tests/tests2/80_flexarray.c
@@ -15,6 +15,7 @@ int f1int (void) {
     struct wint q = {"bugs"};
     return !s[0];
 }
+int empty[] = {}; // GNU extension
 int main (void) {
    char s[9]="nonono";
    static struct wchar q = {"bugs", {'c'}};
diff --git a/tests/tests2/82_attribs_position.c b/tests/tests2/82_attribs_position.c
index fd3f2c4eb..d8c9fe5f1 100644
--- a/tests/tests2/82_attribs_position.c
+++ b/tests/tests2/82_attribs_position.c
@@ -30,6 +30,12 @@ int ATTR actual_function() {
   return 42;
 }
 
+int label_attribute (void)
+{
+lab1: __attribute__((__unused__));
+  return 0;
+}
+
 extern int printf (const char *, ...);
 static int globalvar;
 int main()
diff --git a/tests/tests2/87_dead_code.c b/tests/tests2/87_dead_code.c
index 0d5a64ce2..369f4bab6 100644
--- a/tests/tests2/87_dead_code.c
+++ b/tests/tests2/87_dead_code.c
@@ -56,6 +56,15 @@ static void dowhile(void)
   } while (check());
 }
 
+static void nondead_after_dead_return(void)
+{
+  /* This statement expr is not entered, and hence that fact that it
+     doesn't fall-through should not influence the surrounding code.  */
+  0 && ({ return; 0;});
+  printf ("nondead works\n");
+  return;
+}
+
 int main (void)
 {
   int i = 1;
@@ -150,6 +159,7 @@ int main (void)
   }
 
   dowhile();
+  nondead_after_dead_return();
 
   return 0;
 }
diff --git a/tests/tests2/87_dead_code.expect b/tests/tests2/87_dead_code.expect
index a8c93bd0c..781ff518e 100644
--- a/tests/tests2/87_dead_code.expect
+++ b/tests/tests2/87_dead_code.expect
@@ -21,3 +21,4 @@ check 1
 g=2
 check 2
 g=3
+nondead works
diff --git a/tests/tests2/88_codeopt.c b/tests/tests2/88_codeopt.c
index 2ab4c8a8c..3faa5fac6 100644
--- a/tests/tests2/88_codeopt.c
+++ b/tests/tests2/88_codeopt.c
@@ -44,6 +44,16 @@ void bla(void)
   get_args(!!__ret, sizeof(__ret));
 }
 
+int ext;
+
+void broken_jumpopt (int xxx)
+{
+  /* This was broken in 8227db3a2 by code suppression during suppressed
+     code :) */
+  ext = (xxx || 1) || ((xxx && 1) || 1);
+  printf("okay: %d %d\n", xxx, ext);
+}
+
 _Bool chk(unsigned long addr, unsigned long limit, unsigned long size)
 {
   _Bool ret;
@@ -65,5 +75,6 @@ int main()
   else
     printf("okay\n");
   bla();
+  broken_jumpopt(42);
   return 0;
 }
diff --git a/tests/tests2/88_codeopt.expect b/tests/tests2/88_codeopt.expect
index 439edfd8f..76b582b39 100644
--- a/tests/tests2/88_codeopt.expect
+++ b/tests/tests2/88_codeopt.expect
@@ -1,2 +1,3 @@
 okay
 okay
+okay: 42 1
diff --git a/tests/tests2/90_struct-init.c b/tests/tests2/90_struct-init.c
index de8505d96..4a71a93dc 100644
--- a/tests/tests2/90_struct-init.c
+++ b/tests/tests2/90_struct-init.c
@@ -371,6 +371,22 @@ void test_init_struct_from_struct(void)
         );
 }
 
+typedef struct {
+    unsigned int a;
+    unsigned int : 32;
+    unsigned int b;
+    unsigned long long : 64;
+    unsigned int c;
+} tst_bf;
+
+tst_bf arr[] = { { 1, 2, 3 } };
+
+void
+test_init_bf(void)
+{
+    printf ("%s: %d %d %d\n", __FUNCTION__, arr[0].a, arr[0].b, arr[0].c);
+}
+
 
 int main()
 {
@@ -403,5 +419,6 @@ int main()
   test_zero_init();
   test_init_ranges();
   test_init_struct_from_struct();
+  test_init_bf();
   return 0;
 }
diff --git a/tests/tests2/90_struct-init.expect b/tests/tests2/90_struct-init.expect
index 45c8cf42f..5014f8216 100644
--- a/tests/tests2/90_struct-init.expect
+++ b/tests/tests2/90_struct-init.expect
@@ -56,3 +56,4 @@ sea_fill1: okay
 sea_fill2: okay
 1438
 test_init_struct_from_struct: 1 2 3 4 - 1 2 3 4 - 3 4 5 6
+test_init_bf: 1 2 3
diff --git a/tests/tests2/94_generic.c b/tests/tests2/94_generic.c
index 4a68bcdd3..7ad9dd067 100644
--- a/tests/tests2/94_generic.c
+++ b/tests/tests2/94_generic.c
@@ -30,6 +30,12 @@ void void_foo(int i) {}
 
 typedef int int_type1;
 
+typedef int T[4];
+int f(T t)
+{
+	return _Generic(t, __typeof__( ((void)0, (T){0}) ) : 1 );
+}
+
 #define gen_sw(a) _Generic(a, const char *: 1, default: 8, int: 123);
 
 int main()
@@ -40,6 +46,7 @@ int main()
 	const int * const ptr;
 	const char *ti;
 	int_type1 i2;
+	T t;
 
 	i = _Generic(a, int: a_f, const int: b_f)();
 	printf("%d\n", i);
@@ -92,6 +99,9 @@ int main()
 
 	//void ptrs get chosen preferentially; qualifs still combine
 	_Generic( 0?(int volatile*)0: (void const*)1, void volatile const*: (void)0);
+        //but this is no null-ptr constant, so fallback to void-choice
+        i = 0;
+        _Generic( 1?(void*)(i*0LL):&i, void*:0);
 	//like gcc but not clang, don't treat (void* const as the null-ptr constant)
 	_Generic( 0?(int volatile*)0: (void const*)0, void volatile const*: (void)0);
 
@@ -115,5 +125,7 @@ int main()
 	  (void)(sizeof(struct { int x:_Generic( 0?(int (*)[5])0 : ar, int (*)[5]:+1, int (*)[4]:(void)0); }));
 	}
 
+	printf ("%d\n", f(t));
+
 	return 0;
 }
diff --git a/tests/tests2/94_generic.expect b/tests/tests2/94_generic.expect
index 80d4ed9bd..79be7ab0f 100644
--- a/tests/tests2/94_generic.expect
+++ b/tests/tests2/94_generic.expect
@@ -13,3 +13,4 @@ long
 1
 3
 5
+1
diff --git a/tests/tests2/Makefile b/tests/tests2/Makefile
index a75ea6b6b..8ce149b29 100644
--- a/tests/tests2/Makefile
+++ b/tests/tests2/Makefile
@@ -9,34 +9,28 @@ TESTS = $(patsubst %.c,%.test,\
 
 # some tests do not pass on all platforms, remove them for now
 SKIP = 34_array_assignment.test # array assignment is not in C standard
-ifeq ($(CONFIG_arm_eabi),yes) # not ARM soft-float
+ifeq (-$(CONFIG_arm_eabi)-$(CONFIG_arm_vfp)-,-yes--)
  SKIP += 22_floating_point.test
 endif
-ifdef CONFIG_OSX
- SKIP += 40_stdio.test 42_function_pointer.test
-endif
-ifeq ($(ARCH),x86_64)
- SKIP += 73_arm64.test
-endif
 ifeq (,$(filter i386,$(ARCH)))
  SKIP += 98_al_ax_extend.test 99_fastcall.test
 endif
 ifeq (,$(filter i386 x86_64,$(ARCH)))
  SKIP += 85_asm-outside-function.test # x86 asm
- SKIP += 124_atomic_counter.test
- SKIP += 125_atomic_misc.test # currently only x86 supported
+ SKIP += 127_asm_goto.test    # hardcodes x86 asm
 endif
 ifeq ($(CONFIG_backtrace),no)
- SKIP += 112_backtrace.test
  SKIP += 113_btdll.test
  CONFIG_bcheck = no
 # no bcheck without backtrace
 endif
 ifeq ($(CONFIG_bcheck),no)
+ SKIP += 112_backtrace.test
  SKIP += 114_bound_signal.test
  SKIP += 115_bound_setjmp.test
  SKIP += 116_bound_setjmp2.test
  SKIP += 117_builtins.test
+ SKIP += 126_bound_global.test
 endif
 ifeq ($(CONFIG_dll),no)
  SKIP += 113_btdll.test # no shared lib support yet
@@ -61,6 +55,10 @@ endif
 
 # Some tests might need arguments
 ARGS =
+ifneq (-$(CONFIG_WIN32)-,-yes-)
+22_floating_point.test: FLAGS += -lm
+24_math_library.test: FLAGS += -lm
+endif
 31_args.test : ARGS = arg1 arg2 arg3 arg4 arg5
 46_grep.test : ARGS = '[^* ]*[:a:d: ]+\:\*-/: $$' $(SRC)/46_grep.c
 
@@ -100,7 +98,7 @@ GEN-ALWAYS =
 108_constructor.test: NORUN = true
 
 112_backtrace.test: FLAGS += -dt -b
-112_backtrace.test 113_btdll.test: FILTER += \
+112_backtrace.test 113_btdll.test 126_bound_global.test: FILTER += \
     -e 's;[0-9A-Fa-fx]\{5,\};........;g' \
     -e 's;0x[0-9A-Fa-f]\{1,\};0x?;g'
 
@@ -108,8 +106,8 @@ GEN-ALWAYS =
 113_btdll.test: T1 = \
     $(TCC) -bt $1 -shared -D DLL=1 -o a1$(DLLSUF) && \
     $(TCC) -bt $1 -shared -D DLL=2 -o a2$(DLLSUF) && \
-    $(TCC) -bt $1 a1$(DLLSUF) a2$(DLLSUF) -Wl,-rpath=. -o a.exe && \
-    ./a.exe
+    $(TCC) -bt $1 a1$(DLLSUF) a2$(DLLSUF) -Wl,-rpath=. -o $(basename $@).exe && \
+    ./$(basename $@).exe
 
 114_bound_signal.test: FLAGS += -b
 114_bound_signal.test: NORUN = true # tcc -run does not support fork and -b and SELINUX
@@ -122,6 +120,10 @@ ifneq ($(CONFIG_bcheck),no)
 endif
 125_atomic_misc.test: FLAGS += -dt
 124_atomic_counter.test: FLAGS += -pthread
+126_bound_global.test: FLAGS += -b
+126_bound_global.test: NORUN = true
+128_run_atexit.test: FLAGS += -dt
+132_bound_test.test: FLAGS += -b
 
 # Filter source directory in warnings/errors (out-of-tree builds)
 FILTER = 2>&1 | sed -e 's,$(SRC)/,,g'
@@ -134,7 +136,7 @@ all test tests2.all: $(filter-out $(SKIP),$(TESTS))
 	@$(call T1,$<) $(T3)
 
 T1 = $(TCC) $(FLAGS) $(T2) $(ARGS)
-T2 = $(if $(NORUN),$1 -o a.exe && ./a.exe,-run $1)
+T2 = $(if $(NORUN),$1 -o $(basename $@).exe && ./$(basename $@).exe,-run $1)
 T3 = $(FILTER) >$*.output 2>&1 || true \
      && diff -Nbu $(filter %.expect,$^) $*.output \
      && rm -f $*.output $(filter $*.expect,$(GEN-ALWAYS))
@@ -162,7 +164,7 @@ F2 = $1 UPDATE="$(patsubst %.test,%.expect,$1)"
 
 # using TCC for .expect if -dt in FLAGS
 GEN = $(if $(filter -dt -bt -b,$(FLAGS)),$(GEN-TCC),$(GEN-CC))
-GEN-CC = $(CC) -w -std=gnu99 $(FLAGS) $1 -o a.exe && ./a.exe $(ARGS)
+GEN-CC = $(CC) -w -std=gnu99 $(FLAGS) $1 -o $(basename $@).exe && ./$(basename $@).exe $(ARGS)
 GEN-TCC = $(T1)
 GEN-MSC = $(MS-CC) $1 && ./$(basename $@).exe
 MS-CC = cl
@@ -175,4 +177,4 @@ $(sort $(GEN-ALWAYS) $(UPDATE)) : force
 force:
 
 clean :
-	rm -f fred.txt *.output a.exe *.dll *.so *.def $(GEN-ALWAYS)
+	rm -f fred.txt *.output *.exe *.dll *.so *.def $(GEN-ALWAYS)
diff --git a/win32/build-tcc.bat b/win32/build-tcc.bat
index 84c3888d6..147823e25 100644
--- a/win32/build-tcc.bat
+++ b/win32/build-tcc.bat
@@ -7,15 +7,8 @@ setlocal
 if (%1)==(-clean) goto :cleanup
 set CC=gcc
 set /p VERSION= < ..\VERSION
-git.exe --version 2>nul
-if not %ERRORLEVEL%==0 goto :git_done
-for /f %%b in ('git.exe rev-parse --abbrev-ref HEAD') do set GITHASH=%%b
-for /f %%h in ('git.exe rev-parse --short HEAD') do set GITHASH=%GITHASH%:%%h
-git.exe diff --quiet
-if %ERRORLEVEL%==1 set GITHASH=%GITHASH%-mod
-set DEF_GITHASH=-DTCC_GITHASH="""%GITHASH%"""
-:git_done
-set INST=
+set TCCDIR=
+set BINDIR=
 set DOC=no
 set EXES_ONLY=no
 goto :a0
@@ -31,7 +24,8 @@ goto :a2
 :a1
 if (%1)==(-t) set T=%2&& goto :a2
 if (%1)==(-v) set VERSION=%~2&& goto :a2
-if (%1)==(-i) set INST=%2&& goto :a2
+if (%1)==(-i) set TCCDIR=%2&& goto :a2
+if (%1)==(-b) set BINDIR=%2&& goto :a2
 if (%1)==(-d) set DOC=yes&& goto :a3
 if (%1)==(-x) set EXES_ONLY=yes&& goto :a3
 if (%1)==() goto :p1
@@ -43,6 +37,7 @@ echo   -c "prog options"    use prog with options to compile tcc
 echo   -t 32/64             force 32/64 bit default target
 echo   -v "version"         set tcc version
 echo   -i tccdir            install tcc into tccdir
+echo   -b bindir            but install tcc.exe and libtcc.dll into bindir
 echo   -d                   create tcc-doc.html too (needs makeinfo)
 echo   -x                   just create the executables
 echo   -clean               delete all previously produced files and directories
@@ -94,33 +89,47 @@ set T=32
 if %PROCESSOR_ARCHITECTURE%_==AMD64_ set T=64
 if %PROCESSOR_ARCHITEW6432%_==AMD64_ set T=64
 :p2
-if "%CC:~-3%"=="gcc" set CC=%CC% -O2 -s -static %DEF_GITHASH%
+if "%CC:~-3%"=="gcc" set CC=%CC% -O2 -s -static
+if (%BINDIR%)==() set BINDIR=%TCCDIR%
+
 set D32=-DTCC_TARGET_PE -DTCC_TARGET_I386
 set D64=-DTCC_TARGET_PE -DTCC_TARGET_X86_64
 set P32=i386-win32
 set P64=x86_64-win32
+
 if %T%==64 goto :t64
 set D=%D32%
+set P=%P32%
 set DX=%D64%
 set PX=%P64%
 set TX=64
 goto :p3
+
 :t64
 set D=%D64%
+set P=%P64%
 set DX=%D32%
 set PX=%P32%
 set TX=32
 goto :p3
 
 :p3
+git.exe --version 2>nul
+if not %ERRORLEVEL%==0 goto :git_done
+for /f %%b in ('git.exe rev-parse --abbrev-ref HEAD') do set GITHASH=%%b
+for /f %%b in ('git.exe log -1 "--pretty=format:%%cs_%GITHASH%@%%h"') do set GITHASH=%%b
+git.exe diff --quiet
+if %ERRORLEVEL%==1 set GITHASH=%GITHASH%*
+:git_done
 @echo on
 
 :config.h
 echo>..\config.h #define TCC_VERSION "%VERSION%"
-echo>> ..\config.h #ifdef TCC_TARGET_X86_64
-echo>> ..\config.h #define TCC_LIBTCC1 "libtcc1-64.a"
-echo>> ..\config.h #else
-echo>> ..\config.h #define TCC_LIBTCC1 "libtcc1-32.a"
+if not (%GITHASH%)==() echo>> ..\config.h #define TCC_GITHASH "%GITHASH%"
+@if not (%BINDIR%)==(%TCCDIR%) echo>> ..\config.h #define CONFIG_TCCDIR "%TCCDIR:\=/%"
+if %TX%==64 echo>> ..\config.h #ifdef TCC_TARGET_X86_64
+if %TX%==32 echo>> ..\config.h #ifdef TCC_TARGET_I386
+echo>> ..\config.h #define CONFIG_TCC_CROSSPREFIX "%PX%-"
 echo>> ..\config.h #endif
 
 for %%f in (*tcc.exe *tcc.dll) do @del %%f
@@ -150,15 +159,9 @@ copy>nul tcc-win32.txt doc
 if exist libtcc.dll .\tcc -impdef libtcc.dll -o libtcc\libtcc.def
 @if errorlevel 1 goto :the_end
 
-:libtcc1.a
-call :makelib %T%
-@if errorlevel 1 goto :the_end
-@if exist %PX%-tcc.exe call :makelib %TX%
-@if errorlevel 1 goto :the_end
-.\tcc -m%T% -c ../lib/bcheck.c -o lib/bcheck.o -g
-.\tcc -m%T% -c ../lib/bt-exe.c -o lib/bt-exe.o
-.\tcc -m%T% -c ../lib/bt-log.c -o lib/bt-log.o
-.\tcc -m%T% -c ../lib/bt-dll.c -o lib/bt-dll.o
+:lib
+call :make_lib %T% || goto :the_end
+@if exist %PX%-tcc.exe call :make_lib %TX% %PX%- || goto :the_end
 
 :tcc-doc.html
 @if not (%DOC%)==(yes) goto :doc-done
@@ -170,27 +173,32 @@ cmd /c makeinfo --html --no-split ../tcc-doc.texi -o doc/tcc-doc.html
 for %%f in (*.o *.def) do @del %%f
 
 :copy-install
-@if (%INST%)==() goto :the_end
-if not exist %INST% mkdir %INST%
-for %%f in (*tcc.exe *tcc.dll) do @copy>nul %%f %INST%\%%f
-@if not exist %INST%\lib mkdir %INST%\lib
-for %%f in (lib\*.a lib\*.o lib\*.def) do @copy>nul %%f %INST%\%%f
-for %%f in (include examples libtcc doc) do @xcopy>nul /s/i/q/y %%f %INST%\%%f
+@if (%TCCDIR%)==() goto :the_end
+if not exist %BINDIR% mkdir %BINDIR%
+for %%f in (*tcc.exe *tcc.dll) do @copy>nul %%f %BINDIR%\%%f
+if not exist %TCCDIR% mkdir %TCCDIR%
+@if not exist %TCCDIR%\lib mkdir %TCCDIR%\lib
+for %%f in (lib\*.a lib\*.o lib\*.def) do @copy>nul %%f %TCCDIR%\%%f
+for %%f in (include examples libtcc doc) do @xcopy>nul /s/i/q/y %%f %TCCDIR%\%%f
 
 :the_end
 exit /B %ERRORLEVEL%
 
-:makelib
-.\tcc -m%1 -c ../lib/libtcc1.c
-.\tcc -m%1 -c lib/crt1.c
-.\tcc -m%1 -c lib/crt1w.c
-.\tcc -m%1 -c lib/wincrt1.c
-.\tcc -m%1 -c lib/wincrt1w.c
-.\tcc -m%1 -c lib/dllcrt1.c
-.\tcc -m%1 -c lib/dllmain.c
-.\tcc -m%1 -c lib/chkstk.S
-.\tcc -m%1 -c ../lib/alloca.S
-.\tcc -m%1 -c ../lib/alloca-bt.S
-.\tcc -m%1 -c ../lib/stdatomic.c
-.\tcc -m%1 -ar lib/libtcc1-%1.a libtcc1.o crt1.o crt1w.o wincrt1.o wincrt1w.o dllcrt1.o dllmain.o chkstk.o alloca.o alloca-bt.o stdatomic.o
+:make_lib
+.\tcc -B. -m%1 -c ../lib/libtcc1.c
+.\tcc -B. -m%1 -c lib/crt1.c
+.\tcc -B. -m%1 -c lib/crt1w.c
+.\tcc -B. -m%1 -c lib/wincrt1.c
+.\tcc -B. -m%1 -c lib/wincrt1w.c
+.\tcc -B. -m%1 -c lib/dllcrt1.c
+.\tcc -B. -m%1 -c lib/dllmain.c
+.\tcc -B. -m%1 -c lib/chkstk.S
+.\tcc -B. -m%1 -c ../lib/alloca.S
+.\tcc -B. -m%1 -c ../lib/alloca-bt.S
+.\tcc -B. -m%1 -c ../lib/stdatomic.c
+.\tcc -B. -m%1 -ar lib/%2libtcc1.a libtcc1.o crt1.o crt1w.o wincrt1.o wincrt1w.o dllcrt1.o dllmain.o chkstk.o alloca.o alloca-bt.o stdatomic.o
+.\tcc -B. -m%1 -c ../lib/bcheck.c -o lib/%2bcheck.o -bt
+.\tcc -B. -m%1 -c ../lib/bt-exe.c -o lib/%2bt-exe.o
+.\tcc -B. -m%1 -c ../lib/bt-log.c -o lib/%2bt-log.o
+.\tcc -B. -m%1 -c ../lib/bt-dll.c -o lib/%2bt-dll.o
 exit /B %ERRORLEVEL%
diff --git a/win32/include/stdlib.h b/win32/include/stdlib.h
index 033c0fdf1..a0ca376f2 100644
--- a/win32/include/stdlib.h
+++ b/win32/include/stdlib.h
@@ -544,8 +544,13 @@ extern "C" {
 
   __CRT_INLINE long long __cdecl llabs(long long _j) { return (_j >= 0 ? _j : -_j); }
 
+ #ifdef __TINYC__ /* gr */
+  #define strtoll _strtoi64
+  #define strtoull _strtoui64
+ #else
   long long  __cdecl strtoll(const char* __restrict__, char** __restrict, int);
   unsigned long long  __cdecl strtoull(const char* __restrict__, char** __restrict__, int);
+ #endif
 
   /* these are stubs for MS _i64 versions */
   long long  __cdecl atoll (const char *);
diff --git a/win32/include/uchar.h b/win32/include/uchar.h
old mode 100755
new mode 100644
diff --git a/x86_64-asm.h b/x86_64-asm.h
index 4e037732d..339e1dfba 100644
--- a/x86_64-asm.h
+++ b/x86_64-asm.h
@@ -30,6 +30,9 @@
      DEF_ASM_OP0(int3, 0xcc)
      DEF_ASM_OP0(into, 0xce)
      DEF_ASM_OP0(iret, 0xcf)
+     DEF_ASM_OP0(iretw, 0x66cf)
+     DEF_ASM_OP0(iretl, 0xcf)
+     DEF_ASM_OP0(iretq, 0x48cf)
      DEF_ASM_OP0(rsm, 0x0faa)
      DEF_ASM_OP0(hlt, 0xf4)
      DEF_ASM_OP0(wait, 0x9b)
@@ -37,6 +40,11 @@
      DEF_ASM_OP0(pause, 0xf390)
      DEF_ASM_OP0(xlat, 0xd7)
 
+    DEF_ASM_OP0L(vmcall, 0xc1, 0, OPC_0F01)
+    DEF_ASM_OP0L(vmlaunch, 0xc2, 0, OPC_0F01)
+    DEF_ASM_OP0L(vmresume, 0xc3, 0, OPC_0F01)
+    DEF_ASM_OP0L(vmxoff, 0xc4, 0, OPC_0F01)
+
      /* strings */
 ALT(DEF_ASM_OP0L(cmpsb, 0xa6, 0, OPC_BWLX))
 ALT(DEF_ASM_OP0L(scmpb, 0xa6, 0, OPC_BWLX))
@@ -73,6 +81,11 @@ ALT(DEF_ASM_OP2(btrw, 0x0fba, 6, OPC_MODRM | OPC_WLX, OPT_IM8, OPT_REGW | OPT_EA
 ALT(DEF_ASM_OP2(btcw, 0x0fbb, 0, OPC_MODRM | OPC_WLX, OPT_REGW, OPT_REGW | OPT_EA))
 ALT(DEF_ASM_OP2(btcw, 0x0fba, 7, OPC_MODRM | OPC_WLX, OPT_IM8, OPT_REGW | OPT_EA))
 
+ALT(DEF_ASM_OP2(popcntw, 0xf30fb8, 0, OPC_MODRM | OPC_WLX, OPT_REGW | OPT_EA, OPT_REGW))
+
+ALT(DEF_ASM_OP2(tzcntw, 0xf30fbc, 0, OPC_MODRM | OPC_WLX, OPT_REGW | OPT_EA, OPT_REGW))
+ALT(DEF_ASM_OP2(lzcntw, 0xf30fbd, 0, OPC_MODRM | OPC_WLX, OPT_REGW | OPT_EA, OPT_REGW))
+
      /* prefixes */
      DEF_ASM_OP0(lock, 0xf0)
      DEF_ASM_OP0(rep, 0xf3)
@@ -510,6 +523,10 @@ ALT(DEF_ASM_OP2(movhps, 0x0f17, 0, OPC_MODRM, OPT_SSE, OPT_EA | OPT_REG32 ))
     DEF_ASM_OP2(sqrtps, 0x0f51, 0, OPC_MODRM, OPT_EA | OPT_SSE, OPT_SSE )
     DEF_ASM_OP2(subps, 0x0f5c, 0, OPC_MODRM, OPT_EA | OPT_SSE, OPT_SSE )
 
+    /* movnti should only accept REG32 and REG64, we accept more */
+    DEF_ASM_OP2(movnti, 0x0fc3, 0, OPC_MODRM, OPT_REG, OPT_EA)
+    DEF_ASM_OP2(movntil, 0x0fc3, 0, OPC_MODRM, OPT_REG32, OPT_EA)
+    DEF_ASM_OP2(movntiq, 0x0fc3, 0, OPC_MODRM | OPC_48, OPT_REG64, OPT_EA)
     DEF_ASM_OP1(prefetchnta, 0x0f18, 0, OPC_MODRM, OPT_EA)
     DEF_ASM_OP1(prefetcht0, 0x0f18, 1, OPC_MODRM, OPT_EA)
     DEF_ASM_OP1(prefetcht1, 0x0f18, 2, OPC_MODRM, OPT_EA)
diff --git a/x86_64-gen.c b/x86_64-gen.c
index 6641901ff..e04df10a4 100644
--- a/x86_64-gen.c
+++ b/x86_64-gen.c
@@ -33,8 +33,10 @@
 #define RC_INT     0x0001 /* generic integer register */
 #define RC_FLOAT   0x0002 /* generic float register */
 #define RC_RAX     0x0004
-#define RC_RCX     0x0008
-#define RC_RDX     0x0010
+#define RC_RDX     0x0008
+#define RC_RCX     0x0010
+#define RC_RSI     0x0020
+#define RC_RDI     0x0040
 #define RC_ST0     0x0080 /* only for long double */
 #define RC_R8      0x0100
 #define RC_R9      0x0200
@@ -105,6 +107,10 @@ enum {
 /* define if return values need to be extended explicitely
    at caller side (for interfacing with non-TCC compilers) */
 #define PROMOTE_RET
+
+#define TCC_TARGET_NATIVE_STRUCT_COPY
+ST_FUNC void gen_struct_copy(int size);
+
 /******************************************************/
 #else /* ! TARGET_DEFS_ONLY */
 /******************************************************/
@@ -124,8 +130,8 @@ ST_DATA const int reg_classes[NB_REGS] = {
     0,
     0,
     0,
-    0,
-    0,
+    RC_RSI,
+    RC_RDI,
     RC_R8,
     RC_R9,
     RC_R10,
@@ -701,7 +707,7 @@ static void gen_bounds_epilog(void)
     *bounds_ptr = 0;
 
     sym_data = get_sym_ref(&char_pointer_type, lbounds_section, 
-                           func_bound_offset, lbounds_section->data_offset);
+                           func_bound_offset, PTR_SIZE);
 
     /* generate bound local allocation */
     if (offset_modified) {
@@ -1144,7 +1150,8 @@ static X86_64_Mode classify_x86_64_arg(CType *ty, CType *ret, int *psize, int *p
         size = type_size(ty, &align);
         *psize = (size + 7) & ~7;
         *palign = (align + 7) & ~7;
-    
+        *reg_count = 0; /* avoid compiler warning */
+
         if (size > 16) {
             mode = x86_64_mode_memory;
         } else {
@@ -1216,9 +1223,11 @@ ST_FUNC int classify_x86_64_va_arg(CType *ty)
 ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int *regsize)
 {
     int size, align, reg_count;
+    if (classify_x86_64_arg(vt, ret, &size, &align, &reg_count) == x86_64_mode_memory)
+        return 0;
     *ret_align = 1; // Never have to re-align return values for x86-64
-    *regsize = 8;
-    return (classify_x86_64_arg(vt, ret, &size, &align, &reg_count) != x86_64_mode_memory);
+    *regsize = 8 * reg_count; /* the (virtual) regsize is 16 for VT_QLONG/QFLOAT */
+    return 1;
 }
 
 #define REGN 6
@@ -2038,6 +2047,7 @@ void gen_opf(int op)
                 assert(vtop->r & VT_LVAL);
                 gv(RC_FLOAT);
                 vswap();
+                fc = vtop->c.i; /* bcheck may have saved previous vtop[-1] */
             }
             
             if ((ft & VT_BTYPE) == VT_DOUBLE) {
@@ -2228,7 +2238,7 @@ ST_FUNC void gen_increment_tcov (SValue *sv)
 }
 
 /* computed goto support */
-void ggoto(void)
+ST_FUNC void ggoto(void)
 {
     gcall_or_jmp(1);
     vtop--;
@@ -2282,6 +2292,38 @@ ST_FUNC void gen_vla_alloc(CType *type, int align) {
     }
 }
 
+/*
+ * Assmuing the top part of the stack looks like below,
+ *  src dest src
+ */
+ST_FUNC void gen_struct_copy(int size)
+{
+    int n = size / PTR_SIZE;
+#ifdef TCC_TARGET_PE
+    o(0x5756); /* push rsi, rdi */
+#endif
+    gv2(RC_RDI, RC_RSI);
+    if (n <= 4) {
+        while (n)
+            o(0xa548), --n;
+    } else {
+        vpushi(n);
+        gv(RC_RCX);
+        o(0xa548f3);
+        vpop();
+    }
+    if (size & 0x04)
+        o(0xa5);
+    if (size & 0x02)
+        o(0xa566);
+    if (size & 0x01)
+        o(0xa4);
+#ifdef TCC_TARGET_PE
+    o(0x5e5f); /* pop rdi, rsi */
+#endif
+    vpop();
+    vpop();
+}
 
 /* end of x86-64 code generator */
 /*************************************************************/
diff --git a/x86_64-link.c b/x86_64-link.c
index 6bffb059e..1b6aa092c 100644
--- a/x86_64-link.c
+++ b/x86_64-link.c
@@ -22,7 +22,7 @@
 
 #include "tcc.h"
 
-#if !defined(ELF_OBJ_ONLY) || defined(TCC_TARGET_MACHO)
+#ifdef NEED_RELOC_TYPE
 /* Returns 1 for a code relocation, 0 for a data relocation. For unknown
    relocations, returns -1. */
 int code_reloc (int reloc_type)
@@ -47,6 +47,8 @@ int code_reloc (int reloc_type)
         case R_X86_64_TLSLD:
         case R_X86_64_DTPOFF32:
         case R_X86_64_TPOFF32:
+        case R_X86_64_DTPOFF64:
+        case R_X86_64_TPOFF64:
             return 0;
 
         case R_X86_64_PC32:
@@ -95,6 +97,8 @@ int gotplt_entry_type (int reloc_type)
         case R_X86_64_TLSLD:
         case R_X86_64_DTPOFF32:
         case R_X86_64_TPOFF32:
+        case R_X86_64_DTPOFF64:
+        case R_X86_64_TPOFF64:
         case R_X86_64_REX_GOTPCRELX:
         case R_X86_64_PLT32:
         case R_X86_64_PLTOFF64:
@@ -104,7 +108,7 @@ int gotplt_entry_type (int reloc_type)
     return -1;
 }
 
-#if !defined(TCC_TARGET_MACHO) || defined TCC_IS_NATIVE
+#ifdef NEED_BUILD_GOT
 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
 {
     Section *plt = s1->plt;
@@ -190,7 +194,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
 
     switch (type) {
         case R_X86_64_64:
-            if (s1->output_type == TCC_OUTPUT_DLL) {
+            if (s1->output_type & TCC_OUTPUT_DYN) {
                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
                 qrel->r_offset = rel->r_offset;
                 if (esym_index) {
@@ -208,7 +212,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
             break;
         case R_X86_64_32:
         case R_X86_64_32S:
-            if (s1->output_type == TCC_OUTPUT_DLL) {
+            if (s1->output_type & TCC_OUTPUT_DYN) {
                 /* XXX: this logic may depend on TCC's codegen
                    now TCC uses R_X86_64_32 even for a 64bit pointer */
                 qrel->r_offset = rel->r_offset;
@@ -243,7 +247,11 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
             long long diff;
             diff = (long long)val - addr;
             if (diff < -2147483648LL || diff > 2147483647LL) {
-                tcc_error("internal error: relocation failed");
+#ifdef TCC_TARGET_PE
+              /* ignore overflow with undefined weak symbols */
+              if (((ElfW(Sym)*)symtab_section->data)[sym_index].st_shndx != SHN_UNDEF)
+#endif
+                tcc_error_noabort("internal error: relocation failed");
             }
             add32le(ptr, diff);
         }
@@ -328,7 +336,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                     add32le(ptr + 8, x);
                 }
                 else
-                    tcc_error("unexpected R_X86_64_TLSGD pattern");
+                    tcc_error_noabort("unexpected R_X86_64_TLSGD pattern");
             }
             break;
         case R_X86_64_TLSLD:
@@ -348,7 +356,7 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                     rel[1].r_info = ELFW(R_INFO)(0, R_X86_64_NONE);
                 }
                 else
-                    tcc_error("unexpected R_X86_64_TLSLD pattern");
+                    tcc_error_noabort("unexpected R_X86_64_TLSLD pattern");
             }
             break;
         case R_X86_64_DTPOFF32:
@@ -364,6 +372,19 @@ void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t
                 add32le(ptr, x);
             }
             break;
+        case R_X86_64_DTPOFF64:
+        case R_X86_64_TPOFF64:
+            {
+                ElfW(Sym) *sym;
+                Section *sec;
+                int32_t x;
+
+                sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
+                sec = s1->sections[sym->st_shndx];
+                x = val - sec->sh_addr - sec->data_offset;
+                add64le(ptr, x);
+            }
+            break;
         case R_X86_64_NONE:
             break;
         case R_X86_64_RELATIVE: