diff --git a/env/entry.S b/env/entry.S
index ae059d4..fef8b9e 100644
--- a/env/entry.S
+++ b/env/entry.S
@@ -41,7 +41,7 @@ trap_entry:
   csrr a0, mcause
   csrr a1, mepc
   mv a2, sp
-  call trap
+  call handle_trap
   csrw mepc, a0
 #ifndef __riscv_abi_rve
   addi sp, sp, -8*REGBYTES
diff --git a/libwrap/semihosting/trap.c b/libwrap/semihosting/trap.c
index 7b0c8ee..a133383 100644
--- a/libwrap/semihosting/trap.c
+++ b/libwrap/semihosting/trap.c
@@ -1,60 +1,60 @@
+#include <math.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <math.h>
 
 #include "encoding.h"
 
-#define EBREAK_OPCODE   0x00100073
-#define EBREAK_MCAUSE   0x00000003
+#if defined(SEMIHOSTING)
+#define EBREAK_OPCODE 0x00100073
+#define EBREAK_MCAUSE 0x00000003
 
-#define SLLI_X0_X0_0X1F_OPCODE  0x01f01013
-#define SRAI_X0_X0_0X07_OPCODE  0x40705013
+#define SLLI_X0_X0_0X1F_OPCODE 0x01f01013
+#define SRAI_X0_X0_0X07_OPCODE 0x40705013
 
 int sh_missing_host = 0;
 
-void trap()
-{   //ToDo: Check why macro CSR_MEPC and others are not resolved
-    uint32_t mepc   = read_csr(0x341);       // Address of trap
-    uint32_t mtval  = read_csr(0x343);      // Instruction value of trap
-    uint32_t mcause = read_csr(0x342);     // Reason for the trap
+void trap() { // ToDo: Check why macro CSR_MEPC and others are not
+              // resolved
+  uint32_t mepc = read_csr(0x341);   // Address of trap
+  uint32_t mtval = read_csr(0x343);  // Instruction value of trap
+  uint32_t mcause = read_csr(0x342); // Reason for the trap
 
-    if (mcause == EBREAK_MCAUSE && mtval == EBREAK_OPCODE){
-        // This trap was caused by an EBREAK...
+  if (mcause == EBREAK_MCAUSE && mtval == EBREAK_OPCODE) {
+    // This trap was caused by an EBREAK...
 
-        int aligned = ((mepc-4) & 0x0f) == 0;
-        if (aligned 
-            && *(uint32_t *)mepc     == EBREAK_OPCODE 
-            && *(uint32_t *)(mepc-4) == SLLI_X0_X0_0X1F_OPCODE
-            && *(uint32_t *)(mepc+4) == SRAI_X0_X0_0X07_OPCODE)
-        {
-            // The EBREAK was part of the semihosting call. (See semihosting.c)
-            //
-            // If a debugger were connected, this would have resulted in a CPU halt,
-            // and the debugger would have serviced the the semihosting call.
-            // 
-            // However, the semihosting function was called without a debugger being 
-            // attached. The best course of action is to simply return from the trap 
-            // and let the semihosting function continue after the call to EBREAK to 
-            // prevent the CPU from hanging in the trap handler. 
-            write_csr(mepc, mepc+4);
+    int aligned = ((mepc - 4) & 0x0f) == 0;
+    if (aligned && *(uint32_t *)mepc == EBREAK_OPCODE &&
+        *(uint32_t *)(mepc - 4) == SLLI_X0_X0_0X1F_OPCODE &&
+        *(uint32_t *)(mepc + 4) == SRAI_X0_X0_0X07_OPCODE) {
+      // The EBREAK was part of the semihosting call. (See semihosting.c)
+      //
+      // If a debugger were connected, this would have resulted in a CPU halt,
+      // and the debugger would have serviced the the semihosting call.
+      //
+      // However, the semihosting function was called without a debugger being
+      // attached. The best course of action is to simply return from the trap
+      // and let the semihosting function continue after the call to EBREAK to
+      // prevent the CPU from hanging in the trap handler.
+      write_csr(mepc, mepc + 4);
 
-            // Set a global variable to tell the semihosting code the the semihosting 
-            // call
-            // didn't execute on the host.
-            sh_missing_host = 1;
+      // Set a global variable to tell the semihosting code the the semihosting
+      // call
+      // didn't execute on the host.
+      sh_missing_host = 1;
 
-            return;
-        }
-
-        // EBREAK was not part of a semihosting call. This should not have happened. 
-        // Hang forever.
-        while(1)
-            ;
+      return;
     }
 
-    // Trap was issued for another reason than an EBREAK.
-    // Replace the code below with whatever trap handler you'd normally use. (e.g. interrupt 
-    // processing.)
-    while(1)
-        ;
-}
\ No newline at end of file
+    // EBREAK was not part of a semihosting call. This should not have happened.
+    // Hang forever.
+    while (1)
+      ;
+  }
+
+  // Trap was issued for another reason than an EBREAK.
+  // Replace the code below with whatever trap handler you'd normally use. (e.g.
+  // interrupt processing.)
+  while (1)
+    ;
+}
+#endif
\ No newline at end of file
diff --git a/libwrap/sys/_exit.c b/libwrap/sys/_exit.c
index 0dac450..433f2e2 100644
--- a/libwrap/sys/_exit.c
+++ b/libwrap/sys/_exit.c
@@ -1,9 +1,11 @@
 /* See LICENSE of license details. */
 
-#include <unistd.h>
 #include "platform.h"
 #include "weak_under_alias.h"
+#include <unistd.h>
+#if defined(SEMIHOSTING)
 #include "semihosting.h"
+#endif
 
 #if defined(BOARD_hifive1)
 static volatile uint32_t tohost;
@@ -15,21 +17,21 @@ extern volatile uint32_t fromhost;
 
 void write_hex(int fd, uint32_t hex);
 
-void __wrap_exit(int code)
-{
-/*#if defined(SEMIHOSTING)
-  sh_exit();
-  return;
-#endif*/
-//volatile uint32_t* leds = (uint32_t*) (GPIO_BASE_ADDR + GPIO_OUT_OFFSET);
+void __wrap_exit(int code) {
+  /*#if defined(SEMIHOSTING)
+    sh_exit();
+    return;
+  #endif*/
+  // volatile uint32_t* leds = (uint32_t*) (GPIO_BASE_ADDR + GPIO_OUT_OFFSET);
   const char message[] = "\nProgam has exited with code:";
-//*leds = (~(code));
+  //*leds = (~(code));
 
   write(STDERR_FILENO, message, sizeof(message) - 1);
   write_hex(STDERR_FILENO, code);
   write(STDERR_FILENO, "\n", 1);
-  tohost = code+1;
+  tohost = code + 1;
   write(STDERR_FILENO, "\x04", 1);
-  for (;;);
+  for (;;)
+    ;
 }
 weak_under_alias(exit);
diff --git a/libwrap/sys/close.c b/libwrap/sys/close.c
index 1af2577..b94be5c 100644
--- a/libwrap/sys/close.c
+++ b/libwrap/sys/close.c
@@ -1,12 +1,13 @@
 /* See LICENSE of license details. */
 
-#include <errno.h>
 #include "stub.h"
 #include "weak_under_alias.h"
+#include <errno.h>
+#if defined(SEMIHOSTING)
 #include "semihosting.h"
+#endif
 
-int __wrap_close(int fd)
-{
+int __wrap_close(int fd) {
 #if defined(SEMIHOTING)
   int i = sh_close(fd);
   return i;
@@ -15,4 +16,3 @@ int __wrap_close(int fd)
 }
 
 weak_under_alias(close);
-
diff --git a/libwrap/sys/isatty.c b/libwrap/sys/isatty.c
index 44a805a..0f02349 100644
--- a/libwrap/sys/isatty.c
+++ b/libwrap/sys/isatty.c
@@ -1,8 +1,10 @@
 /* See LICENSE of license details. */
 
-#include "semihosting.h"
 #include "weak_under_alias.h"
 #include <unistd.h>
+#if defined(SEMIHOSTING)
+#include "semihosting.h"
+#endif
 
 int __wrap_isatty(int fd) {
 #if defined(SEMIHOSTING)
diff --git a/libwrap/sys/lseek.c b/libwrap/sys/lseek.c
index f7e629c..05beed6 100644
--- a/libwrap/sys/lseek.c
+++ b/libwrap/sys/lseek.c
@@ -1,16 +1,17 @@
 /* See LICENSE of license details. */
 
-#include <errno.h>
-#include <unistd.h>
-#include <sys/types.h>
 #include "stub.h"
 #include "weak_under_alias.h"
-#include "semihosting.h"
-
-off_t __wrap_lseek(int fd, off_t ptr, int dir)
-{
+#include <errno.h>
+#include <sys/types.h>
+#include <unistd.h>
 #if defined(SEMIHOSTING)
-  if(sh_istty(fd))
+#include "semihosting.h"
+#endif
+
+off_t __wrap_lseek(int fd, off_t ptr, int dir) {
+#if defined(SEMIHOSTING)
+  if (sh_istty(fd))
     return 0;
   sh_seek(fd, ptr);
   return ptr;
@@ -22,4 +23,3 @@ off_t __wrap_lseek(int fd, off_t ptr, int dir)
 }
 
 weak_under_alias(lseek);
-
diff --git a/libwrap/sys/open.c b/libwrap/sys/open.c
index 2ecad62..df71422 100644
--- a/libwrap/sys/open.c
+++ b/libwrap/sys/open.c
@@ -1,12 +1,13 @@
 /* See LICENSE of license details. */
 
-#include <errno.h>
 #include "stub.h"
 #include "weak_under_alias.h"
+#include <errno.h>
+#if defined(SEMIHOSTING)
 #include "semihosting.h"
+#endif
 
-int __wrap_open(const char* name, int flags, int mode)
-{
+int __wrap_open(const char *name, int flags, int mode) {
 #if defined(SEMIHOSTING)
   int fd = sh_open(name, mode);
   return fd;
diff --git a/libwrap/sys/printf.c b/libwrap/sys/printf.c
index 139116f..a5a2bcb 100644
--- a/libwrap/sys/printf.c
+++ b/libwrap/sys/printf.c
@@ -3,60 +3,49 @@
 
 #include <stdarg.h>
 #include <stddef.h>
-#include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <unistd.h>
-//#include "semihosting.h"
 
 #undef putchar
-int putchar(int ch)
-{
-  return write(STDOUT_FILENO, &ch, 1) == 1 ? ch : -1;
-}
+int putchar(int ch) { return write(STDOUT_FILENO, &ch, 1) == 1 ? ch : -1; }
 
-size_t strnlen (const char *str, size_t n)
-{
+size_t strnlen(const char *str, size_t n) {
   const char *start = str;
-  while (n-- > 0 && *str) str++;
+  while (n-- > 0 && *str)
+    str++;
   return str - start;
 }
 
-static void fprintf_putch(int ch, void** data)
-{
-  putchar(ch);
-}
-static void sprintf_putch(int ch, void** data)
-{
-  char** pstr = (char**)data;
+static void fprintf_putch(int ch, void **data) { putchar(ch); }
+static void sprintf_putch(int ch, void **data) {
+  char **pstr = (char **)data;
   **pstr = ch;
   (*pstr)++;
 }
 
-static unsigned long getuint(va_list *ap, int lflag)
-{
+static unsigned long getuint(va_list *ap, int lflag) {
   if (lflag)
     return va_arg(*ap, unsigned long);
   else
     return va_arg(*ap, unsigned int);
 }
 
-static long getint(va_list *ap, int lflag)
-{
+static long getint(va_list *ap, int lflag) {
   if (lflag)
     return va_arg(*ap, long);
   else
     return va_arg(*ap, int);
 }
 
-static inline void printnum(void (*putch)(int, void**), void **putdat,
-                    unsigned long num, unsigned base, int width, int padc)
-{
-  unsigned digs[sizeof(num)*8];
+static inline void printnum(void (*putch)(int, void **), void **putdat,
+                            unsigned long num, unsigned base, int width,
+                            int padc) {
+  unsigned digs[sizeof(num) * 8];
   int pos = 0;
 
-  while (1)
-  {
+  while (1) {
     digs[pos++] = num % base;
     if (num < base)
       break;
@@ -70,9 +59,8 @@ static inline void printnum(void (*putch)(int, void**), void **putdat,
     putch(digs[pos] + (digs[pos] >= 10 ? 'a' - 10 : '0'), putdat);
 }
 
-static inline void print_double(void (*putch)(int, void**), void **putdat,
-                                double num, int width, int prec)
-{
+static inline void print_double(void (*putch)(int, void **), void **putdat,
+                                double num, int width, int prec) {
   union {
     double d;
     uint64_t u;
@@ -88,30 +76,30 @@ static inline void print_double(void (*putch)(int, void**), void **putdat,
     u.d *= 10;
 
   char buf[32], *pbuf = buf;
-  printnum(sprintf_putch, (void**)&pbuf, (unsigned long)u.d, 10, 0, 0);
+  printnum(sprintf_putch, (void **)&pbuf, (unsigned long)u.d, 10, 0, 0);
   if (prec > 0) {
     for (int i = 0; i < prec; i++) {
-      pbuf[-i] = pbuf[-i-1];
+      pbuf[-i] = pbuf[-i - 1];
     }
     pbuf[-prec] = '.';
     pbuf++;
   }
 
-  for (char* p = buf; p < pbuf; p++)
+  for (char *p = buf; p < pbuf; p++)
     putch(*p, putdat);
 }
 
-static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap)
-{
-  register const char* p;
-  const char* last_fmt;
+static void vprintfmt(void (*putch)(int, void **), void **putdat,
+                      const char *fmt, va_list ap) {
+  register const char *p;
+  const char *last_fmt;
   register int ch;
   unsigned long num;
   int base, lflag, width, precision;
   char padc;
 
   while (1) {
-    while ((ch = *(const char *) fmt) != '%') {
+    while ((ch = *(const char *)fmt) != '%') {
       if (ch == '\0')
         return;
       fmt++;
@@ -126,13 +114,13 @@ static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt
     precision = -1;
     lflag = 0;
   reswitch:
-    switch (ch = *(const char *) fmt++) {
+    switch (ch = *(const char *)fmt++) {
 
     // flag to pad on the right
     case '-':
       padc = '-';
       goto reswitch;
-      
+
     // flag to pad with 0's instead of spaces
     case '0':
       padc = '0';
@@ -148,7 +136,7 @@ static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt
     case '7':
     case '8':
     case '9':
-      for (precision = 0; ; ++fmt) {
+      for (precision = 0;; ++fmt) {
         precision = precision * 10 + ch - '0';
         ch = *fmt;
         if (ch < '0' || ch > '9')
@@ -173,61 +161,62 @@ static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt
         width = precision, precision = -1;
       goto reswitch;
 
-    case 'l':    // long flag
+    case 'l': // long flag
       if (lflag)
         goto bad;
       goto reswitch;
-    case 'c':    // character
+    case 'c': // character
       putch(va_arg(ap, int), putdat);
       break;
-    case 'f':    // double
+    case 'f': // double
       print_double(putch, putdat, va_arg(ap, double), width, precision);
       break;
-    case 's':    // string
+    case 's': // string
       if ((p = va_arg(ap, char *)) == NULL)
         p = "(null)";
       if (width > 0 && padc != '-')
         for (width -= strnlen(p, precision); width > 0; width--)
           putch(padc, putdat);
-      for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0); width--) {
+      for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0);
+           width--) {
         putch(ch, putdat);
         p++;
       }
       for (; width > 0; width--)
         putch(' ', putdat);
       break;
-    case 'd':    // (signed) decimal
+    case 'd': // (signed) decimal
       num = getint(&ap, lflag);
-      if ((long) num < 0) {
+      if ((long)num < 0) {
         putch('-', putdat);
-        num = -(long) num;
+        num = -(long)num;
       }
       base = 10;
       goto signed_number;
-    case 'u':    // unsigned decimal
+    case 'u': // unsigned decimal
       base = 10;
       goto unsigned_number;
     case 'o': // (unsigned) octal
       // should do something with padding so it's always 3 octits
       base = 8;
       goto unsigned_number;
-    case 'p':// pointer
+    case 'p': // pointer
       lflag = 1;
       putch('0', putdat);
       putch('x', putdat);
       /* fall through to 'x' */
       __attribute__((fallthrough));
-    case 'x':    // (unsigned) hexadecimal
+    case 'x': // (unsigned) hexadecimal
       base = 16;
-      unsigned_number:
+    unsigned_number:
       num = getuint(&ap, lflag);
-      signed_number:
+    signed_number:
       printnum(putch, putdat, num, base, width, padc);
       break;
-    case '%':    // escaped '%' character
+    case '%': // escaped '%' character
       putch(ch, putdat);
       break;
-    default:    // unrecognized escape sequence - just print it literally
+    default: // unrecognized escape sequence - just print it literally
     bad:
       putch('%', putdat);
       fmt = last_fmt;
@@ -236,8 +225,7 @@ static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt
   }
 }
 
-int __wrap_printf(const char* fmt, ...)
-{
+int __wrap_printf(const char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
 
@@ -247,13 +235,12 @@ int __wrap_printf(const char* fmt, ...)
   return 0; // incorrect return value, but who cares, anyway?
 }
 
-int __wrap_sprintf(char* str, const char* fmt, ...)
-{
+int __wrap_sprintf(char *str, const char *fmt, ...) {
   va_list ap;
-  char* str0 = str;
+  char *str0 = str;
   va_start(ap, fmt);
 
-  vprintfmt(sprintf_putch, (void**)&str, fmt, ap);
+  vprintfmt(sprintf_putch, (void **)&str, fmt, ap);
   *str = 0;
 
   va_end(ap);
diff --git a/libwrap/sys/puts.c b/libwrap/sys/puts.c
index a88f0b4..69e5dae 100644
--- a/libwrap/sys/puts.c
+++ b/libwrap/sys/puts.c
@@ -6,9 +6,11 @@
 #include <unistd.h>
 
 #include "platform.h"
-#include "semihosting.h"
 #include "stub.h"
 #include "weak_under_alias.h"
+#if defined(SEMIHOSTING)
+#include "semihosting.h"
+#endif
 
 int __wrap_puts(const char *s) {
 #if defined(SEMIHOSTING)
diff --git a/libwrap/sys/read.c b/libwrap/sys/read.c
index b9269ac..389ae6b 100644
--- a/libwrap/sys/read.c
+++ b/libwrap/sys/read.c
@@ -6,9 +6,11 @@
 #include <unistd.h>
 
 #include "platform.h"
-#include "semihosting.h"
 #include "stub.h"
 #include "weak_under_alias.h"
+#if defined(SEMIHOSTING)
+#include "semihosting.h"
+#endif
 
 ssize_t __wrap_read(int fd, void *ptr, size_t len) {
   uint8_t *current = (uint8_t *)ptr;
diff --git a/libwrap/sys/unlink.c b/libwrap/sys/unlink.c
index 5355a66..3433d9c 100644
--- a/libwrap/sys/unlink.c
+++ b/libwrap/sys/unlink.c
@@ -1,12 +1,13 @@
 /* See LICENSE of license details. */
 
-#include <errno.h>
 #include "stub.h"
 #include "weak_under_alias.h"
+#include <errno.h>
+#if defined(SEMIHOSTING)
 #include "semihosting.h"
+#endif
 
-int __wrap_unlink(const char* name)
-{
+int __wrap_unlink(const char *name) {
 #if defined(SEMIHOSTING)
   return sh_remove(name);
 #endif
diff --git a/libwrap/sys/write.c b/libwrap/sys/write.c
index 26ba15c..cc77a75 100644
--- a/libwrap/sys/write.c
+++ b/libwrap/sys/write.c
@@ -6,9 +6,11 @@
 #include <unistd.h>
 
 #include "platform.h"
-#include "semihosting.h"
 #include "stub.h"
 #include "weak_under_alias.h"
+#if defined(SEMIHOSTING)
+#include "semihosting.h"
+#endif
 
 ssize_t __wrap_write(int fd, const void *ptr, size_t len) {
   const uint8_t *current = (const uint8_t *)ptr;