diff --git a/vmkit/configure.ac b/vmkit/configure.ac
index 9ed2663..73849c5 100644
--- a/vmkit/configure.ac
+++ b/vmkit/configure.ac
@@ -87,38 +87,86 @@
 dnl **************************************************************************
 AC_HEADER_STDC
 
-AC_ARG_WITH(readline,
-  [AS_HELP_STRING([--without-readline],
-    [disable readline support])],
-    [with_readline=$enableval],[with_readline=yes]
+dnl **************************************************************************
+dnl Checks for header files.
+dnl **************************************************************************
+AC_HEADER_STDC
+
+case $target_os in
+  *linux*)
+  dnl libiberty, libopcode and libbfd are part of binutils
+  AC_CHECK_HEADER([bfd.h], [], \
+    AC_MSG_ERROR([You need to install the binutils devel package (bfd.h).])
+  )
+  AC_CHECK_HEADER([dis-asm.h], [], \
+    AC_MSG_ERROR([You need to install the binutils devel package (dis-asm.h).])
+  )
+  ;;
+esac
+
+AC_CHECK_HEADER([zlib.h], [], \
+  AC_MSG_ERROR([You need to install the zlib devel package (zlib.h).])
 )
 
-AS_IF([test "x$with_readline" = xyes],
-  [AC_CHECK_HEADER([readline/readline.h],
-	  [AC_DEFINE(HAVE_READLINE_H,1,[readline found])],
-	  [AC_MSG_WARN(readline NOT found)])
-    AC_CHECK_LIB(readline, history_truncate_file, [],
-     [AC_MSG_ERROR([You need to install readline version 5.])])
-    ]
+dnl **************************************************************************
+dnl Checks for libraries    
+dnl **************************************************************************
+case $target_os in
+  *darwin*)
+    rdynamic=""
+    ;;
+  *linux*)
+    AC_CHECK_LIB(iberty, xexit, [], \
+      [AC_MSG_ERROR([You need to install the binutils package (iberty).])]
+    )
+    AC_CHECK_LIB(bfd, bfd_get_arch, [], \
+      [AC_MSG_ERROR([You need to install the binutils package (bfd).])],
+    -liberty
+    )
+    AC_CHECK_LIB(opcodes, disassembler, [], \
+      [AC_MSG_ERROR([You need to install the binutils package (opcodes).])],
+    -lbfd -liberty
+    )
+    
+    rdynamic="-rdynamic"
+    AC_DEFINE([HAVE_DISASSEMBLER], [1], [Using libopcodes])
+
+    ;;
+  *) AC_MSG_ERROR([$target_os target is not supported.]);;
+esac
+
+AC_CHECK_LIB(z, inflate, [], \
+  [AC_MSG_ERROR([You need to install the zlib package (z).])]
 )
 
-AC_ARG_WITH(bare,
-  [AS_HELP_STRING([--with-bare], [bare VVMos support])],
-    [with_bare=$enableval],[with_bare=no]
-)
-
-bare_header=""
-AM_CONDITIONAL([BARE], [test "x$vvmthreadtype" != "xno"])
-if test "x$with_bare" != xno; then
-  AC_DEFINE([BARE], [1], [bare VVMos support])
-  bare_header=-I$PWD/../bare/include/
-fi
-
-AC_SUBST([bare_header])
-AC_SUBST([mksyms])
 AC_SUBST([rdynamic])
 AC_SUBST([LLVMDYLIB])
 
+dnl **************************************************************************
+dnl VVM thread type
+dnl **************************************************************************
+AC_ARG_WITH(vvm-thread-type,
+       [AS_HELP_STRING(--with-vvm-thread-type=something,
+           [VVM Thread type ('common' or 'no')])],
+       [vvmthreadtype=$withval],[vvmthreadtype=common]
+)
+
+AS_IF([test "x$vvmthreadtype" != "xno"],
+  [AC_CHECK_HEADER([pthread.h],,
+    [AC_MSG_WARN(phtread include NOT found)])
+  AC_CHECK_LIB(pthread, pthread_create, [], 
+     [AC_MSG_ERROR([pthread library not found])])
+  ]
+)
+
+AM_CONDITIONAL([HAVE_PTHREAD], [test "x$vvmthreadtype" != "xno"])
+if test "x$vvmthreadtype" = xcommon; then
+  AC_DEFINE([HAVE_PTHREAD], [1], [Using pthread library])
+fi
+
+AC_SUBST([vvmthreadtype])
+GCTHREAD_SUBDIRS="$GCTHREAD_SUBDIRS $vvmthreadtype-thread"
+
 
 dnl **************************************************************************
 dnl Checks for typedefs, structures, and compiler characteristics.
@@ -133,36 +181,11 @@
 
 
 dnl **************************************************************************
-dnl VVM thread type
-dnl **************************************************************************
-AC_ARG_WITH(vvm-thread-type,
-       [AS_HELP_STRING(--with-vvm-thread-type=something,
-           [VVM Thread type ('common' or 'no')])],
-       [vvmthreadtype=$withval],[vvmthreadtype=common]
-)
-
-AS_IF([test "x$vvmthreadtype" != "xno"],
-  [AC_CHECK_HEADER([pthread.h],,
-    [AC_MSG_WARN(phtread include NOT found)])
-  AC_CHECK_LIB(pthread, pthread_create, [],
-     [AC_MSG_ERROR([pthread library not found])])
-  ]
-)
-
-AM_CONDITIONAL([HAVE_PTHREAD], [test "x$vvmthreadtype" != "xno"])
-if test "x$vvmthreadtype" = xcommon; then
-  AC_DEFINE([HAVE_PTHREAD], [1], [Using pthread library])
-fi
-
-AC_SUBST([vvmthreadtype])
-GCTHREAD_SUBDIRS="$GCTHREAD_SUBDIRS $vvmthreadtype-thread"
-
-dnl **************************************************************************
 dnl VVM GC type 
 dnl **************************************************************************
 AC_ARG_WITH(vvm-gc-type,
        [AS_HELP_STRING(--with-vvm-gc-type=something,
-           [VVM GC type ('gen2', 'mmap2' or 'simple2')])],
+           [VVM GC type ('mmap2' or 'boehm')])],
        [[vvmgctype=$withval]],
        [[ echo Using mmap2 as vvm gc type.
         	vvmgctype=mmap2
diff --git a/vmkit/include/mvm/JIT.h b/vmkit/include/mvm/JIT.h
index 93e2320..049d664 100644
--- a/vmkit/include/mvm/JIT.h
+++ b/vmkit/include/mvm/JIT.h
@@ -156,6 +156,7 @@
 
 extern void protectConstants();
 extern void unprotectConstants();
+extern int disassemble(unsigned int* addr);
 
 
 } // end namespace jit
diff --git a/vmkit/lib/JnJVM/Classpath/Makefile.am b/vmkit/lib/JnJVM/Classpath/Makefile.am
index 9628de6..a15a072 100644
--- a/vmkit/lib/JnJVM/Classpath/Makefile.am
+++ b/vmkit/lib/JnJVM/Classpath/Makefile.am
@@ -1,4 +1,3 @@
-# $Id: Makefile.am,v 1.6 2008/03/21 11:12:38 varth Exp $
 lib_LTLIBRARIES = libClasspath.la
 
 THREADDIR=../../Mvm/CommonThread
@@ -8,7 +7,6 @@
 	    -I../VMCore
 
 PREFIX=@prefix@
-LIBSUVM=$(LIBLLVM) $(LIBGC) $(LIBALLOC) $(LIBTHREAD)
 
 libClasspath_la_SOURCES = \
 	ClasspathVMSystem.cpp ClasspathVMSystem.h Classpath.cpp \
diff --git a/vmkit/lib/JnJVM/Makefile.am b/vmkit/lib/JnJVM/Makefile.am
index 56ec573..bd39ad9 100644
--- a/vmkit/lib/JnJVM/Makefile.am
+++ b/vmkit/lib/JnJVM/Makefile.am
@@ -12,14 +12,13 @@
 LIBTHREAD=$(THREADDIR)/libuvm_@vvmthreadtype@_thread.a
 LIBALLOC=$(ALLOCDIR)/libuvm_alloc.a
 LIBGC=$(GCDIR)/libuvm_gc_@vvmgctype@.a @GC_LIBS@
-PREFIX=@prefix@
-LIBSUVM=$(LIBLLVM) $(LIBGC) $(LIBALLOC) $(LIBTHREAD)
+LIBSUVM=$(LIBGC) $(LIBALLOC) $(LIBTHREAD)
 
 main_SOURCES = ../Mvm/Object.cc ../Mvm/Sigsegv.cc Main.cpp ../Mvm/MvmMemoryManager.cpp ../Mvm/JIT.cc ../Mvm/EscapeAnalysis.cpp
 
 
 main_CXXFLAGS = $(libJnJVM_la_CXXFLAGS)
-main_LDADD = VMCore/.libs/libJnJVM.a Classpath/.libs/libClasspath.a $(LIBSUVM) @LLVMDYLIB@ -lopcodes -lbfd -liberty -lz
+main_LDADD = VMCore/.libs/libJnJVM.a Classpath/.libs/libClasspath.a $(LIBSUVM) @LLVMDYLIB@
 main_LDFLAGS = @rdynamic@
 
 libjnjvm.la:
diff --git a/vmkit/lib/JnJVM/VMCore/JavaJIT.cpp b/vmkit/lib/JnJVM/VMCore/JavaJIT.cpp
index 729e002..fea3dfe 100644
--- a/vmkit/lib/JnJVM/VMCore/JavaJIT.cpp
+++ b/vmkit/lib/JnJVM/VMCore/JavaJIT.cpp
@@ -256,71 +256,6 @@
   return llvmFunction;
 }
 
-#if defined __PPC__
-extern "C"
-{
-# include <dis-asm.h>
-# include <bfd.h>
-};
-
-
-
-static struct disassemble_info  info;
-static int      initialised= 0;  
-
-// this is the only function exported from this file
-
-extern "C" int disassemble(unsigned int *addr)
-{
-  
-  if (!initialised)
-    {   
-      INIT_DISASSEMBLE_INFO(info, stdout, fprintf);
-      info.flavour=   bfd_target_elf_flavour;
-      info.arch=    bfd_arch_powerpc;
-      info.mach=    bfd_mach_ppc_750; // generic(ish) == PPC G3
-      info.endian=    BFD_ENDIAN_BIG;
-      info.buffer_length= 65536;
-    }   
-  info.buffer=     (bfd_byte *)addr;
-  info.buffer_vma= (bfd_vma)(long)addr;
-  return print_insn_big_powerpc((bfd_vma)(long)addr, &info);
-  
-}
-
-#else
-extern "C"
-{
-# include <bfd.h>	// bfd types
-# include <dis-asm.h>	// disassemble_info
-  int print_insn_i386_att(bfd_vma, disassemble_info *);
-};
-
-
-static struct disassemble_info	info;
-static int			initialised= 0;
-
-// this is the only function exported from this file
-
-extern "C" int disassemble(unsigned int *addr)
-{
-  if (!initialised)
-    {
-      INIT_DISASSEMBLE_INFO(info, stdout, fprintf);
-      info.flavour=	  bfd_target_elf_flavour;
-      info.arch=	  bfd_arch_i386;
-      info.mach=	  bfd_mach_i386_i386;
-      info.endian=	  BFD_ENDIAN_LITTLE;
-      info.buffer_length= 65536;
-    }
-  info.buffer=	   (bfd_byte *)addr;
-  info.buffer_vma= (bfd_vma)(long)addr;
-  return print_insn_i386_att((bfd_vma)(long)addr, &info);
-}
-
-#endif
-
-
 void JavaJIT::beginSynchronize() {
   std::vector<Value*> argsSync;
   if (isVirtual(compilingMethod->access)) {
@@ -591,7 +526,7 @@
     void* base = res;
     while (base <  (void*)((char*)res + ((mvm::Code*)res)->objectSize())) {
       printf("%08x\t", (unsigned)base);
-      int n= disassemble((unsigned int *)base);
+      int n= mvm::jit::disassemble((unsigned int *)base);
       printf("\n");
       base= ((void *)((char *)base + n));
     }
diff --git a/vmkit/lib/JnJVM/VMCore/Makefile.am b/vmkit/lib/JnJVM/VMCore/Makefile.am
index c4706db..cd1bb63 100644
--- a/vmkit/lib/JnJVM/VMCore/Makefile.am
+++ b/vmkit/lib/JnJVM/VMCore/Makefile.am
@@ -1,4 +1,3 @@
-# $Id: Makefile.am,v 1.7 2008/03/21 11:12:38 varth Exp $
 EXTRA_DIST = OpcodeNames.def
 lib_LTLIBRARIES = libJnJVM.la
 
diff --git a/vmkit/lib/Mvm/Allocator/Makefile.am b/vmkit/lib/Mvm/Allocator/Makefile.am
index 3c79965..768e41a 100644
--- a/vmkit/lib/Mvm/Allocator/Makefile.am
+++ b/vmkit/lib/Mvm/Allocator/Makefile.am
@@ -1,4 +1,3 @@
-# $Id: Makefile.am,v 1.2 2008/03/21 11:12:38 varth Exp $
 noinst_LIBRARIES = libuvm_alloc.a
 noinst_PROGRAMS = mainuvm_alloc
 
diff --git a/vmkit/lib/Mvm/Disassembler.cc b/vmkit/lib/Mvm/Disassembler.cc
new file mode 100644
index 0000000..ac33203
--- /dev/null
+++ b/vmkit/lib/Mvm/Disassembler.cc
@@ -0,0 +1,91 @@
+//===--------- Disassembler.cc - Intefarce to disassembler ----------------===//
+//
+//                      Micro Virtual Machine
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mvm/JIT.h"
+
+#ifdef HAVE_DISASSEMBLER
+
+#if defined(__PPC__)
+extern "C"
+{
+# include <dis-asm.h>
+# include <bfd.h>
+}
+
+
+
+static struct disassemble_info  info;
+static int      initialised= 0;  
+
+// this is the only function exported from this file
+
+int mvm::jit::disassemble(unsigned int *addr)
+{
+  
+  if (!initialised)
+    {   
+      INIT_DISASSEMBLE_INFO(info, stdout, fprintf);
+      info.flavour=   bfd_target_elf_flavour;
+      info.arch=    bfd_arch_powerpc;
+      info.mach=    bfd_mach_ppc_750; // generic(ish) == PPC G3
+      info.endian=    BFD_ENDIAN_BIG;
+      info.buffer_length= 65536;
+    }   
+  info.buffer=     (bfd_byte *)addr;
+  info.buffer_vma= (bfd_vma)(long)addr;
+  return print_insn_big_powerpc((bfd_vma)(long)addr, &info);
+  
+}
+
+#elif defined(__i386__)
+extern "C"
+{
+# include <bfd.h>	// bfd types
+# include <dis-asm.h>	// disassemble_info
+  int print_insn_i386_att(bfd_vma, disassemble_info *);
+};
+
+
+static struct disassemble_info	info;
+static int			initialised= 0;
+
+
+int mvm::jit::disassemble(unsigned int *addr)
+{
+  if (!initialised)
+    {
+      INIT_DISASSEMBLE_INFO(info, stdout, fprintf);
+      info.flavour=	  bfd_target_elf_flavour;
+      info.arch=	  bfd_arch_i386;
+      info.mach=	  bfd_mach_i386_i386;
+      info.endian=	  BFD_ENDIAN_LITTLE;
+      info.buffer_length= 65536;
+    }
+  info.buffer=	   (bfd_byte *)addr;
+  info.buffer_vma= (bfd_vma)(long)addr;
+  return print_insn_i386_att((bfd_vma)(long)addr, &info);
+}
+
+#else
+
+int mvm::jit::disassemble(unsigned int* addr) {
+  return 0;
+}
+
+#endif
+
+#else
+
+int mvm::jit::disassemble(unsigned int* addr) {
+  return 0;
+}
+
+#endif
+
+
diff --git a/vmkit/lib/Mvm/GCMmap2/Makefile.am b/vmkit/lib/Mvm/GCMmap2/Makefile.am
index 1f4f06b..2d7871c 100644
--- a/vmkit/lib/Mvm/GCMmap2/Makefile.am
+++ b/vmkit/lib/Mvm/GCMmap2/Makefile.am
@@ -1,4 +1,3 @@
-# $Id: Makefile.am,v 1.3 2008/03/21 16:25:31 varth Exp $
 noinst_LIBRARIES = libuvm_gc_mmap2.a
 noinst_PROGRAMS = mainuvm_gc_mmap2
 
diff --git a/vmkit/lib/Mvm/Makefile.am b/vmkit/lib/Mvm/Makefile.am
index cfbf317..160da70 100644
--- a/vmkit/lib/Mvm/Makefile.am
+++ b/vmkit/lib/Mvm/Makefile.am
@@ -7,17 +7,16 @@
 THREADDIR=CommonThread
 ALLOCDIR=Allocator
 GCDIR=GCMmap2
-INCLUDEDIRS=-I@srcdir@/$(THREADDIR) -I@srcdir@/$(ALLOCDIR) -I@srcdir@/$(GCDIR)\
-	    @bare_header@
+INCLUDEDIRS=-I@srcdir@/$(THREADDIR) -I@srcdir@/$(ALLOCDIR) -I@srcdir@/$(GCDIR)
 
 LIBTHREAD=$(THREADDIR)/libuvm_@vvmthreadtype@_thread.a
 LIBALLOC=$(ALLOCDIR)/libuvm_alloc.a
 LIBGC=$(GCDIR)/libuvm_gc_@vvmgctype@.a @GC_LIBS@
 MAIN_O=main-main.o
-LIBSUVM=$(LIBLLVM) $(LIBGC) $(LIBALLOC) $(LIBTHREAD)
+LIBSUVM=$(LIBGC) $(LIBALLOC) $(LIBTHREAD)
 PREFIX=@prefix@
 
-main_SOURCES = Main.cc Object.cc Sigsegv.cc JIT.cc CommandLine.cpp CommandLine.h MvmMemoryManager.h MvmMemoryManager.cpp EscapeAnalysis.cpp
+main_SOURCES = Main.cc Object.cc Sigsegv.cc JIT.cc CommandLine.cpp CommandLine.h MvmMemoryManager.h MvmMemoryManager.cpp EscapeAnalysis.cpp Disassembler.cc
 main_CXXFLAGS = $(INCLUDEDIRS) -DPREFIX=\"$(PREFIX)\" -W -Wall -ansi -Wno-unused-parameter -pedantic -Wno-long-long -fno-omit-frame-pointer -O2 -g
 main_LDFLAGS=@rdynamic@
-main_LDADD = $(LIBSUVM) @LLVMDYLIB@ -lopcodes -lbfd -liberty
+main_LDADD = $(LIBSUVM) @LLVMDYLIB@
diff --git a/vmkit/lib/N3/Makefile.am b/vmkit/lib/N3/Makefile.am
index 7c7a28c..54502da 100644
--- a/vmkit/lib/N3/Makefile.am
+++ b/vmkit/lib/N3/Makefile.am
@@ -10,11 +10,10 @@
 LIBALLOC=$(ALLOCDIR)/libuvm_alloc.a
 LIBGC=$(GCDIR)/libuvm_gc_@vvmgctype@.a @GC_LIBS@
 PREFIX=@prefix@
-LIBSUVM=$(LIBLLVM) $(LIBGC) $(LIBALLOC) $(LIBTHREAD)
+LIBSUVM=$(LIBGC) $(LIBALLOC) $(LIBTHREAD)
 
 main_SOURCES = ../Mvm/Object.cc ../Mvm/Sigsegv.cc Main.cpp ../Mvm/MvmMemoryManager.cpp ../Mvm/JIT.cc ../Mvm/EscapeAnalysis.cpp
 
-
-main_CXXFLAGS = $(libJnJVM_la_CXXFLAGS)
-main_LDADD = VMCore/.libs/libN3.a $(LIBSUVM) @LLVMDYLIB@ -lopcodes -lbfd -liberty
+main_CXXFLAGS = $(INCLUDEDIRS) -DPREFIX=\"$(PREFIX)\" -W -Wall -ansi -Wno-unused-parameter -Wno-long-long -Wno-unused-function -fno-omit-frame-pointer -g -Werror -O2
+main_LDADD = VMCore/.libs/libN3.a $(LIBSUVM) @LLVMDYLIB@
 main_LDFLAGS = @rdynamic@
diff --git a/vmkit/lib/N3/VMCore/Makefile.am b/vmkit/lib/N3/VMCore/Makefile.am
index 044fc2c..31d89d4 100644
--- a/vmkit/lib/N3/VMCore/Makefile.am
+++ b/vmkit/lib/N3/VMCore/Makefile.am
@@ -1,4 +1,3 @@
-# $Id: Makefile.am,v 1.4 2008/03/21 11:12:39 varth Exp $
 EXTRA_DIST = SignatureNames.def OpcodeNames.def
 lib_LTLIBRARIES = libN3.la
 
