diff --git a/Makefile.in b/Makefile.in
index 871393005ed5c7f6219f1d3f2559fe1bc82b79de..20506afaf6939ed7fb63ac0339ac571de20be9b9 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -111,7 +111,7 @@ lib/libdarshan-posix.a: lib/darshan-posix.o lib/lookup3.o lib/lookup8.o
 	ar rcs $@ $^
 
 lib/libdarshan.so: lib/darshan-mpi-io.po lib/darshan-pnetcdf.po lib/darshan-hdf5.po lib/darshan-posix.po lib/lookup3.po lib/lookup8.po
-	$(CC) $(CFLAGS_MPI_SHARED) -ldl -o $@ $^
+	gcc $(CFLAGS_MPI_SHARED) -ldl -o $@ $^ -lpthread -lrt
 
 install:: all
 	install -d $(libdir)
diff --git a/lib/darshan-hdf5.c b/lib/darshan-hdf5.c
index f0469b7f6c14b91b87e3b0e1ba5ef6911e091e8f..6de2bcce17cb269f46cfbb24ff13400410bc5348 100644
--- a/lib/darshan-hdf5.c
+++ b/lib/darshan-hdf5.c
@@ -16,11 +16,25 @@ typedef int herr_t;
 
 #ifdef DARSHAN_PRELOAD
 
+#define __USE_GNU
+#include <dlfcn.h>
+#include <stdlib.h>
+
 #define DARSHAN_FORWARD_DECL(name,ret,args) \
   ret (*__real_ ## name)args = NULL;
 
 #define DARSHAN_DECL(__name) __name
 
+#define MAP_OR_FAIL(func) \
+    if (!(__real_ ## func)) \
+    { \
+        __real_ ## func = dlsym(RTLD_NEXT, #func); \
+        if(!(__real_ ## func)) { \
+            fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
+            exit(1); \
+        } \
+    }
+
 #else
 
 #define DARSHAN_FORWARD_DECL(name,ret,args) \
@@ -28,33 +42,14 @@ typedef int herr_t;
 
 #define DARSHAN_DECL(__name) __wrap_ ## __name
 
+#define MAP_OR_FAIL(func) 
+
 #endif
 
 DARSHAN_FORWARD_DECL(H5Fcreate, hid_t, (const char *filename, unsigned flags, hid_t create_plist, hid_t access_plist));
 DARSHAN_FORWARD_DECL(H5Fopen, hid_t, (const char *filename, unsigned flags, hid_t access_plist));
 DARSHAN_FORWARD_DECL(H5Fclose, herr_t, (hid_t file_id));
 
-#ifdef DARSHAN_PRELOAD
-#define __USE_GNU
-#include <dlfcn.h>
-#include <stdlib.h>
-static void __attribute__ ((constructor)) darshan_ldpreload_init(void)
-{
-#define MAP_OR_FAIL(func) \
-    __real_ ## func = dlsym(RTLD_NEXT, #func); \
-    if(!(__real_ ## func)) { \
-        fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
-        exit(1); \
-    }
-
-    MAP_OR_FAIL(H5Fcreate);
-    MAP_OR_FAIL(H5Fopen);
-    MAP_OR_FAIL(H5Fclose);
-
-    return;
-}
-#endif
-
 static struct darshan_file_runtime* darshan_file_by_hid(int hid);
 
 hid_t DARSHAN_DECL(H5Fcreate)(const char *filename, unsigned flags,
@@ -65,6 +60,8 @@ hid_t DARSHAN_DECL(H5Fcreate)(const char *filename, unsigned flags,
     char* tmp;
     int hash_index;
 
+    MAP_OR_FAIL(H5Fcreate);
+
     ret = __real_H5Fcreate(filename, flags, create_plist, access_plist);
     if(ret >= 0)
     {  
@@ -106,6 +103,8 @@ hid_t DARSHAN_DECL(H5Fopen)(const char *filename, unsigned flags,
     char* tmp;
     int hash_index;
 
+    MAP_OR_FAIL(H5Fopen);
+
     ret = __real_H5Fopen(filename, flags, access_plist);
     if(ret >= 0)
     {  
@@ -148,6 +147,8 @@ herr_t DARSHAN_DECL(H5Fclose)(hid_t file_id)
     int tmp_hid = file_id;
     int ret;
 
+    MAP_OR_FAIL(H5Fclose);
+
     ret = __real_H5Fclose(file_id);
 
     CP_LOCK();
diff --git a/lib/darshan-mpi-io.c b/lib/darshan-mpi-io.c
index ca140fa4a6c17426b2f9dd40e1c656fff64d2528..a1e09d7222b4a90f209bbef66ee2da77dd3d153a 100644
--- a/lib/darshan-mpi-io.c
+++ b/lib/darshan-mpi-io.c
@@ -27,6 +27,137 @@
 #include "mpi.h"
 #include "darshan.h"
 
+#ifdef DARSHAN_PRELOAD
+#include <dlfcn.h>
+#include <stdlib.h>
+
+#define DARSHAN_MPI_CALL(func) __real_ ## func
+
+#define DARSHAN_FORWARD_DECL(name,ret,args) \
+  ret (*__real_ ## name)args = NULL;
+
+#define MAP_OR_FAIL(func) \
+    __real_ ## func = dlsym(RTLD_NEXT, #func); \
+    if (!(__real_ ## func)) { \
+        fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
+    }
+
+DARSHAN_FORWARD_DECL(PMPI_File_close, int, (MPI_File *fh));
+DARSHAN_FORWARD_DECL(PMPI_File_set_size, int, (MPI_File fh, MPI_Offset size));
+DARSHAN_FORWARD_DECL(PMPI_File_iread_at, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
+DARSHAN_FORWARD_DECL(PMPI_File_iread, int, (MPI_File fh, void  *buf, int  count, MPI_Datatype  datatype, MPI_Request  *request));
+DARSHAN_FORWARD_DECL(PMPI_File_iread_shared, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
+DARSHAN_FORWARD_DECL(PMPI_File_iwrite_at, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
+DARSHAN_FORWARD_DECL(PMPI_File_iwrite, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
+DARSHAN_FORWARD_DECL(PMPI_File_iwrite_shared, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request));
+DARSHAN_FORWARD_DECL(PMPI_File_open, int, (MPI_Comm comm, char *filename, int amode, MPI_Info info, MPI_File *fh));
+DARSHAN_FORWARD_DECL(PMPI_File_read_all_begin, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype));
+DARSHAN_FORWARD_DECL(PMPI_File_read_all, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_read_at_all, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_read_at_all_begin, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype));
+DARSHAN_FORWARD_DECL(PMPI_File_read_at, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_read, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_read_ordered_begin, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype));
+DARSHAN_FORWARD_DECL(PMPI_File_read_ordered, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_read_shared, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_set_view, int, (MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, char *datarep, MPI_Info info));
+DARSHAN_FORWARD_DECL(PMPI_File_sync, int, (MPI_File fh));
+DARSHAN_FORWARD_DECL(PMPI_File_write_all_begin, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype));
+DARSHAN_FORWARD_DECL(PMPI_File_write_all, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_write_at_all_begin, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype));
+DARSHAN_FORWARD_DECL(PMPI_File_write_at_all, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_write_at, int, (MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_write, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_write_ordered_begin, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype));
+DARSHAN_FORWARD_DECL(PMPI_File_write_ordered, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_File_write_shared, int, (MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status));
+DARSHAN_FORWARD_DECL(PMPI_Finalize, int, ());
+DARSHAN_FORWARD_DECL(PMPI_Init, int, (int *argc, char ***argv));
+DARSHAN_FORWARD_DECL(PMPI_Init_thread, int, (int *argc, char ***argv, int required, int *provided));
+
+DARSHAN_FORWARD_DECL(PMPI_Wtime, double, ());
+DARSHAN_FORWARD_DECL(PMPI_Allreduce, int, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+DARSHAN_FORWARD_DECL(PMPI_Bcast, int, (void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm));
+DARSHAN_FORWARD_DECL(PMPI_Comm_rank, int, (MPI_Comm comm, int *rank));
+DARSHAN_FORWARD_DECL(PMPI_Comm_size, int, (MPI_Comm comm, int *size));
+DARSHAN_FORWARD_DECL(PMPI_Scan, int, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm));
+DARSHAN_FORWARD_DECL(PMPI_Type_commit, int, (MPI_Datatype *datatype));
+DARSHAN_FORWARD_DECL(PMPI_Type_contiguous, int, (int count, MPI_Datatype oldtype, MPI_Datatype *newtype));
+DARSHAN_FORWARD_DECL(PMPI_Type_extent, int, (MPI_Datatype datatype, MPI_Aint *extent));
+DARSHAN_FORWARD_DECL(PMPI_Type_free, int, (MPI_Datatype *datatype));
+DARSHAN_FORWARD_DECL(PMPI_Type_hindexed, int, (int count, int *array_of_blocklengths, MPI_Aint *array_of_displacements, MPI_Datatype oldtype, MPI_Datatype *newtype));
+DARSHAN_FORWARD_DECL(PMPI_Op_create, int, (MPI_User_function *function, int commute, MPI_Op *op));
+DARSHAN_FORWARD_DECL(PMPI_Reduce, int, (void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm));
+DARSHAN_FORWARD_DECL(PMPI_Type_get_envelope, int, (MPI_Datatype datatype, int *num_integers, int *num_addresses, int *num_datatypes, int *combiner));
+DARSHAN_FORWARD_DECL(PMPI_Type_size, int, (MPI_Datatype datatype, int *size));
+
+void resolve_mpi_symbols (void)
+{
+    /*
+     * Overloaded functions
+     */
+    MAP_OR_FAIL(PMPI_File_close);
+    MAP_OR_FAIL(PMPI_File_set_size);
+    MAP_OR_FAIL(PMPI_File_iread_at);
+    MAP_OR_FAIL(PMPI_File_iread);
+    MAP_OR_FAIL(PMPI_File_iread_shared);
+    MAP_OR_FAIL(PMPI_File_iwrite_at);
+    MAP_OR_FAIL(PMPI_File_iwrite);
+    MAP_OR_FAIL(PMPI_File_iwrite_shared);
+    MAP_OR_FAIL(PMPI_File_open);
+    MAP_OR_FAIL(PMPI_File_read_all_begin);
+    MAP_OR_FAIL(PMPI_File_read_all);
+    MAP_OR_FAIL(PMPI_File_read_at_all_begin);
+    MAP_OR_FAIL(PMPI_File_read_at_all);
+    MAP_OR_FAIL(PMPI_File_read_at);
+    MAP_OR_FAIL(PMPI_File_read);
+    MAP_OR_FAIL(PMPI_File_read_ordered_begin);
+    MAP_OR_FAIL(PMPI_File_read_ordered);
+    MAP_OR_FAIL(PMPI_File_read_shared);
+    MAP_OR_FAIL(PMPI_File_set_view);
+    MAP_OR_FAIL(PMPI_File_sync);
+    MAP_OR_FAIL(PMPI_File_write_all_begin);
+    MAP_OR_FAIL(PMPI_File_write_all);
+    MAP_OR_FAIL(PMPI_File_write_at_all_begin);
+    MAP_OR_FAIL(PMPI_File_write_at_all);
+    MAP_OR_FAIL(PMPI_File_write_at);
+    MAP_OR_FAIL(PMPI_File_write);
+    MAP_OR_FAIL(PMPI_File_write_ordered_begin);
+    MAP_OR_FAIL(PMPI_File_write_ordered);
+    MAP_OR_FAIL(PMPI_File_write_shared);
+    MAP_OR_FAIL(PMPI_Finalize);
+    MAP_OR_FAIL(PMPI_Init);
+    MAP_OR_FAIL(PMPI_Init_thread);
+
+    /*
+     * These function are not intercepted but are used
+     * by darshan itself.
+     */
+    MAP_OR_FAIL(PMPI_Wtime);
+    MAP_OR_FAIL(PMPI_Allreduce);
+    MAP_OR_FAIL(PMPI_Bcast);
+    MAP_OR_FAIL(PMPI_Comm_rank);
+    MAP_OR_FAIL(PMPI_Comm_size);
+    MAP_OR_FAIL(PMPI_Scan);
+    MAP_OR_FAIL(PMPI_Type_commit);
+    MAP_OR_FAIL(PMPI_Type_contiguous);
+    MAP_OR_FAIL(PMPI_Type_extent);
+    MAP_OR_FAIL(PMPI_Type_free);
+    MAP_OR_FAIL(PMPI_Type_size);
+    MAP_OR_FAIL(PMPI_Type_hindexed);
+    MAP_OR_FAIL(PMPI_Op_create);
+    MAP_OR_FAIL(PMPI_Reduce);
+    MAP_OR_FAIL(PMPI_Type_get_envelope);
+
+    return;
+}
+
+#else
+
+#define DARSHAN_MPI_CALL(func) func
+
+#endif
+
 extern char* __progname;
 
 /* maximum number of memory segments each process will write to the log */
@@ -34,8 +165,8 @@ extern char* __progname;
 
 #define CP_DATATYPE_INC(__file, __datatype) do {\
     int num_integers, num_addresses, num_datatypes, combiner, ret; \
-    ret = MPI_Type_get_envelope(__datatype, &num_integers, &num_addresses, \
-        &num_datatypes, &combiner); \
+    ret = DARSHAN_MPI_CALL(PMPI_Type_get_envelope)(__datatype, &num_integers, \
+        &num_addresses, &num_datatypes, &combiner); \
     if(ret == MPI_SUCCESS) { \
         switch(combiner) { \
             case MPI_COMBINER_NAMED:\
@@ -85,9 +216,9 @@ extern char* __progname;
     if(__ret != MPI_SUCCESS) break; \
     file = darshan_file_by_fh(__fh); \
     if(!file) break; \
-    MPI_Type_size(__datatype, &size);  \
+    DARSHAN_MPI_CALL(PMPI_Type_size)(__datatype, &size);  \
     size = size * __count; \
-    MPI_Type_extent(__datatype, &extent); \
+    DARSHAN_MPI_CALL(PMPI_Type_extent)(__datatype, &extent); \
     CP_BUCKET_INC(file, CP_SIZE_WRITE_AGG_0_100, size); \
     CP_BUCKET_INC(file, CP_EXTENT_WRITE_0_100, extent); \
     CP_INC(file, __counter, 1); \
@@ -105,9 +236,9 @@ extern char* __progname;
     if(__ret != MPI_SUCCESS) break; \
     file = darshan_file_by_fh(__fh); \
     if(!file) break; \
-    MPI_Type_size(__datatype, &size);  \
+    DARSHAN_MPI_CALL(PMPI_Type_size)(__datatype, &size);  \
     size = size * __count; \
-    MPI_Type_extent(__datatype, &extent); \
+    DARSHAN_MPI_CALL(PMPI_Type_extent)(__datatype, &extent); \
     CP_BUCKET_INC(file, CP_SIZE_READ_AGG_0_100, size); \
     CP_BUCKET_INC(file, CP_EXTENT_READ_0_100, extent); \
     CP_INC(file, __counter, 1); \
@@ -164,7 +295,11 @@ int MPI_Init(int *argc, char ***argv)
 {
     int ret;
 
-    ret = PMPI_Init(argc, argv);
+#ifdef DARSHAN_PRELOAD
+    resolve_mpi_symbols();
+#endif
+
+    ret = DARSHAN_MPI_CALL(PMPI_Init)(argc, argv);
     if(ret != MPI_SUCCESS)
     {
         return(ret);
@@ -179,7 +314,7 @@ int MPI_Init_thread (int *argc, char ***argv, int required, int *provided)
 {
     int ret;
 
-    ret = PMPI_Init_thread(argc, argv, required, provided);
+    ret = DARSHAN_MPI_CALL(PMPI_Init_thread)(argc, argv, required, provided);
     if (ret != MPI_SUCCESS)
     {
         return(ret);
@@ -195,8 +330,8 @@ static void darshan_mpi_initialize(int *argc, char ***argv)
     int nprocs;
     int rank;
 
-    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    DARSHAN_MPI_CALL(PMPI_Comm_size)(MPI_COMM_WORLD, &nprocs);
+    DARSHAN_MPI_CALL(PMPI_Comm_rank)(MPI_COMM_WORLD, &rank);
 
     CP_LOCK();
     if(argc && argv)
@@ -256,7 +391,7 @@ void darshan_shutdown(int timing_flag)
     flags = final_job->flags;
     CP_UNLOCK();
 
-    start_log_time = MPI_Wtime();
+    start_log_time = DARSHAN_MPI_CALL(PMPI_Wtime)();
 
     /* figure out which access sizes to log */
     darshan_walk_file_accesses(final_job);
@@ -303,7 +438,7 @@ void darshan_shutdown(int timing_flag)
         return;
     }
 
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    DARSHAN_MPI_CALL(PMPI_Comm_rank)(MPI_COMM_WORLD, &rank);
 
     /* collect information about command line and 
      * mounted file systems 
@@ -319,12 +454,12 @@ void darshan_shutdown(int timing_flag)
             CP_MAX_MNTS*sizeof(int64_t));
     }
 
-    bcst1=MPI_Wtime();
-    MPI_Bcast(mnt_id_array_root, CP_MAX_MNTS*sizeof(int64_t), MPI_BYTE, 0,
-        MPI_COMM_WORLD);
-    MPI_Bcast(mnt_hash_array_root, CP_MAX_MNTS*sizeof(uint64_t), MPI_BYTE, 0,
-        MPI_COMM_WORLD);
-    bcst2=MPI_Wtime();
+    bcst1=DARSHAN_MPI_CALL(PMPI_Wtime)();
+    DARSHAN_MPI_CALL(PMPI_Bcast)(mnt_id_array_root,
+        CP_MAX_MNTS*sizeof(int64_t), MPI_BYTE, 0, MPI_COMM_WORLD);
+    DARSHAN_MPI_CALL(PMPI_Bcast)(mnt_hash_array_root,
+        CP_MAX_MNTS*sizeof(uint64_t), MPI_BYTE, 0, MPI_COMM_WORLD);
+    bcst2=DARSHAN_MPI_CALL(PMPI_Wtime)();
 
     /* identify any common mount points that have different device ids on
      * non-root processes
@@ -431,19 +566,20 @@ void darshan_shutdown(int timing_flag)
     }
 
     /* broadcast log file name */
-    bcst3=MPI_Wtime();
-    MPI_Bcast(logfile_name, PATH_MAX, MPI_CHAR, 0, MPI_COMM_WORLD);
+    bcst3=DARSHAN_MPI_CALL(PMPI_Wtime)();
+    DARSHAN_MPI_CALL(PMPI_Bcast)(logfile_name, PATH_MAX, MPI_CHAR, 0,
+        MPI_COMM_WORLD);
 
     final_job->log_job.end_time = time(NULL);
 
     /* reduce records for shared files */
     if(timing_flag)
-        red1 = MPI_Wtime();
+        red1 = DARSHAN_MPI_CALL(PMPI_Wtime)();
     local_ret = cp_log_reduction(final_job, rank, logfile_name, 
         &next_offset);
     if(timing_flag)
-        red2 = MPI_Wtime();
-    MPI_Allreduce(&local_ret, &all_ret, 1, MPI_INT, MPI_LOR, 
+        red2 = DARSHAN_MPI_CALL(PMPI_Wtime)();
+    DARSHAN_MPI_CALL(PMPI_Allreduce)(&local_ret, &all_ret, 1, MPI_INT, MPI_LOR, 
         MPI_COMM_WORLD);
 
     if(all_ret == 0)
@@ -457,26 +593,26 @@ void darshan_shutdown(int timing_flag)
     {
         /* compress data */
         if(timing_flag)
-            gz1 = MPI_Wtime();
+            gz1 = DARSHAN_MPI_CALL(PMPI_Wtime)();
         local_ret = cp_log_compress(final_job, rank, &index_count, 
             lengths, pointers);
         if(timing_flag)
-            gz2 = MPI_Wtime();
-        MPI_Allreduce(&local_ret, &all_ret, 1, MPI_INT, MPI_LOR, 
-            MPI_COMM_WORLD);
+            gz2 = DARSHAN_MPI_CALL(PMPI_Wtime)();
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&local_ret, &all_ret, 1,
+            MPI_INT, MPI_LOR, MPI_COMM_WORLD);
     }
 
     if(all_ret == 0)
     {
         /* actually write out log file */
         if(timing_flag)
-            write1 = MPI_Wtime();
+            write1 = DARSHAN_MPI_CALL(PMPI_Wtime)();
         local_ret = cp_log_write(final_job, rank, logfile_name, 
             index_count, lengths, pointers, start_log_time);
         if(timing_flag)
-            write2 = MPI_Wtime();
-        MPI_Allreduce(&local_ret, &all_ret, 1, MPI_INT, MPI_LOR, 
-            MPI_COMM_WORLD);
+            write2 = DARSHAN_MPI_CALL(PMPI_Wtime)();
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&local_ret, &all_ret, 1,
+            MPI_INT, MPI_LOR, MPI_COMM_WORLD);
     }
 
     /* if any process failed to write log, then delete the whole file so we
@@ -500,7 +636,7 @@ void darshan_shutdown(int timing_flag)
         double all_tm, all_slowest;
         double bcst_tm, bcst_slowest;
         
-        tm_end = MPI_Wtime();
+        tm_end = DARSHAN_MPI_CALL(PMPI_Wtime)();
 
         bcst_tm=(bcst2-bcst1)+(red1-bcst3);
         red_tm = red2-red1;
@@ -508,20 +644,20 @@ void darshan_shutdown(int timing_flag)
         write_tm = write2-write1;
         all_tm = tm_end-start_log_time;
 
-        MPI_Allreduce(&red_tm, &red_slowest, 1,
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&red_tm, &red_slowest, 1,
             MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
-        MPI_Allreduce(&gz_tm, &gz_slowest, 1,
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&gz_tm, &gz_slowest, 1,
             MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
-        MPI_Allreduce(&write_tm, &write_slowest, 1,
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&write_tm, &write_slowest, 1,
             MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
-        MPI_Allreduce(&all_tm, &all_slowest, 1,
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&all_tm, &all_slowest, 1,
             MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
-        MPI_Allreduce(&bcst_tm, &bcst_slowest, 1,
+        DARSHAN_MPI_CALL(PMPI_Allreduce)(&bcst_tm, &bcst_slowest, 1,
             MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
 
         if(rank == 0)
         {
-            MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+            DARSHAN_MPI_CALL(PMPI_Comm_size)(MPI_COMM_WORLD, &nprocs);
             printf("#<op>\t<nprocs>\t<time>\n");
             printf("bcst\t%d\t%f\n", nprocs, bcst_slowest);
             printf("reduce\t%d\t%f\n", nprocs, red_slowest);
@@ -543,7 +679,7 @@ int MPI_Finalize(void)
     else
         darshan_shutdown(0);
 
-    ret = PMPI_Finalize();
+    ret = DARSHAN_MPI_CALL(PMPI_Finalize)();
     return(ret);
 }
 
@@ -558,7 +694,7 @@ int MPI_File_open(MPI_Comm comm, char *filename, int amode, MPI_Info info, MPI_F
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_open(comm, filename, amode, info, fh);
+    ret = DARSHAN_MPI_CALL(PMPI_File_open)(comm, filename, amode, info, fh);
     tm2 = darshan_wtime();
 
     if(ret == MPI_SUCCESS)
@@ -583,8 +719,9 @@ int MPI_File_open(MPI_Comm comm, char *filename, int amode, MPI_Info info, MPI_F
             CP_SET(file, CP_MODE, amode);
             CP_F_INC(file, CP_F_MPI_META_TIME, (tm2-tm1));
             if(CP_F_VALUE(file, CP_F_OPEN_TIMESTAMP) == 0)
-                CP_F_SET(file, CP_F_OPEN_TIMESTAMP, MPI_Wtime());
-            MPI_Comm_size(comm, &comm_size);
+                CP_F_SET(file, CP_F_OPEN_TIMESTAMP,
+                DARSHAN_MPI_CALL(PMPI_Wtime)());
+            DARSHAN_MPI_CALL(PMPI_Comm_size)(comm, &comm_size);
             if(comm_size == 1)
             {
                 CP_INC(file, CP_INDEP_OPENS, 1);
@@ -621,7 +758,7 @@ int MPI_File_close(MPI_File *fh)
     int ret;
     
     tm1 = darshan_wtime();
-    ret = PMPI_File_close(fh);
+    ret = DARSHAN_MPI_CALL(PMPI_File_close)(fh);
     tm2 = darshan_wtime();
 
     CP_LOCK();
@@ -629,7 +766,7 @@ int MPI_File_close(MPI_File *fh)
     if(file)
     {
         file->fh = MPI_FILE_NULL;
-        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, MPI_Wtime());
+        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, DARSHAN_MPI_CALL(PMPI_Wtime)());
         CP_F_INC(file, CP_F_MPI_META_TIME, (tm2-tm1));
         if(file->fh_prev == NULL)
         {
@@ -663,7 +800,7 @@ int MPI_File_sync(MPI_File fh)
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_sync(fh);
+    ret = DARSHAN_MPI_CALL(PMPI_File_sync)(fh);
     tm2 = darshan_wtime();
     if(ret == MPI_SUCCESS)
     {
@@ -689,7 +826,8 @@ int MPI_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_set_view(fh, disp, etype, filetype, datarep, info);
+    ret = DARSHAN_MPI_CALL(PMPI_File_set_view)(fh, disp, etype,
+        filetype, datarep, info);
     tm2 = darshan_wtime();
     if(ret == MPI_SUCCESS)
     {
@@ -718,7 +856,7 @@ int MPI_File_read(MPI_File fh, void *buf, int count,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read)(fh, buf, count, datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_INDEP_READS, tm1, tm2);
@@ -733,7 +871,8 @@ int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_at(fh, offset, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_at)(fh, offset, buf,
+        count, datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_INDEP_READS, tm1, tm2);
@@ -748,7 +887,8 @@ int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void * buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_at_all(fh, offset, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_at_all)(fh, offset, buf,
+        count, datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_COLL_READS, tm1, tm2);
@@ -762,7 +902,8 @@ int MPI_File_read_all(MPI_File fh, void * buf, int count, MPI_Datatype datatype,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_all(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_all)(fh, buf, count,
+        datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_COLL_READS, tm1, tm2);
@@ -776,7 +917,8 @@ int MPI_File_read_shared(MPI_File fh, void * buf, int count, MPI_Datatype dataty
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_shared(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_shared)(fh, buf, count,
+        datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_INDEP_READS, tm1, tm2);
@@ -791,7 +933,8 @@ int MPI_File_read_ordered(MPI_File fh, void * buf, int count,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_ordered(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_ordered)(fh, buf, count,
+        datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_COLL_READS, tm1, tm2);
@@ -806,7 +949,8 @@ int MPI_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void * buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_at_all_begin(fh, offset, buf, count, datatype);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_at_all_begin)(fh, offset, buf,
+        count, datatype);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_SPLIT_READS, tm1, tm2);
@@ -820,7 +964,7 @@ int MPI_File_read_all_begin(MPI_File fh, void * buf, int count, MPI_Datatype dat
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_all_begin(fh, buf, count, datatype);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_all_begin)(fh, buf, count, datatype);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_SPLIT_READS, tm1, tm2);
@@ -834,7 +978,8 @@ int MPI_File_read_ordered_begin(MPI_File fh, void * buf, int count, MPI_Datatype
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_read_ordered_begin(fh, buf, count, datatype);
+    ret = DARSHAN_MPI_CALL(PMPI_File_read_ordered_begin)(fh, buf, count,
+        datatype);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_SPLIT_READS, tm1, tm2);
@@ -849,7 +994,8 @@ int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void * buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_iread_at(fh, offset, buf, count, datatype, request);
+    ret = DARSHAN_MPI_CALL(PMPI_File_iread_at)(fh, offset, buf, count,
+        datatype, request);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_NB_READS, tm1, tm2);
@@ -863,7 +1009,7 @@ int MPI_File_iread(MPI_File fh, void * buf, int count, MPI_Datatype datatype, MP
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_iread(fh, buf, count, datatype, request);
+    ret = DARSHAN_MPI_CALL(PMPI_File_iread)(fh, buf, count, datatype, request);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_NB_READS, tm1, tm2);
@@ -878,7 +1024,8 @@ int MPI_File_iread_shared(MPI_File fh, void * buf, int count,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_iread_shared(fh, buf, count, datatype, request);
+    ret = DARSHAN_MPI_CALL(PMPI_File_iread_shared)(fh, buf, count,
+        datatype, request);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_READ(ret, fh, count, datatype, CP_NB_READS, tm1, tm2);
@@ -894,7 +1041,7 @@ int MPI_File_write(MPI_File fh, void *buf, int count,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write)(fh, buf, count, datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_INDEP_WRITES, tm1, tm2);
@@ -909,7 +1056,8 @@ int MPI_File_write_at(MPI_File fh, MPI_Offset offset, void *buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_at(fh, offset, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_at)(fh, offset, buf,
+        count, datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_INDEP_WRITES, tm1, tm2);
@@ -924,7 +1072,8 @@ int MPI_File_write_at_all(MPI_File fh, MPI_Offset offset, void * buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_at_all(fh, offset, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_at_all)(fh, offset, buf,
+        count, datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_COLL_WRITES, tm1, tm2);
@@ -938,7 +1087,8 @@ int MPI_File_write_all(MPI_File fh, void * buf, int count, MPI_Datatype datatype
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_all(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_all)(fh, buf, count,
+        datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_COLL_WRITES, tm1, tm2);
@@ -952,7 +1102,8 @@ int MPI_File_write_shared(MPI_File fh, void * buf, int count, MPI_Datatype datat
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_shared(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_shared)(fh, buf, count,
+        datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_INDEP_WRITES, tm1, tm2);
@@ -967,7 +1118,8 @@ int MPI_File_write_ordered(MPI_File fh, void * buf, int count,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_ordered(fh, buf, count, datatype, status);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_ordered)(fh, buf, count,
+         datatype, status);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_COLL_WRITES, tm1, tm2);
@@ -982,7 +1134,8 @@ int MPI_File_write_at_all_begin(MPI_File fh, MPI_Offset offset, void * buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_at_all_begin(fh, offset, buf, count, datatype);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_at_all_begin)(fh, offset,
+        buf, count, datatype);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_SPLIT_WRITES, tm1, tm2);
@@ -996,7 +1149,7 @@ int MPI_File_write_all_begin(MPI_File fh, void * buf, int count, MPI_Datatype da
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_all_begin(fh, buf, count, datatype);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_all_begin)(fh, buf, count, datatype);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_SPLIT_WRITES, tm1, tm2);
@@ -1010,7 +1163,8 @@ int MPI_File_write_ordered_begin(MPI_File fh, void * buf, int count, MPI_Datatyp
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_write_ordered_begin(fh, buf, count, datatype);
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_ordered_begin)(fh, buf, count,
+        datatype);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_SPLIT_WRITES, tm1, tm2);
@@ -1025,7 +1179,8 @@ int MPI_File_iwrite_at(MPI_File fh, MPI_Offset offset, void * buf,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_iwrite_at(fh, offset, buf, count, datatype, request);
+    ret = DARSHAN_MPI_CALL(PMPI_File_iwrite_at)(fh, offset, buf,
+        count, datatype, request);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_NB_WRITES, tm1, tm2);
@@ -1039,7 +1194,7 @@ int MPI_File_iwrite(MPI_File fh, void * buf, int count, MPI_Datatype datatype, M
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_iwrite(fh, buf, count, datatype, request);
+    ret = DARSHAN_MPI_CALL(PMPI_File_iwrite)(fh, buf, count, datatype, request);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_NB_WRITES, tm1, tm2);
@@ -1054,7 +1209,8 @@ int MPI_File_iwrite_shared(MPI_File fh, void * buf, int count,
     double tm1, tm2;
 
     tm1 = darshan_wtime();
-    ret = PMPI_File_iwrite_shared(fh, buf, count, datatype, request);
+    ret = DARSHAN_MPI_CALL(PMPI_File_iwrite_shared)(fh, buf, count,
+        datatype, request);
     tm2 = darshan_wtime();
     CP_LOCK();
     CP_RECORD_MPI_WRITE(ret, fh, count, datatype, CP_NB_WRITES, tm1, tm2);
@@ -1125,7 +1281,7 @@ static int cp_log_reduction(struct darshan_job_runtime* final_job, int rank,
     int shared_count = 0;
 
     /* register a reduction operation */
-    ret = MPI_Op_create(darshan_file_reduce, 1, &reduce_op); 
+    ret = DARSHAN_MPI_CALL(PMPI_Op_create)(darshan_file_reduce, 1, &reduce_op); 
     if(ret != 0)
     {
         return(-1);
@@ -1134,8 +1290,9 @@ static int cp_log_reduction(struct darshan_job_runtime* final_job, int rank,
     /* construct a datatype for a file record.  This is serving no purpose
      * except to make sure we can do a reduction on proper boundaries
      */
-    MPI_Type_contiguous(sizeof(struct darshan_file), MPI_BYTE, &rtype); 
-    MPI_Type_commit(&rtype); 
+    DARSHAN_MPI_CALL(PMPI_Type_contiguous)(sizeof(struct darshan_file),
+        MPI_BYTE, &rtype); 
+    DARSHAN_MPI_CALL(PMPI_Type_commit)(&rtype); 
 
     /* gather list of files that root process has opened */
     if(rank == 0)
@@ -1147,7 +1304,8 @@ static int cp_log_reduction(struct darshan_job_runtime* final_job, int rank,
     }
 
     /* broadcast list of files to all other processes */
-    ret = MPI_Bcast(hash_array, (CP_MAX_FILES * sizeof(uint64_t)), 
+    ret = DARSHAN_MPI_CALL(PMPI_Bcast)(hash_array,
+        (CP_MAX_FILES * sizeof(uint64_t)), 
         MPI_BYTE, 0, MPI_COMM_WORLD);
     if(ret != 0)
     {
@@ -1169,8 +1327,8 @@ static int cp_log_reduction(struct darshan_job_runtime* final_job, int rank,
     }
 
     /* now allreduce so that everyone agrees on which files are shared */
-    ret = MPI_Allreduce(mask_array, all_mask_array, CP_MAX_FILES, MPI_INT, 
-        MPI_LAND, MPI_COMM_WORLD);
+    ret = DARSHAN_MPI_CALL(PMPI_Allreduce)(mask_array, all_mask_array,
+        CP_MAX_FILES, MPI_INT, MPI_LAND, MPI_COMM_WORLD);
     if(ret != 0)
     {
         return(-1);
@@ -1240,7 +1398,7 @@ static int cp_log_reduction(struct darshan_job_runtime* final_job, int rank,
         qsort(final_job->file_array, final_job->file_count, 
             sizeof(struct darshan_file), file_compare);
 
-        ret = MPI_Reduce(
+        ret = DARSHAN_MPI_CALL(PMPI_Reduce)(
             &final_job->file_array[final_job->file_count-shared_count], 
             tmp_array, shared_count, rtype, reduce_op, 0, MPI_COMM_WORLD);
         if(ret != 0)
@@ -1589,37 +1747,39 @@ static int cp_log_write(struct darshan_job_runtime* final_job, int rank,
     {
         displacements[i] = (MPI_Aint)(pointers[i] - buf);
     }
-    MPI_Type_hindexed(count, lengths, displacements, MPI_BYTE, &mtype);
-    MPI_Type_commit(&mtype); 
+    DARSHAN_MPI_CALL(PMPI_Type_hindexed)(count, lengths, displacements,
+        MPI_BYTE, &mtype);
+    DARSHAN_MPI_CALL(PMPI_Type_commit)(&mtype); 
 
-    ret = PMPI_File_open(MPI_COMM_WORLD, logfile_name, MPI_MODE_CREATE |
-        MPI_MODE_WRONLY | MPI_MODE_EXCL, MPI_INFO_NULL, &fh);
+    ret = DARSHAN_MPI_CALL(PMPI_File_open)(MPI_COMM_WORLD, logfile_name,
+        MPI_MODE_CREATE | MPI_MODE_WRONLY | MPI_MODE_EXCL, MPI_INFO_NULL, &fh);
     if(ret != MPI_SUCCESS)
     {
         /* TODO: keep this print or not? */
         fprintf(stderr, "darshan library warning: unable to open log file %s\n", logfile_name);
-        MPI_Type_free(&mtype);
+        DARSHAN_MPI_CALL(PMPI_Type_free)(&mtype);
         return(-1);
     }
    
-    PMPI_File_set_size(fh, 0);
+    DARSHAN_MPI_CALL(PMPI_File_set_size)(fh, 0);
 
     /* figure out where everyone is writing */
-    MPI_Type_size(mtype, &my_total);
+    DARSHAN_MPI_CALL(PMPI_Type_size)(mtype, &my_total);
     my_total_long = my_total;
-    MPI_Scan(&my_total_long, &offset, 1, MPI_LONG, MPI_SUM, MPI_COMM_WORLD); 
+    DARSHAN_MPI_CALL(PMPI_Scan)(&my_total_long, &offset, 1,
+        MPI_LONG, MPI_SUM, MPI_COMM_WORLD); 
     /* scan is inclusive; subtract local size back out */
     offset -= my_total_long;
 
     /* collectively write out file records from all processes */
-    ret = PMPI_File_write_at_all(fh, offset, buf, 
+    ret = DARSHAN_MPI_CALL(PMPI_File_write_at_all)(fh, offset, buf, 
         1, mtype, &status);
     if(ret != MPI_SUCCESS)
     {
         failed_write = 1;
     }
 
-    PMPI_File_close(&fh);
+    DARSHAN_MPI_CALL(PMPI_File_close)(&fh);
 
     /* rename from *.darshan_partial to *-<logwritetime>.darshan.gz */
     if(rank == 0)
@@ -1632,7 +1792,7 @@ static int cp_log_write(struct darshan_job_runtime* final_job, int rank,
         if(new_logfile_name)
         {
             new_logfile_name[0] = '\0';
-            end_log_time = MPI_Wtime();
+            end_log_time = DARSHAN_MPI_CALL(PMPI_Wtime)();
             strcat(new_logfile_name, logfile_name);
             mod_index = strstr(new_logfile_name, ".darshan_partial");
             sprintf(mod_index, "_%d.darshan.gz", (int)(end_log_time-start_log_time+1));
@@ -1643,7 +1803,7 @@ static int cp_log_write(struct darshan_job_runtime* final_job, int rank,
         }
     }
 
-    MPI_Type_free(&mtype);
+    DARSHAN_MPI_CALL(PMPI_Type_free)(&mtype);
 
     if(failed_write)
     {
@@ -1937,19 +2097,21 @@ static int darshan_file_variance(
     struct variance_dt* var_array = NULL;
     struct variance_dt* varres_array = NULL;
 
-    ret = MPI_Op_create(pairwise_variance_reduce, 1, &pw_var_op);
+    ret = DARSHAN_MPI_CALL(PMPI_Op_create)(pairwise_variance_reduce, 1,
+        &pw_var_op);
     if (ret != MPI_SUCCESS)
     {
         goto error_handler;
     }
 
-    ret = MPI_Type_contiguous(sizeof(struct variance_dt), MPI_BYTE, &var_dt);
+    ret = DARSHAN_MPI_CALL(PMPI_Type_contiguous)(sizeof(struct variance_dt),
+        MPI_BYTE, &var_dt);
     if (ret != MPI_SUCCESS)
     {
         goto error_handler;
     }
 
-    ret = MPI_Type_commit(&var_dt);
+    ret = DARSHAN_MPI_CALL(PMPI_Type_commit)(&var_dt);
     if (ret != MPI_SUCCESS)
     {
         goto error_handler;
@@ -1983,7 +2145,7 @@ static int darshan_file_variance(
                          infile_array[i].fcounters[CP_F_POSIX_WRITE_TIME];
     } 
 
-    ret = MPI_Reduce(
+    ret = DARSHAN_MPI_CALL(PMPI_Reduce)(
              var_array, varres_array, count, var_dt, pw_var_op,
              0, MPI_COMM_WORLD);
     if(ret != MPI_SUCCESS)
@@ -2012,7 +2174,7 @@ static int darshan_file_variance(
                          infile_array[i].counters[CP_BYTES_WRITTEN];
     } 
 
-    ret = MPI_Reduce(
+    ret = DARSHAN_MPI_CALL(PMPI_Reduce)(
              var_array, varres_array, count, var_dt, pw_var_op,
              0, MPI_COMM_WORLD);
     if(ret != MPI_SUCCESS)
@@ -2029,7 +2191,7 @@ static int darshan_file_variance(
         }
     }
 
-    MPI_Type_free(&var_dt);
+    DARSHAN_MPI_CALL(PMPI_Type_free)(&var_dt);
 
     ret = 0;
 
diff --git a/lib/darshan-pnetcdf.c b/lib/darshan-pnetcdf.c
index 6ddd9eced16e152f6947a3d9da949f41ecab2da8..cae92d7c8a40024a6f7bb6a7dcc074997b66404c 100644
--- a/lib/darshan-pnetcdf.c
+++ b/lib/darshan-pnetcdf.c
@@ -11,12 +11,25 @@
 #include "darshan-config.h"
 
 #ifdef DARSHAN_PRELOAD
-        
+#define __USE_GNU
+#include <dlfcn.h>
+#include <stdlib.h>
+
 #define DARSHAN_FORWARD_DECL(name,ret,args) \
   ret (*__real_ ## name)args = NULL;
          
 #define DARSHAN_DECL(__name) __name
 
+#define MAP_OR_FAIL(func) \
+    if (!(__real_ ## func)) \
+    { \
+        __real_ ## func = dlsym(RTLD_NEXT, #func); \
+        if(!(__real_ ## func)) { \
+            fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
+            exit(1); \
+        } \
+    }
+ 
 #else   
     
 #define DARSHAN_FORWARD_DECL(name,ret,args) \
@@ -24,33 +37,14 @@
 
 #define DARSHAN_DECL(__name) __wrap_ ## __name
 
+#define MAP_OR_FAIL(func)
+
 #endif
 
 DARSHAN_FORWARD_DECL(ncmpi_create, int, (MPI_Comm comm, const char *path, int cmode, MPI_Info info, int *ncidp));
 DARSHAN_FORWARD_DECL(ncmpi_open, int, (MPI_Comm comm, const char *path, int omode, MPI_Info info, int *ncidp));
 DARSHAN_FORWARD_DECL(ncmpi_close, int, (int ncid));
 
-#ifdef DARSHAN_PRELOAD
-#define __USE_GNU
-#include <dlfcn.h>
-#include <stdlib.h>
-static void __attribute__ ((constructor)) darshan_ldpreload_init(void)
-{       
-#define MAP_OR_FAIL(func) \
-    __real_ ## func = dlsym(RTLD_NEXT, #func); \
-    if(!(__real_ ## func)) { \
-        fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
-        exit(1); \
-    }       
-            
-    MAP_OR_FAIL(ncmpi_create);
-    MAP_OR_FAIL(ncmpi_open);
-    MAP_OR_FAIL(ncmpi_close); 
-            
-    return;     
-}           
-#endif
-
 static struct darshan_file_runtime* darshan_file_by_ncid(int ncid);
 
 int DARSHAN_DECL(ncmpi_create)(MPI_Comm comm, const char *path, 
@@ -62,6 +56,8 @@ int DARSHAN_DECL(ncmpi_create)(MPI_Comm comm, const char *path,
     int comm_size;
     int hash_index;
 
+    MAP_OR_FAIL(ncmpi_create);
+
     ret = __real_ncmpi_create(comm, path, cmode, info, ncidp);
     if(ret == 0)
     {  
@@ -114,6 +110,8 @@ int DARSHAN_DECL(ncmpi_open)(MPI_Comm comm, const char *path,
     int comm_size;
     int hash_index;
 
+    MAP_OR_FAIL(ncmpi_open);
+
     ret = __real_ncmpi_open(comm, path, omode, info, ncidp);
     if(ret == 0)
     {  
@@ -165,6 +163,8 @@ int DARSHAN_DECL(ncmpi_close)(int ncid)
     int tmp_ncid = ncid;
     int ret;
 
+    MAP_OR_FAIL(ncmpi_close); 
+
     ret = __real_ncmpi_close(ncid);
 
     CP_LOCK();
diff --git a/lib/darshan-posix.c b/lib/darshan-posix.c
index a4a0c5c01589abaa8c41899ff71542b6ad6f40c1..c99d2a9dd6d260d254d78c86a7fcdd1bb84d1a58 100644
--- a/lib/darshan-posix.c
+++ b/lib/darshan-posix.c
@@ -29,12 +29,31 @@ typedef int64_t off64_t;
 extern char* __progname_full;
 
 #ifdef DARSHAN_PRELOAD
+#define __USE_GNU
+#include <dlfcn.h>
+#include <stdlib.h>
 
 #define DARSHAN_FORWARD_DECL(name,ret,args) \
   ret (*__real_ ## name)args = NULL;
 
 #define DARSHAN_DECL(__name) __name
 
+#define DARSHAN_MPI_CALL(func) __real_ ## func
+
+#define MAP_OR_FAIL(func) \
+    fprintf(stderr, "Trapped: %s\n", #func); \
+    if (!(__real_ ## func)) \
+    { \
+        __real_ ## func = dlsym(RTLD_NEXT, #func); \
+        if(!(__real_ ## func)) { \
+           fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
+           exit(1); \
+       } \
+    }
+
+
+extern double __real_PMPI_Wtime(void);
+
 #else
 
 #define DARSHAN_FORWARD_DECL(name,ret,args) \
@@ -42,6 +61,10 @@ extern char* __progname_full;
 
 #define DARSHAN_DECL(__name) __wrap_ ## __name
 
+#define MAP_OR_FAIL(func)
+
+#define DARSHAN_MPI_CALL(func) func
+
 #endif
 
 DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
@@ -77,55 +100,6 @@ DARSHAN_FORWARD_DECL(fseek, int, (FILE *stream, long offset, int whence));
 DARSHAN_FORWARD_DECL(fsync, int, (int fd));
 DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
 
-#ifdef DARSHAN_PRELOAD
-#define __USE_GNU
-#include <dlfcn.h>
-#include <stdlib.h>
-static void __attribute__ ((constructor)) darshan_ldpreload_init(void)
-{
-#define MAP_OR_FAIL(func) \
-    __real_ ## func = dlsym(RTLD_NEXT, #func); \
-    if(!(__real_ ## func)) { \
-        fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
-        exit(1); \
-    }
-
-    MAP_OR_FAIL(creat);
-    MAP_OR_FAIL(creat64);
-    MAP_OR_FAIL(open);
-    MAP_OR_FAIL(open64);
-    MAP_OR_FAIL(close);
-    MAP_OR_FAIL(write);
-    MAP_OR_FAIL(read);
-    MAP_OR_FAIL(lseek);
-    MAP_OR_FAIL(lseek64);
-    MAP_OR_FAIL(pread);
-    MAP_OR_FAIL(pread64);
-    MAP_OR_FAIL(pwrite);
-    MAP_OR_FAIL(pwrite64);
-    MAP_OR_FAIL(readv);
-    MAP_OR_FAIL(writev);
-    MAP_OR_FAIL(__fxstat);
-    MAP_OR_FAIL(__fxstat64);
-    MAP_OR_FAIL(__lxstat);
-    MAP_OR_FAIL(__lxstat64);
-    MAP_OR_FAIL(__xstat);
-    MAP_OR_FAIL(__xstat64);
-    MAP_OR_FAIL(mmap);
-    MAP_OR_FAIL(mmap64);
-    MAP_OR_FAIL(fopen);
-    MAP_OR_FAIL(fopen64);
-    MAP_OR_FAIL(close);
-    MAP_OR_FAIL(fread);
-    MAP_OR_FAIL(fwrite);
-    MAP_OR_FAIL(fseek);
-    MAP_OR_FAIL(fsync);
-    MAP_OR_FAIL(fdatasync);
-
-    return;
-}
-#endif
-
 pthread_mutex_t cp_mutex = PTHREAD_MUTEX_INITIALIZER;
 struct darshan_job_runtime* darshan_global_job = NULL;
 static int my_rank = -1;
@@ -147,6 +121,8 @@ static char* exclusions[] = {
 NULL
 };
 
+static double posix_wtime(void);
+
 static void cp_access_counter(struct darshan_file_runtime* file, ssize_t size,     enum cp_counter_type type);
 
 #define CP_RECORD_WRITE(__ret, __fd, __count, __update_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
@@ -290,7 +266,7 @@ static void cp_access_counter(struct darshan_file_runtime* file, ssize_t size,
     else \
         CP_INC(file, CP_POSIX_OPENS, 1); \
     if(CP_F_VALUE(file, CP_F_OPEN_TIMESTAMP) == 0) \
-        CP_F_SET(file, CP_F_OPEN_TIMESTAMP, MPI_Wtime()); \
+        CP_F_SET(file, CP_F_OPEN_TIMESTAMP, posix_wtime()); \
     CP_F_INC(file, CP_F_POSIX_META_TIME, (__tm2-__tm1)); \
     hash_index = file->fd & CP_HASH_MASK; \
     file->fd_prev = NULL; \
@@ -308,6 +284,8 @@ int DARSHAN_DECL(close)(int fd)
     double tm1, tm2;
     int ret;
 
+    MAP_OR_FAIL(close);
+
     tm1 = darshan_wtime();
     ret = __real_close(fd);
     tm2 = darshan_wtime();
@@ -319,7 +297,7 @@ int DARSHAN_DECL(close)(int fd)
         file->fd = -1;
         file->last_byte_written = 0;
         file->last_byte_read = 0;
-        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, MPI_Wtime());
+        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
         CP_F_INC(file, CP_F_POSIX_META_TIME, (tm2-tm1));
         if(file->fd_prev == NULL)
         {
@@ -353,6 +331,8 @@ int DARSHAN_DECL(fclose)(FILE *fp)
     double tm1, tm2;
     int ret;
 
+    MAP_OR_FAIL(fclose);
+
     tm1 = darshan_wtime();
     ret = __real_fclose(fp);
     tm2 = darshan_wtime();
@@ -364,7 +344,7 @@ int DARSHAN_DECL(fclose)(FILE *fp)
         file->fd = -1;
         file->last_byte_written = 0;
         file->last_byte_read = 0;
-        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, MPI_Wtime());
+        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
         CP_F_INC(file, CP_F_POSIX_META_TIME, (tm2-tm1));
         if(file->fd_prev == NULL)
         {
@@ -397,6 +377,8 @@ int DARSHAN_DECL(fsync)(int fd)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fsync);
+
     tm1 = darshan_wtime();
     ret = __real_fsync(fd);
     tm2 = darshan_wtime();
@@ -422,6 +404,8 @@ int DARSHAN_DECL(fdatasync)(int fd)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fdatasync);
+
     tm1 = darshan_wtime();
     ret = __real_fdatasync(fd);
     tm2 = darshan_wtime();
@@ -447,6 +431,8 @@ void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
     void* ret;
     struct darshan_file_runtime* file;
 
+    MAP_OR_FAIL(mmap64);
+
     ret = __real_mmap64(addr, length, prot, flags, fd, offset);
     if(ret == MAP_FAILED)
         return(ret);
@@ -469,6 +455,8 @@ void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
     void* ret;
     struct darshan_file_runtime* file;
 
+    MAP_OR_FAIL(mmap);
+
     ret = __real_mmap(addr, length, prot, flags, fd, offset);
     if(ret == MAP_FAILED)
         return(ret);
@@ -489,6 +477,8 @@ int DARSHAN_DECL(creat)(const char* path, mode_t mode)
     int ret;
     double tm1, tm2;
 
+    MAP_OR_FAIL(creat);
+
     tm1 = darshan_wtime();
     ret = __real_creat(path, mode);
     tm2 = darshan_wtime();
@@ -505,6 +495,8 @@ int DARSHAN_DECL(creat64)(const char* path, mode_t mode)
     int ret;
     double tm1, tm2;
 
+    MAP_OR_FAIL(creat64);
+
     tm1 = darshan_wtime();
     ret = __real_creat64(path, mode);
     tm2 = darshan_wtime();
@@ -522,6 +514,8 @@ int DARSHAN_DECL(open64)(const char* path, int flags, ...)
     int ret;
     double tm1, tm2;
 
+    MAP_OR_FAIL(open64);
+
     if (flags & O_CREAT) 
     {
         va_list arg;
@@ -553,6 +547,8 @@ int DARSHAN_DECL(open)(const char *path, int flags, ...)
     int ret;
     double tm1, tm2;
 
+    MAP_OR_FAIL(open);
+
     if (flags & O_CREAT) 
     {
         va_list arg;
@@ -584,6 +580,8 @@ FILE* DARSHAN_DECL(fopen64)(const char *path, const char *mode)
     int fd;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fopen64);
+
     tm1 = darshan_wtime();
     ret = __real_fopen64(path, mode);
     tm2 = darshan_wtime();
@@ -605,6 +603,8 @@ FILE* DARSHAN_DECL(fopen)(const char *path, const char *mode)
     int fd;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fopen);
+
     tm1 = darshan_wtime();
     ret = __real_fopen(path, mode);
     tm2 = darshan_wtime();
@@ -626,6 +626,8 @@ int DARSHAN_DECL(__xstat64)(int vers, const char *path, struct stat64 *buf)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(__xstat64);
+
     tm1 = darshan_wtime();
     ret = __real___xstat64(vers, path, buf);
     tm2 = darshan_wtime();
@@ -649,6 +651,8 @@ int DARSHAN_DECL(__lxstat64)(int vers, const char *path, struct stat64 *buf)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(__lxstat64);
+
     tm1 = darshan_wtime();
     ret = __real___lxstat64(vers, path, buf);
     tm2 = darshan_wtime();
@@ -672,6 +676,8 @@ int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(__fxstat64);
+
     tm1 = darshan_wtime();
     ret = __real___fxstat64(vers, fd, buf);
     tm2 = darshan_wtime();
@@ -700,6 +706,8 @@ int DARSHAN_DECL(__xstat)(int vers, const char *path, struct stat *buf)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(__xstat);
+
     tm1 = darshan_wtime();
     ret = __real___xstat(vers, path, buf);
     tm2 = darshan_wtime();
@@ -723,6 +731,8 @@ int DARSHAN_DECL(__lxstat)(int vers, const char *path, struct stat *buf)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(__lxstat);
+
     tm1 = darshan_wtime();
     ret = __real___lxstat(vers, path, buf);
     tm2 = darshan_wtime();
@@ -746,6 +756,8 @@ int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(__fxstat);
+
     tm1 = darshan_wtime();
     ret = __real___fxstat(vers, fd, buf);
     tm2 = darshan_wtime();
@@ -773,6 +785,8 @@ ssize_t DARSHAN_DECL(pread64)(int fd, void *buf, size_t count, off64_t offset)
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(pread64);
+
     if((unsigned long)buf % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -791,6 +805,8 @@ ssize_t DARSHAN_DECL(pread)(int fd, void *buf, size_t count, off_t offset)
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(pread);
+
     if((unsigned long)buf % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -810,6 +826,8 @@ ssize_t DARSHAN_DECL(pwrite)(int fd, const void *buf, size_t count, off_t offset
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(pwrite);
+
     if((unsigned long)buf % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -828,6 +846,8 @@ ssize_t DARSHAN_DECL(pwrite64)(int fd, const void *buf, size_t count, off64_t of
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(pwrite64);
+
     if((unsigned long)buf % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -847,6 +867,8 @@ ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
     int i;
     double tm1, tm2;
 
+    MAP_OR_FAIL(readv);
+
     for(i=0; i<iovcnt; i++)
     {
         if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
@@ -869,6 +891,8 @@ ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
     int i;
     double tm1, tm2;
 
+    MAP_OR_FAIL(writev);
+
     for(i=0; i<iovcnt; i++)
     {
         if(!((unsigned long)iov[i].iov_base % darshan_mem_alignment == 0))
@@ -890,6 +914,8 @@ size_t DARSHAN_DECL(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fread);
+
     if((unsigned long)ptr % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -911,6 +937,8 @@ ssize_t DARSHAN_DECL(read)(int fd, void *buf, size_t count)
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(read);
+
     if((unsigned long)buf % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -929,6 +957,8 @@ ssize_t DARSHAN_DECL(write)(int fd, const void *buf, size_t count)
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(write);
+
     if((unsigned long)buf % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -947,6 +977,8 @@ size_t DARSHAN_DECL(fwrite)(const void *ptr, size_t size, size_t nmemb, FILE *st
     int aligned_flag = 0;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fwrite);
+
     if((unsigned long)ptr % darshan_mem_alignment == 0)
         aligned_flag = 1;
 
@@ -968,6 +1000,8 @@ off64_t DARSHAN_DECL(lseek64)(int fd, off64_t offset, int whence)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(lseek64);
+
     tm1 = darshan_wtime();
     ret = __real_lseek64(fd, offset, whence);
     tm2 = darshan_wtime();
@@ -992,6 +1026,8 @@ off_t DARSHAN_DECL(lseek)(int fd, off_t offset, int whence)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(lseek);
+
     tm1 = darshan_wtime();
     ret = __real_lseek(fd, offset, whence);
     tm2 = darshan_wtime();
@@ -1016,6 +1052,8 @@ int DARSHAN_DECL(fseek)(FILE *stream, long offset, int whence)
     struct darshan_file_runtime* file;
     double tm1, tm2;
 
+    MAP_OR_FAIL(fseek);
+
     tm1 = darshan_wtime();
     ret = __real_fseek(stream, offset, whence);
     tm2 = darshan_wtime();
@@ -1662,6 +1700,11 @@ void darshan_search_bench(int argc, char** argv, int iters)
 }
 #endif
 
+static double posix_wtime(void)
+{
+    return DARSHAN_MPI_CALL(PMPI_Wtime)();
+}
+
 double darshan_wtime(void)
 {
     if(!darshan_global_job || darshan_global_job->flags & CP_FLAG_NOTIMING)
@@ -1669,7 +1712,7 @@ double darshan_wtime(void)
         return(0);
     }
     
-    return(MPI_Wtime());
+    return(posix_wtime());
 }
 
 /*