diff --git a/benchmarks/C/aggregation.c b/benchmarks/C/aggregation.c
index 3f29fd4f4..71aa3de53 100644
--- a/benchmarks/C/aggregation.c
+++ b/benchmarks/C/aggregation.c
@@ -184,13 +184,13 @@ int benchmark_write(char       *filename,
     if (cfg->star_block) nvars++;
     nvars *= cfg->nvars;
 
-    varid = (int*) malloc(nvars * sizeof(int));
+    varid = (int*) malloc(sizeof(int) * nvars);
 
     /* initialize I/O buffer */
     lenlen = cfg->len * cfg->len;
-    buf = (double**) malloc(nvars * sizeof(double*));
+    buf = (double**) malloc(sizeof(double*) * nvars);
     for (i=0; i<nvars; i++) {
-        buf[i] = (double*) malloc(lenlen * sizeof(double));
+        buf[i] = (double*) malloc(sizeof(double) * lenlen);
         assert(buf[i] != NULL);
         for (j=0; j<lenlen; j++) buf[i][j] = (double)rank;
     }
@@ -280,8 +280,8 @@ int benchmark_write(char       *filename,
         }
     }
     assert(v == nvars);
-    reqs = (int*) malloc(num_reqs * sizeof(int));
-    sts  = (int*) malloc(num_reqs * sizeof(int));
+    reqs = (int*) malloc(sizeof(int) * num_reqs);
+    sts  = (int*) malloc(sizeof(int) * num_reqs);
 
     err = ncmpi_enddef(ncid); ERR(err)
     err = ncmpi_inq_header_size(ncid, &cfg->header_size); ERR(err)
@@ -436,9 +436,9 @@ int benchmark_read(char       *filename,
     nvars *= cfg->nvars;
 
     /* allocate I/O buffer */
-    buf = (double**) malloc(nvars * sizeof(double*));
+    buf = (double**) malloc(sizeof(double*) * nvars);
     for (i=0; i<nvars; i++) {
-        buf[i] = (double*) malloc(lenlen * sizeof(double));
+        buf[i] = (double*) malloc(sizeof(double) * lenlen);
         assert(buf[i] != NULL);
     }
     MPI_Barrier(comm);
@@ -499,8 +499,8 @@ int benchmark_read(char       *filename,
         if (cfg->star_block)
             num_reqs++; /* complete in 1 nonblocking call */
     }
-    reqs = (int*) malloc(num_reqs * sizeof(int));
-    sts  = (int*) malloc(num_reqs * sizeof(int));
+    reqs = (int*) malloc(sizeof(int) * num_reqs);
+    sts  = (int*) malloc(sizeof(int) * num_reqs);
 
     timing[2] = timing[3] = 0;
     for (n=0; n<cfg->num_records; n++) {
diff --git a/benchmarks/C/write_block_read_column.c b/benchmarks/C/write_block_read_column.c
index 29cb05a81..4c129794c 100644
--- a/benchmarks/C/write_block_read_column.c
+++ b/benchmarks/C/write_block_read_column.c
@@ -91,22 +91,22 @@ int benchmark_write(char       *filename,
     /* initialize I/O buffer */
     for (i=0; i<NVARS; i++) {
         if (i % 4 == 0) {
-            int *int_b = (int*) malloc(len * len * sizeof(int));
+            int *int_b = (int*) malloc(sizeof(int) * len * len);
             for (j=0; j<len*len; j++) int_b[j] = rank;
             buf[i] = (void*)int_b;
         }
         else if (i % 4 == 1) {
-            float *flt_b = (float*) malloc(len * len * sizeof(float));
+            float *flt_b = (float*) malloc(sizeof(float) * len * len);
             for (j=0; j<len*len; j++) flt_b[j] = rank;
             buf[i] = (void*)flt_b;
         }
         else if (i % 4 == 2) {
-            short *shr_b = (short*) malloc(len * len * sizeof(short));
+            short *shr_b = (short*) malloc(sizeof(short) * len * len);
             for (j=0; j<len*len; j++) shr_b[j] = rank;
             buf[i] = (void*)shr_b;
         }
         else {
-            double *dbl_b = (double*) malloc(len * len * sizeof(double));
+            double *dbl_b = (double*) malloc(sizeof(double) * len * len);
             for (j=0; j<len*len; j++) dbl_b[j] = rank;
             buf[i] = (void*)dbl_b;
         }
@@ -240,8 +240,8 @@ int benchmark_read(char       *filename,
     err = ncmpi_inq_dimlen(ncid, dimid[0], &gsizes[0]); ERR(err)
     err = ncmpi_inq_dimlen(ncid, dimid[1], &gsizes[1]); ERR(err)
 
-    varid = (int*)   malloc(nvars * sizeof(int));
-    buf   = (void**) malloc(nvars * sizeof(void*));
+    varid = (int*)   malloc(sizeof(int) * nvars);
+    buf   = (void**) malloc(sizeof(void*) * nvars);
 
     /* construct *-block partitioning pattern */
     start[0] = 0;
@@ -260,13 +260,13 @@ int benchmark_read(char       *filename,
     for (i=0; i<nvars; i++) {
         varid[i] = i;
         if (i % 4 == 0)
-            buf[i] = malloc(len * sizeof(int));
+            buf[i] = malloc(sizeof(int) * len);
         else if (i % 4 == 1)
-            buf[i] = (float*) malloc(len * sizeof(float));
+            buf[i] = (float*) malloc(sizeof(float) * len);
         else if (i % 4 == 2)
-            buf[i] = (short*) malloc(len * sizeof(short));
+            buf[i] = (short*) malloc(sizeof(short) * len);
         else
-            buf[i] = (double*) malloc(len * sizeof(double));
+            buf[i] = (double*) malloc(sizeof(double) * len);
     }
     end_t = MPI_Wtime();
     timing[2] = end_t - start_t;
diff --git a/examples/C/block_cyclic.c b/examples/C/block_cyclic.c
index dbd8625cb..fa5c2a5ed 100644
--- a/examples/C/block_cyclic.c
+++ b/examples/C/block_cyclic.c
@@ -185,7 +185,7 @@ int main(int argc, char** argv) {
 
     /* First, fill the entire array with zeros, using a blocking I/O.
        Every process writes a subarray of size NY * myNX */
-    buf    = (int**) malloc(myNX * sizeof(int*));
+    buf    = (int**) malloc(sizeof(int*) * myNX);
     buf[0] = (int*)  calloc(NY * myNX, sizeof(int));
     start[0] = 0;   start[1] = myOff;
     count[0] = NY;  count[1] = myNX;
@@ -197,12 +197,12 @@ int main(int argc, char** argv) {
     /* initialize the buffer with rank ID. Also make the case interesting,
        by allocating buffers separately */
     for (i=0; i<myNX; i++) {
-        buf[i] = (int*) malloc(NY * sizeof(int));
+        buf[i] = (int*) malloc(sizeof(int) * NY);
         for (j=0; j<NY; j++) buf[i][j] = rank+10;
     }
 
-    reqs = (int*) malloc(myNX * sizeof(int));
-    sts  = (int*) malloc(myNX * sizeof(int));
+    reqs = (int*) malloc(sizeof(int) * myNX);
+    sts  = (int*) malloc(sizeof(int) * myNX);
 
     /* each proc writes myNX columns of the 2D array, block_len controls the
        number of contiguous columns at a time */
@@ -272,15 +272,15 @@ int main(int argc, char** argv) {
     ERR
 
     /* initialize the buffer with -1, so a read error can be pinpointed */
-    buf    = (int**) malloc(myNX * sizeof(int*));
-    buf[0] = (int*)  malloc(global_ny * myNX * sizeof(int));
+    buf    = (int**) malloc(sizeof(int*) * myNX);
+    buf[0] = (int*)  malloc(sizeof(int) * global_ny * myNX);
     for (i=0; i<myNX; i++) {
         if (i > 0) buf[i] = buf[i-1] + global_ny;
         for (j=0; j<global_ny; j++) buf[i][j] = -1;
     }
 
-    reqs = (int*) malloc(myNX * sizeof(int));
-    sts  = (int*) malloc(myNX * sizeof(int));
+    reqs = (int*) malloc(sizeof(int) * myNX);
+    sts  = (int*) malloc(sizeof(int) * myNX);
 
     /* each proc reads myNX columns of the 2D array, block_len controls the
        number of contiguous columns at a time */
diff --git a/examples/C/bput_varn_int64.c b/examples/C/bput_varn_int64.c
index 776d6dec4..c1a37ab85 100644
--- a/examples/C/bput_varn_int64.c
+++ b/examples/C/bput_varn_int64.c
@@ -153,8 +153,8 @@ static MPI_Offset *** calloc_3D(size_t z, size_t y, size_t x)
 {
     if (z*y*x == 0) return NULL;
     int _j, _k;
-    MPI_Offset ***buf  = (MPI_Offset***) malloc(z     * sizeof(MPI_Offset**));
-    MPI_Offset  **bufy = (MPI_Offset**)  malloc(z*y   * sizeof(MPI_Offset*));
+    MPI_Offset ***buf  = (MPI_Offset***) malloc(sizeof(MPI_Offset**) * z);
+    MPI_Offset  **bufy = (MPI_Offset**)  malloc(sizeof(MPI_Offset*) * z*y);
     MPI_Offset   *bufx = (MPI_Offset*)   calloc(z*y*x,  sizeof(MPI_Offset));
     for (_k=0; _k<z; _k++, bufy+=y) {
         buf[_k] = bufy;
@@ -191,7 +191,7 @@ static int check_contents(int ncid, int *varid)
                                      3, 2, 0, 2, 3, 2, 3, 2, 1, 1,
                                      3, 0, 2, 1, 2, 0, 2, 1, 2, 0}};
 
-    long long *r_buffer = (long long*) malloc(NY*NX*sizeof(long long));
+    long long *r_buffer = (long long*) malloc(sizeof(long long)*NY*NX);
 
     for (i=0; i<4; i++) {
         for (j=0; j<NY*NX; j++) r_buffer[j] = 99999;
@@ -388,7 +388,7 @@ int main(int argc, char** argv)
         if (verbose) printf("req_lens[%d]=%d\n",i,req_lens[i]);
 
         /* allocate I/O buffer and initialize its contents */
-        buffer[i] = (long long*) malloc(req_lens[i] * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i]);
         for (j=0; j<req_lens[i]; j++) buffer[i][j] = rank;
 
         bufsize += req_lens[i];
@@ -420,7 +420,7 @@ int main(int argc, char** argv)
         MPI_Datatype buftype;
         MPI_Type_vector(req_lens[i], 1, 2, MPI_UNSIGNED, &buftype);
         MPI_Type_commit(&buftype);
-        buffer[i] = (long long*) malloc(req_lens[i] * 2 * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i] * 2);
         for (j=0; j<req_lens[i]*2; j++) buffer[i][j] = rank;
 
         err = ncmpi_bput_varn(ncid, varid[i], num_segs[i], starts[i],
diff --git a/examples/C/bput_varn_uint.c b/examples/C/bput_varn_uint.c
index b0160dfb4..f3bbeab69 100644
--- a/examples/C/bput_varn_uint.c
+++ b/examples/C/bput_varn_uint.c
@@ -129,8 +129,8 @@ static MPI_Offset *** calloc_3D(size_t z, size_t y, size_t x)
 {
     if (z*y*x == 0) return NULL;
     int _j, _k;
-    MPI_Offset ***buf  = (MPI_Offset***) malloc(z     * sizeof(MPI_Offset**));
-    MPI_Offset  **bufy = (MPI_Offset**)  malloc(z*y   * sizeof(MPI_Offset*));
+    MPI_Offset ***buf  = (MPI_Offset***) malloc(sizeof(MPI_Offset**) * z);
+    MPI_Offset  **bufy = (MPI_Offset**)  malloc(sizeof(MPI_Offset*) * z*y);
     MPI_Offset   *bufx = (MPI_Offset*)   calloc(z*y*x,  sizeof(MPI_Offset));
     for (_k=0; _k<z; _k++, bufy+=y) {
         buf[_k] = bufy;
@@ -167,7 +167,7 @@ static int check_contents(int ncid, int *varid)
                                         2, 2, 1, 0, 0, 0, 3, 3, 2, 2,
                                         3, 3, 3, 1, 2, 2, 2, 0, 0, 0}};
 
-    unsigned int *r_buffer = (unsigned int*) malloc(NY*NX*sizeof(unsigned int));
+    unsigned int *r_buffer = (unsigned int*) malloc(sizeof(unsigned int)*NY*NX);
 
     for (i=0; i<4; i++) {
         for (j=0; j<NY*NX; j++) r_buffer[j] = 99999;
@@ -322,7 +322,7 @@ int main(int argc, char** argv)
         if (verbose) printf("req_lens[%d]=%d\n",i,req_lens[i]);
 
         /* allocate I/O buffer and initialize its contents */
-        buffer[i] = (unsigned int*) malloc(req_lens[i] * sizeof(unsigned int));
+        buffer[i] = (unsigned int*) malloc(sizeof(unsigned int) * req_lens[i]);
         for (j=0; j<req_lens[i]; j++) buffer[i][j] = rank;
 
         bufsize += req_lens[i];
@@ -354,7 +354,7 @@ int main(int argc, char** argv)
         MPI_Datatype buftype;
         MPI_Type_vector(req_lens[i], 1, 2, MPI_UNSIGNED, &buftype);
         MPI_Type_commit(&buftype);
-        buffer[i] = (unsigned int*) malloc(req_lens[i] * 2 * sizeof(unsigned int));
+        buffer[i] = (unsigned int*) malloc(sizeof(unsigned int) * req_lens[i] * 2);
         for (j=0; j<req_lens[i]*2; j++) buffer[i][j] = rank;
 
         err = ncmpi_bput_varn(ncid, varid[i], num_segs[i], starts[i],
diff --git a/examples/C/collective_write.c b/examples/C/collective_write.c
index 2337ab4dd..9b4550466 100644
--- a/examples/C/collective_write.c
+++ b/examples/C/collective_write.c
@@ -154,7 +154,7 @@ pnetcdf_io(MPI_Comm comm, char *filename, int cmode, int len)
 
     /* allocate buffer and initialize with non-zero numbers */
     for (i=0; i<NUM_VARS; i++) {
-        buf[i] = (int *) malloc(bufsize * sizeof(int));
+        buf[i] = (int *) malloc(sizeof(int) * bufsize);
         for (j=0; j<bufsize; j++) buf[i][j] = rank * i + 123 + j;
     }
 
diff --git a/examples/C/column_wise.c b/examples/C/column_wise.c
index 8d138a0fb..29aa576fd 100644
--- a/examples/C/column_wise.c
+++ b/examples/C/column_wise.c
@@ -175,7 +175,7 @@ int main(int argc, char** argv)
 
     /* First, fill the entire array with zeros, using a blocking I/O.
        Every process writes a subarray of size NY * myNX */
-    buf    = (int**) malloc(myNX * sizeof(int*));
+    buf    = (int**) malloc(sizeof(int*) * myNX);
     buf[0] = (int*)  calloc(NY * myNX, sizeof(int));
     start[0] = 0;   start[1] = myOff;
     count[0] = NY;  count[1] = myNX;
@@ -187,12 +187,12 @@ int main(int argc, char** argv)
     /* initialize the buffer with rank ID. Also make the case interesting,
        by allocating buffers separately */
     for (i=0; i<myNX; i++) {
-        buf[i] = (int*) malloc(NY * sizeof(int));
+        buf[i] = (int*) malloc(sizeof(int) * NY);
         for (j=0; j<NY; j++) buf[i][j] = rank;
     }
 
-    reqs = (int*) malloc(myNX * sizeof(int));
-    sts  = (int*) malloc(myNX * sizeof(int));
+    reqs = (int*) malloc(sizeof(int) * myNX);
+    sts  = (int*) malloc(sizeof(int) * myNX);
 
     /* each proc writes myNX single columns of the 2D array */
     start[0]  = 0;   start[1] = rank;
diff --git a/examples/C/flexible_api.c b/examples/C/flexible_api.c
index 1e3a4ab2d..4f63ca44c 100644
--- a/examples/C/flexible_api.c
+++ b/examples/C/flexible_api.c
@@ -189,7 +189,7 @@ int main(int argc, char** argv)
     MPI_Type_commit(&subarray);
 
     int buffer_len = (NZ+2*ghost_len) * (NY+2*ghost_len);
-    buf_zy = (int*) malloc(buffer_len * sizeof(int));
+    buf_zy = (int*) malloc(sizeof(int) * buffer_len);
     for (i=0; i<buffer_len; i++) buf_zy[i] = rank;
 
     start[0] = NZ * rank; start[1] = 0;
@@ -243,7 +243,7 @@ int main(int argc, char** argv)
     MPI_Type_commit(&subarray);
 
     buffer_len = (NY+2*ghost_len) * (NX+2*ghost_len);
-    buf_yx = (double*) malloc(buffer_len * sizeof(double));
+    buf_yx = (double*) malloc(sizeof(double) * buffer_len);
     for (i=0; i<buffer_len; i++) buf_yx[i] = rank;
 
     start[0] = 0;  start[1] = NX * rank;
diff --git a/examples/C/get_vara.c b/examples/C/get_vara.c
index 89ae72753..fc5d0454e 100644
--- a/examples/C/get_vara.c
+++ b/examples/C/get_vara.c
@@ -154,14 +154,14 @@ pnetcdf_io(MPI_Comm comm, char *filename)
     err = ncmpi_inq_attlen(ncid, varid, "float_att_name", &len); ERR
 
     /* get attribute contents */
-    float_att = (float*) malloc(len * sizeof(float));
+    float_att = (float*) malloc(sizeof(float) * len);
     err = ncmpi_get_att_float(ncid, varid, "float_att_name", float_att); ERR
     free(float_att);
 
     /* the local array size */
     local_ny = global_ny;
     local_nx = global_nx / nprocs;
-    buf = (int*) malloc(local_nx * local_ny * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * local_nx * local_ny);
 
     /* prepare reading subarray */
     start[0] = 0;
diff --git a/examples/C/ghost_cell.c b/examples/C/ghost_cell.c
index 6136222e8..3dbc69845 100644
--- a/examples/C/ghost_cell.c
+++ b/examples/C/ghost_cell.c
@@ -164,7 +164,7 @@ pnetcdf_io(MPI_Comm comm, char *filename, int cmode, int len)
     /* allocate and initialize buffer with ghost cells on both ends of each dim */
     nghosts = 2;
     bufsize = (counts[0] + 2 * nghosts) * (counts[1] + 2 * nghosts);
-    buf = (int *) malloc(bufsize * sizeof(int));
+    buf = (int *) malloc(sizeof(int) * bufsize);
     for (i=0; i<counts[0]+2*nghosts; i++)
     for (j=0; j<counts[1]+2*nghosts; j++) {
         if (nghosts <= i && i < counts[0]+nghosts &&
diff --git a/examples/C/hints.c b/examples/C/hints.c
index deb88d5c9..4b9f5651b 100644
--- a/examples/C/hints.c
+++ b/examples/C/hints.c
@@ -181,7 +181,7 @@ int main(int argc, char** argv)
     err = ncmpi_enddef(ncid); ERR
 
     /* var_zy is partitioned along Z dimension */
-    buf_zy = (int*) malloc(NZ * (NY * nprocs) * sizeof(int));
+    buf_zy = (int*) malloc(sizeof(int) * NZ * (NY * nprocs));
     for (i=0; i<NZ*(NY*nprocs); i++) buf_zy[i] = i;
 
     start[0] = NZ * rank; start[1] = 0;
@@ -189,7 +189,7 @@ int main(int argc, char** argv)
     err = ncmpi_put_vara_int_all(ncid, varid0, start, count, buf_zy); ERR
 
     /* var_yx is partitioned along X dimension */
-    buf_yx = (float*) malloc((NY * nprocs) * NX * sizeof(float));
+    buf_yx = (float*) malloc(sizeof(float) * (NY * nprocs) * NX);
     for (i=0; i<(NY*nprocs)*NX; i++) buf_yx[i] = i;
 
     start[0] = 0;           start[1] = NX * rank;
diff --git a/examples/C/i_varn_int64.c b/examples/C/i_varn_int64.c
index b202c3514..b9301d5c2 100644
--- a/examples/C/i_varn_int64.c
+++ b/examples/C/i_varn_int64.c
@@ -130,8 +130,8 @@ static MPI_Offset *** calloc_3D(size_t z, size_t y, size_t x)
 {
     if (z*y*x == 0) return NULL;
     int _j, _k;
-    MPI_Offset ***buf  = (MPI_Offset***) malloc(z     * sizeof(MPI_Offset**));
-    MPI_Offset  **bufy = (MPI_Offset**)  malloc(z*y   * sizeof(MPI_Offset*));
+    MPI_Offset ***buf  = (MPI_Offset***) malloc(sizeof(MPI_Offset**) * z);
+    MPI_Offset  **bufy = (MPI_Offset**)  malloc(sizeof(MPI_Offset*) * z*y);
     MPI_Offset   *bufx = (MPI_Offset*)   calloc(z*y*x,  sizeof(MPI_Offset));
     for (_k=0; _k<z; _k++, bufy+=y) {
         buf[_k] = bufy;
@@ -168,7 +168,7 @@ static int check_contents(int ncid, int *varid)
                                      2, 2, 1, 0, 0, 0, 3, 3, 2, 2,
                                      3, 3, 3, 1, 2, 2, 2, 0, 0, 0}};
 
-    long long *r_buffer = (long long*) malloc(NY*NX * sizeof(long long));
+    long long *r_buffer = (long long*) malloc(sizeof(long long) * NY*NX);
 
     for (i=0; i<4; i++) {
         for (j=0; j<NY*NX; j++) r_buffer[j] = -1;
@@ -322,7 +322,7 @@ int main(int argc, char** argv)
         if (verbose) printf("req_lens[%d]=%d\n",i,req_lens[i]);
 
         /* allocate I/O buffer and initialize its contents */
-        buffer[i] = (long long*) malloc(req_lens[i] * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i]);
         for (j=0; j<req_lens[i]; j++) buffer[i][j] = rank;
     }
 
@@ -366,7 +366,7 @@ int main(int argc, char** argv)
         MPI_Datatype buftype;
         MPI_Type_vector(req_lens[i], 1, 2, MPI_LONG_LONG, &buftype);
         MPI_Type_commit(&buftype);
-        buffer[i] = (long long*) malloc(req_lens[i] * 2 * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i] * 2);
         for (j=0; j<req_lens[i]*2; j++) buffer[i][j] = rank;
 
         err = ncmpi_iput_varn(ncid, varid[i], num_segs[i], starts[i],
diff --git a/examples/C/mput.c b/examples/C/mput.c
index b219d9441..51978655c 100644
--- a/examples/C/mput.c
+++ b/examples/C/mput.c
@@ -165,8 +165,8 @@ int main(int argc, char** argv)
     else if (rank == 3) num_reqs = 4;
 
     if (num_reqs > 0) {
-        starts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
-        counts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
+        starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+        counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
         starts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
         counts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
         for (i=1; i<num_reqs; i++) {
@@ -226,9 +226,9 @@ int main(int argc, char** argv)
          */
     }
 
-    nvarids   = (int*)          malloc(num_reqs * sizeof(int));
-    bufcounts = (MPI_Offset*)   malloc(num_reqs * sizeof(MPI_Offset));
-    datatypes = (MPI_Datatype*) malloc(num_reqs * sizeof(MPI_Datatype));
+    nvarids   = (int*)          malloc(sizeof(int) * num_reqs);
+    bufcounts = (MPI_Offset*)   malloc(sizeof(MPI_Offset) * num_reqs);
+    datatypes = (MPI_Datatype*) malloc(sizeof(MPI_Datatype) * num_reqs);
     w_len = 0;
     for (i=0; i<num_reqs; i++) {
         nvarids[i]    = varid;
@@ -238,11 +238,11 @@ int main(int argc, char** argv)
     }
 
     /* allocate I/O buffer and initialize its contents */
-    buffer = (int*)  malloc(w_len * sizeof(int));
+    buffer = (int*)  malloc(sizeof(int) * w_len);
     for (i=0; i<w_len; i++) buffer[i] = rank;
 
     /* set the buffer pointers to different offsets to the I/O buffer */
-    bufs    = (int**) malloc(num_reqs * sizeof(int*));
+    bufs    = (int**) malloc(sizeof(int*) * num_reqs);
     if (num_reqs > 0) bufs[0] = buffer;
     for (i=1; i<num_reqs; i++) bufs[i] = bufs[i-1] + bufcounts[i-1];
 
diff --git a/examples/C/nonblocking_write.c b/examples/C/nonblocking_write.c
index 48284b4ec..937d0da38 100644
--- a/examples/C/nonblocking_write.c
+++ b/examples/C/nonblocking_write.c
@@ -197,7 +197,7 @@ int main(int argc, char **argv)
 
         total_nelems = SCA_NVARS + (FIX_NVARS + REC_NVARS) * nelems;
 
-        sca_buf = (int*) malloc(total_nelems * sizeof(int));
+        sca_buf = (int*) malloc(sizeof(int) * total_nelems);
 
         for (i=0; i<FIX_NVARS; i++)
             fix_buf[i] = sca_buf + SCA_NVARS + nelems * i;
@@ -207,11 +207,11 @@ int main(int argc, char **argv)
     }
     else {
         /* allocate individual buffers separately +1 ensure non-contiguity*/
-        sca_buf = (int*) malloc((SCA_NVARS+1) * sizeof(int));
+        sca_buf = (int*) malloc(sizeof(int) * (SCA_NVARS+1));
         for (i=0; i<FIX_NVARS; i++)
-            fix_buf[i] = (int *) malloc((nelems+1) * sizeof(int));
+            fix_buf[i] = (int *) malloc(sizeof(int) * (nelems+1));
         for (i=0; i<REC_NVARS; i++)
-            rec_buf[i] = (int *) malloc((nelems+1) * sizeof(int));
+            rec_buf[i] = (int *) malloc(sizeof(int) * (nelems+1));
     }
 
     /* initialize buffer contents */
@@ -247,8 +247,8 @@ int main(int argc, char **argv)
 
     MPI_Info_free(&info);
 
-    req = (int*) malloc((SCA_NVARS + FIX_NVARS + REC_NVARS) * sizeof(int));
-    st  = (int*) malloc((SCA_NVARS + FIX_NVARS + REC_NVARS) * sizeof(int));
+    req = (int*) malloc(sizeof(int) * (SCA_NVARS + FIX_NVARS + REC_NVARS));
+    st  = (int*) malloc(sizeof(int) * (SCA_NVARS + FIX_NVARS + REC_NVARS));
 
     /* define dimensions */
     err = ncmpi_def_dim(ncid, "time", NC_UNLIMITED, &dimids[0]);
diff --git a/examples/C/nonblocking_write_in_def.c b/examples/C/nonblocking_write_in_def.c
index f9e0eebcf..84a592381 100644
--- a/examples/C/nonblocking_write_in_def.c
+++ b/examples/C/nonblocking_write_in_def.c
@@ -172,7 +172,7 @@ int main(int argc, char **argv)
 
     /* allocate buffer and initialize with some non-zero numbers */
     for (i=0; i<NUM_VARS; i++) {
-        buf[i] = (int *) malloc(bufsize * sizeof(int));
+        buf[i] = (int *) malloc(sizeof(int) * bufsize);
         for (j=0; j<bufsize; j++) buf[i][j] = rank * i + 123 + j;
     }
 
diff --git a/examples/C/pthread.c b/examples/C/pthread.c
index 46ce34eac..60081b550 100644
--- a/examples/C/pthread.c
+++ b/examples/C/pthread.c
@@ -243,8 +243,8 @@ void* thread_func(void *arg)
     sprintf(filename, "%s.%d", ((thread_arg*)arg)->fname, id);
 
     /* allocate I/O buffers and initialize their contents */
-    ibuf = (int*)    malloc(NY * NX * sizeof(int));
-    dbuf = (double*) malloc(NY * NX * sizeof(double));
+    ibuf = (int*)    malloc(sizeof(int) * NY * NX);
+    dbuf = (double*) malloc(sizeof(double) * NY * NX);
     for (i=0; i<NY*NX; i++) {
         ibuf[i] = id;
         dbuf[i] = 1.0 * id;
diff --git a/examples/C/put_varn_float.c b/examples/C/put_varn_float.c
index 2791aabbc..01d59f479 100644
--- a/examples/C/put_varn_float.c
+++ b/examples/C/put_varn_float.c
@@ -149,7 +149,7 @@ int main(int argc, char** argv)
     else if (rank == 3) num_reqs = 10;
 
     if (num_reqs > 0) {
-        starts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
+        starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
         starts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
         for (i=1; i<num_reqs; i++)
             starts[i] = starts[i-1] + NDIMS;
@@ -228,7 +228,7 @@ int main(int argc, char** argv)
     }
 
     /* allocate I/O buffer and initialize its contents */
-    buffer = (float*) malloc(num_reqs * sizeof(float));
+    buffer = (float*) malloc(sizeof(float) * num_reqs);
     for (i=0; i<num_reqs; i++) buffer[i] = (float)rank;
 
     /* set the buffer pointers to different offsets to the I/O buffer */
diff --git a/examples/C/put_varn_int.c b/examples/C/put_varn_int.c
index 47467b936..79267191e 100644
--- a/examples/C/put_varn_int.c
+++ b/examples/C/put_varn_int.c
@@ -156,8 +156,8 @@ int main(int argc, char** argv)
     else if (rank == 3) num_reqs = 4;
 
     if (num_reqs > 0) {
-        starts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
-        counts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
+        starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+        counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
         starts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
         counts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
         for (i=1; i<num_reqs; i++) {
@@ -226,7 +226,7 @@ int main(int argc, char** argv)
     }
 
     /* allocate I/O buffer and initialize its contents */
-    buffer = (int*) malloc(w_len * sizeof(int));
+    buffer = (int*) malloc(sizeof(int) * w_len);
     for (i=0; i<w_len; i++) buffer[i] = rank;
 
     /* set the buffer pointers to different offsets to the I/O buffer */
diff --git a/examples/C/req_all.c b/examples/C/req_all.c
index 50fd1de67..5de443a06 100644
--- a/examples/C/req_all.c
+++ b/examples/C/req_all.c
@@ -156,9 +156,9 @@ int main(int argc, char** argv)
     err = ncmpi_enddef(ncid); ERR
 
     /* initialize the buffer with rank ID */
-    buf = (int**) malloc(myNX * sizeof(int*));
+    buf = (int**) malloc(sizeof(int*) * myNX);
     for (i=0; i<myNX; i++) {
-        buf[i] = (int*) malloc(NY * sizeof(int));
+        buf[i] = (int*) malloc(sizeof(int) * NY);
         for (j=0; j<NY; j++) buf[i][j] = rank;
     }
 
diff --git a/examples/C/time_var.c b/examples/C/time_var.c
index 9e3b27cf4..41b15ef19 100644
--- a/examples/C/time_var.c
+++ b/examples/C/time_var.c
@@ -245,7 +245,7 @@ pnetcdf_read(MPI_Comm comm, char *filename)
     err = ncmpi_inq_varid(ncid, "fix_var", &fix_var); ERR
 
     /* allocate read buffer */
-    buf = (double*) malloc(global_ny * global_nx * sizeof(double));
+    buf = (double*) malloc(sizeof(double) * global_ny * global_nx);
     for (i=0; i<global_ny*global_nx; i++) buf[i] = -1.0; /* initialize buffer */
 
     /* read 1st record of the record variable, rec_var */
diff --git a/examples/C/transpose.c b/examples/C/transpose.c
index aceb1d137..4d0df11fa 100644
--- a/examples/C/transpose.c
+++ b/examples/C/transpose.c
@@ -136,7 +136,7 @@ pnetcdf_io(MPI_Comm comm, char *filename, int cmode, int len)
     }
 
     /* allocate buffer and initialize with contiguous numbers */
-    buf = (int *) malloc(bufsize * sizeof(int));
+    buf = (int *) malloc(sizeof(int) * bufsize);
     for (k=0; k<counts[0]; k++)
     for (j=0; j<counts[1]; j++)
     for (i=0; i<counts[2]; i++)
diff --git a/examples/C/transpose2D.c b/examples/C/transpose2D.c
index 301b24d73..b8a7da513 100644
--- a/examples/C/transpose2D.c
+++ b/examples/C/transpose2D.c
@@ -157,7 +157,7 @@ pnetcdf_io(MPI_Comm comm, char *filename, int cmode, int len)
     }
 
     /* allocate buffer and initialize buffer with contiguous numbers, in YX layout */
-    buf = (int *) malloc(bufsize * sizeof(int));
+    buf = (int *) malloc(sizeof(int) * bufsize);
     for (i=0; i<count[0]; i++)
     for (j=0; j<count[1]; j++)
         buf[i*count[1] + j] = (int)((start[0]+i)*gsizes[1] + (start[1]+j));
diff --git a/examples/C/vard_bottom.c b/examples/C/vard_bottom.c
index bbeda3a58..57a800238 100644
--- a/examples/C/vard_bottom.c
+++ b/examples/C/vard_bottom.c
@@ -177,11 +177,11 @@ int main(int argc, char **argv)
 
     if (verbose && rank == 0) printf("%s: example of using vard APIs to write/read two variables\n",__FILE__);
 
-    buf[0] = (int*)malloc(NY * NX * sizeof(int));
+    buf[0] = (int*)malloc(sizeof(int) * NY * NX);
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         buf[0][j*NX+i] = rank*100 + j*10 + i;
 
-    buf[1] = (int*)malloc(NY * NX * sizeof(int));
+    buf[1] = (int*)malloc(sizeof(int) * NY * NX);
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         buf[1][j*NX+i] = 1000 + rank*100 + j*10 + i;
 
diff --git a/examples/C/vard_mvars.c b/examples/C/vard_mvars.c
index caca1995d..c728a8732 100644
--- a/examples/C/vard_mvars.c
+++ b/examples/C/vard_mvars.c
@@ -173,11 +173,11 @@ int main(int argc, char **argv)
 
     if (verbose && rank == 0) printf("%s: example of using vard APIs to write/read two variables\n",__FILE__);
 
-    buf[0] = (int*)malloc(NY * NX * sizeof(int));
+    buf[0] = (int*)malloc(sizeof(int) * NY * NX);
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         buf[0][j*NX+i] = rank*100 + j*10 + i;
 
-    buf[1] = (int*)malloc(NY * NX * sizeof(int));
+    buf[1] = (int*)malloc(sizeof(int) * NY * NX);
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         buf[1][j*NX+i] = 1000 + rank*100 + j*10 + i;
 
diff --git a/examples/CXX/block_cyclic.cpp b/examples/CXX/block_cyclic.cpp
index fd9dc63a1..d471dca40 100644
--- a/examples/CXX/block_cyclic.cpp
+++ b/examples/CXX/block_cyclic.cpp
@@ -144,7 +144,7 @@ int main(int argc, char** argv)
 
         /* First, fill the entire array with zeros, using a blocking I/O.
            Every process writes a subarray of size NY * myNX */
-        buf    = (int**) malloc(myNX * sizeof(int*));
+        buf    = (int**) malloc(sizeof(int*) * myNX);
         buf[0] = (int*)  calloc(NY * myNX, sizeof(int));
         start[0] = 0;   start[1] = myOff;
         count[0] = NY;  count[1] = myNX;
@@ -158,12 +158,12 @@ int main(int argc, char** argv)
         /* initialize the buffer with rank ID. Also make the case interesting,
            by allocating buffers separately */
         for (i=0; i<myNX; i++) {
-            buf[i] = (int*) malloc(NY * sizeof(int));
+            buf[i] = (int*) malloc(sizeof(int) * NY);
             for (j=0; j<NY; j++) buf[i][j] = rank+10;
         }
 
-        reqs = (int*) malloc(myNX * sizeof(int));
-        sts  = (int*) malloc(myNX * sizeof(int));
+        reqs = (int*) malloc(sizeof(int) * myNX);
+        sts  = (int*) malloc(sizeof(int) * myNX);
 
         /* each proc writes myNX columns of the 2D array, block_len controls the
            the number of contiguous columns at a time */
@@ -228,15 +228,15 @@ int main(int argc, char** argv)
         NcmpiVar var = nc.getVar("var");
 
         /* initialize the buffer with -1, so a read error can be pinpointed */
-        buf    = (int**) malloc(myNX * sizeof(int*));
-        buf[0] = (int*)  malloc(NY * myNX * sizeof(int));
+        buf    = (int**) malloc(sizeof(int*) * myNX);
+        buf[0] = (int*)  malloc(sizeof(int) * NY * myNX);
         for (i=0; i<myNX; i++) {
             if (i > 0) buf[i] = buf[i-1] + NY;
             for (j=0; j<NY; j++) buf[i][j] = -1;
         }
 
-        reqs = (int*) malloc(myNX * sizeof(int));
-        sts  = (int*) malloc(myNX * sizeof(int));
+        reqs = (int*) malloc(sizeof(int) * myNX);
+        sts  = (int*) malloc(sizeof(int) * myNX);
 
         /* each proc reads myNX columns of the 2D array, block_len controls the
            the number of contiguous columns at a time */
diff --git a/examples/CXX/collective_write.cpp b/examples/CXX/collective_write.cpp
index e2b6becb4..83aeff1f0 100644
--- a/examples/CXX/collective_write.cpp
+++ b/examples/CXX/collective_write.cpp
@@ -140,7 +140,7 @@ int main(int argc, char **argv)
 
     /* allocate buffer and initialize with some non-zero numbers */
     for (i=0; i<NUM_VARS; i++) {
-        buf[i] = (int *) malloc(bufsize * sizeof(int));
+        buf[i] = (int *) malloc(sizeof(int) * bufsize);
         for (j=0; j<bufsize; j++) buf[i][j] = rank * i + 123 + j;
     }
 
diff --git a/examples/CXX/column_wise.cpp b/examples/CXX/column_wise.cpp
index 15731828b..e28ba44b0 100644
--- a/examples/CXX/column_wise.cpp
+++ b/examples/CXX/column_wise.cpp
@@ -132,7 +132,7 @@ int main(int argc, char** argv)
 
         /* First, fill the entire array with zeros, using a blocking I/O.
            Every process writes a subarray of size NY * myNX */
-        buf    = (int**) malloc(myNX * sizeof(int*));
+        buf    = (int**) malloc(sizeof(int*) * myNX);
         buf[0] = (int*)  calloc(NY * myNX, sizeof(int));
         start[0] = 0;   start[1] = myOff;
         count[0] = NY;  count[1] = myNX;
@@ -145,12 +145,12 @@ int main(int argc, char** argv)
         /* initialize the buffer with rank ID. Also make the case interesting,
            by allocating buffers separately */
         for (i=0; i<myNX; i++) {
-            buf[i] = (int*) malloc(NY * sizeof(int));
+            buf[i] = (int*) malloc(sizeof(int) * NY);
             for (j=0; j<NY; j++) buf[i][j] = rank;
         }
 
-        reqs = (int*) malloc(myNX * sizeof(int));
-        sts  = (int*) malloc(myNX * sizeof(int));
+        reqs = (int*) malloc(sizeof(int) * myNX);
+        sts  = (int*) malloc(sizeof(int) * myNX);
 
         /* each proc writes myNX single columns of the 2D array */
         start[0]  = 0;   start[1] = rank;
diff --git a/examples/CXX/flexible_api.cpp b/examples/CXX/flexible_api.cpp
index c94c7cec6..0cad01771 100644
--- a/examples/CXX/flexible_api.cpp
+++ b/examples/CXX/flexible_api.cpp
@@ -161,7 +161,7 @@ int main(int argc, char** argv)
 
         /* allocate buffer buf_zy and initialize its contents */
         int buffer_len = (NZ+2*ghost_len) * (NY+2*ghost_len);
-        buf_zy = (int*) malloc(buffer_len * sizeof(int));
+        buf_zy = (int*) malloc(sizeof(int) * buffer_len);
         for (i=0; i<buffer_len; i++) buf_zy[i] = rank;
 
         vector <MPI_Offset> start(2), count(2);
@@ -190,7 +190,7 @@ int main(int argc, char** argv)
 
         /* allocate buffer buf_yx and initialize its contents */
         buffer_len = (NY+2*ghost_len) * (NX+2*ghost_len);
-        buf_yx = (float*) malloc(buffer_len * sizeof(float));
+        buf_yx = (float*) malloc(sizeof(float) * buffer_len);
         for (i=0; i<buffer_len; i++) buf_yx[i] = rank;
 
         start[0] = 0;  start[1] = NX * rank;
diff --git a/examples/CXX/get_vara.cpp b/examples/CXX/get_vara.cpp
index 95549ca98..d27e2f03e 100644
--- a/examples/CXX/get_vara.cpp
+++ b/examples/CXX/get_vara.cpp
@@ -144,13 +144,13 @@ int main(int argc, char** argv)
         len = flt_vatt.getAttLength();
 
         /* get attribute contents */
-        float *float_att = (float*) malloc(len * sizeof(float));
+        float *float_att = (float*) malloc(sizeof(float) * len);
         flt_vatt.getValues(float_att);
 
         /* the local array size */
         local_ny = global_ny;
         local_nx = global_nx / nprocs;
-        int *buf = (int*) malloc(local_nx * local_ny * sizeof(int));
+        int *buf = (int*) malloc(sizeof(int) * local_nx * local_ny);
 
         /* prepare reading subarray */
         vector<MPI_Offset> start(2), count(2);
diff --git a/examples/CXX/hints.cpp b/examples/CXX/hints.cpp
index bd9b0bb30..23a9db90e 100644
--- a/examples/CXX/hints.cpp
+++ b/examples/CXX/hints.cpp
@@ -158,7 +158,7 @@ int main(int argc, char** argv)
         NcmpiVar var1 = ncFile.addVar("var_yx", ncmpiFloat, dimid_yx);
 
         /* var_zy is partitioned along Z dimension */
-        buf_zy = (int*) malloc(NZ * (NY * nprocs) * sizeof(int));
+        buf_zy = (int*) malloc(sizeof(int) * NZ * (NY * nprocs));
         for (i=0; i<NZ*(NY*nprocs); i++) buf_zy[i] = i;
 
         start[0] = NZ * rank; start[1] = 0;
@@ -166,7 +166,7 @@ int main(int argc, char** argv)
         var0.putVar_all(start, count, buf_zy);
 
         /* var_yx is partitioned along X dimension */
-        buf_yx = (float*) malloc((NY * nprocs) * NX * sizeof(float));
+        buf_yx = (float*) malloc(sizeof(float) * (NY * nprocs) * NX);
         for (i=0; i<(NY*nprocs)*NX; i++) buf_yx[i] = i;
 
         start[0] = 0;           start[1] = NX * rank;
diff --git a/examples/CXX/nonblocking_write.cpp b/examples/CXX/nonblocking_write.cpp
index 85d5a3bc0..c38ce785c 100644
--- a/examples/CXX/nonblocking_write.cpp
+++ b/examples/CXX/nonblocking_write.cpp
@@ -140,7 +140,7 @@ int main(int argc, char **argv)
 
     /* allocate buffer and initialize with some non-zero numbers */
     for (i=0; i<NUM_VARS; i++) {
-        buf[i] = (int *) malloc(bufsize * sizeof(int));
+        buf[i] = (int *) malloc(sizeof(int) * bufsize);
         for (j=0; j<bufsize; j++) buf[i][j] = rank * i + 123 + j;
     }
 
diff --git a/examples/CXX/put_varn_float.cpp b/examples/CXX/put_varn_float.cpp
index 7280e36ce..1c420d078 100644
--- a/examples/CXX/put_varn_float.cpp
+++ b/examples/CXX/put_varn_float.cpp
@@ -114,7 +114,7 @@ int main(int argc, char** argv)
         else if (rank == 3) num_reqs = 10;
 
         if (num_reqs > 0) {
-            starts    = (MPI_Offset**)malloc(num_reqs*       sizeof(MPI_Offset*));
+            starts    = (MPI_Offset**)malloc(sizeof(MPI_Offset*) * num_reqs);
             starts[0] = (MPI_Offset*) calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
             for (i=1; i<num_reqs; i++)
                 starts[i] = starts[i-1] + NDIMS;
@@ -193,7 +193,7 @@ int main(int argc, char** argv)
         }
 
         /* allocate I/O buffer and initialize its contents */
-        buffer = (float*) malloc(num_reqs * sizeof(float));
+        buffer = (float*) malloc(sizeof(float) * num_reqs);
         for (i=0; i<num_reqs; i++) buffer[i] =  (float)rank;
 
         /* set the buffer pointers to different offsets to the I/O buffer */
diff --git a/examples/CXX/put_varn_int.cpp b/examples/CXX/put_varn_int.cpp
index 73a7a9fa5..3fd185f4e 100644
--- a/examples/CXX/put_varn_int.cpp
+++ b/examples/CXX/put_varn_int.cpp
@@ -122,8 +122,8 @@ int main(int argc, char** argv)
         else if (rank == 3) num_reqs = 4;
 
         if (num_reqs > 0) {
-            starts    = (MPI_Offset**) malloc(num_reqs *        sizeof(MPI_Offset*));
-            counts    = (MPI_Offset**) malloc(num_reqs *        sizeof(MPI_Offset*));
+            starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+            counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
             starts[0] = (MPI_Offset*)  calloc(num_reqs * NDIMS, sizeof(MPI_Offset));
             counts[0] = (MPI_Offset*)  calloc(num_reqs * NDIMS, sizeof(MPI_Offset));
             for (i=1; i<num_reqs; i++) {
@@ -192,7 +192,7 @@ int main(int argc, char** argv)
         }
 
         /* allocate I/O buffer and initialize its contents */
-        buffer = (int*) malloc(w_len * sizeof(int));
+        buffer = (int*) malloc(sizeof(int) * w_len);
         for (i=0; i<w_len; i++) buffer[i] = rank;
 
         /* set the buffer pointers to different offsets to the I/O buffer */
diff --git a/examples/CXX/transpose.cpp b/examples/CXX/transpose.cpp
index c3805aa50..a9076b191 100644
--- a/examples/CXX/transpose.cpp
+++ b/examples/CXX/transpose.cpp
@@ -132,7 +132,7 @@ int main(int argc, char **argv)
     }
 
     /* allocate buffer and initialize with contiguous  numbers */
-    buf = (int *) malloc(bufsize * sizeof(int));
+    buf = (int *) malloc(sizeof(int) * bufsize);
     for (k=0; k<counts[0]; k++)
     for (j=0; j<counts[1]; j++)
     for (i=0; i<counts[2]; i++)
diff --git a/examples/tutorial/pnetcdf-read-flexible.c b/examples/tutorial/pnetcdf-read-flexible.c
index 730c40ef3..d687561cd 100644
--- a/examples/tutorial/pnetcdf-read-flexible.c
+++ b/examples/tutorial/pnetcdf-read-flexible.c
@@ -79,7 +79,7 @@ int main(int argc, char **argv) {
          * the dimids array */
         ret = ncmpi_inq_varndims(ncfile, i, &var_ndims);
         if (ret != NC_NOERR) handle_error(ret, __LINE__);
-        dimids = (int*) malloc(var_ndims * sizeof(int));
+        dimids = (int*) malloc(sizeof(int) * var_ndims);
 
         /* much less coordination in this case compared to rank 0 doing all
          * the i/o: everyone already has the necessary information */
diff --git a/examples/tutorial/pnetcdf-read-from-master.c b/examples/tutorial/pnetcdf-read-from-master.c
index 23bf45330..a4b793b52 100644
--- a/examples/tutorial/pnetcdf-read-from-master.c
+++ b/examples/tutorial/pnetcdf-read-from-master.c
@@ -120,7 +120,7 @@ int main(int argc, char **argv) {
              * allocate the dimids array */
             err = ncmpi_inq_varndims(ncfile, i, &var_ndims);
             if (err != NC_NOERR) handle_error(err, __LINE__);
-            dimids = (int*) malloc(var_ndims * sizeof(int));
+            dimids = (int*) malloc(sizeof(int) * var_ndims);
 
             err = ncmpi_inq_var(ncfile, i, varname, &type, &var_ndims, dimids,
                     &var_natts);
diff --git a/examples/tutorial/pnetcdf-read-nb.c b/examples/tutorial/pnetcdf-read-nb.c
index 0ecc247d2..ec24667b6 100644
--- a/examples/tutorial/pnetcdf-read-nb.c
+++ b/examples/tutorial/pnetcdf-read-nb.c
@@ -81,7 +81,7 @@ int main(int argc, char **argv) {
          * the dimids array */
         ret = ncmpi_inq_varndims(ncfile, i, &var_ndims);
         if (ret != NC_NOERR) handle_error(ret, __LINE__);
-        dimids = (int*) malloc(var_ndims * sizeof(int));
+        dimids = (int*) malloc(sizeof(int) * var_ndims);
 
         /* much less coordination in this case compared to rank 0 doing all
          * the i/o: everyone already has the necessary information */
diff --git a/examples/tutorial/pnetcdf-read-nfiles.c b/examples/tutorial/pnetcdf-read-nfiles.c
index 7926f1fd0..5bc231fd0 100644
--- a/examples/tutorial/pnetcdf-read-nfiles.c
+++ b/examples/tutorial/pnetcdf-read-nfiles.c
@@ -99,7 +99,7 @@ int main(int argc, char **argv) {
          * the dimids array */
         ret = ncmpi_inq_varndims(ncfile, i, &var_ndims);
         if (ret != NC_NOERR) handle_error(ret, __LINE__);
-        dimids = (int*) malloc(var_ndims * sizeof(int));
+        dimids = (int*) malloc(sizeof(int) * var_ndims);
 
         /* much less coordination in this case compared to rank 0 doing all
          * the i/o: everyone already has the necessary information */
diff --git a/examples/tutorial/pnetcdf-read-standard.c b/examples/tutorial/pnetcdf-read-standard.c
index a5db566de..b08aa877f 100644
--- a/examples/tutorial/pnetcdf-read-standard.c
+++ b/examples/tutorial/pnetcdf-read-standard.c
@@ -77,7 +77,7 @@ int main(int argc, char **argv) {
     for(i=0; i<nvars; i++) {
         ret = ncmpi_inq_varndims(ncfile, i, &var_ndims);
         if (ret != NC_NOERR) handle_error(ret, __LINE__);
-        dimids = (int*) malloc(var_ndims * sizeof(int));
+        dimids = (int*) malloc(sizeof(int) * var_ndims);
 
         /* much less coordination in this case compared to rank 0 doing all
          * the i/o: everyone already has the necessary information */
diff --git a/src/binding/f77/buildiface b/src/binding/f77/buildiface
index 5e28d131c..f078621de 100755
--- a/src/binding/f77/buildiface
+++ b/src/binding/f77/buildiface
@@ -1417,7 +1417,7 @@ sub logical_array_ftoc {
 }
 sub logical_array_in_decl {
     my $count = $_[0];
-    print $OUTFD "    int *l$count = (int *)$malloc((size_t)($Array_size) * SIZEOF_INT);\n";
+    print $OUTFD "    int *l$count = (int *)$malloc(sizeof(int) * ($Array_size));\n";
     $clean_up .= "    $free(l$count);\n";
 }
 sub logical_array_in_arg {
@@ -1741,7 +1741,7 @@ sub blankpad_out_ftoc {
 
     # Allocate space to hold the C version of the output
     $strlen = "d$count";
-    print $OUTFD "    p$count = (char *)$malloc( (size_t)$strlen + 1 );\n";
+    print $OUTFD "    p$count = (char *)$malloc((size_t)$strlen + 1);\n";
 }
 sub blankpad_ctof {
     my $coutvar = $_[0];
@@ -1782,7 +1782,7 @@ sub blankpadonflag_out_ftoc {
 
     # Allocate space to hold the C version of the output
     $strlen = "d$count";
-    print $OUTFD "    p$count = (char *)$malloc( (size_t)$strlen + 1 );\n";
+    print $OUTFD "    p$count = (char *)$malloc((size_t)$strlen + 1);\n";
 }
 sub blankpadonflag_ctof {
     my $coutvar = $_[0];
@@ -1864,7 +1864,7 @@ sub addnullandtrim_ftoc {
         while (*p == ' ' && p > v$count) p--;
         p++;
         while (*pin == ' ' && pin < p) pin++;
-        p$count = (char *)$malloc( (size_t)(p-pin) + 1 );
+        p$count = (char *)$malloc((size_t)(p-pin) + 1);
         for (li=0; li<(p-pin); li++) { p$count\[li\] = pin\[li\]; }
         p$count\[li\] = '\\0';
     }
@@ -1919,8 +1919,8 @@ sub chararray_ftoc {
       }\n";
     }
     print $OUTFD "\
-      p$count = (char **)$malloc( (size_t)asize$count * sizeof(char *) );
-      ptmp    = (char *)$malloc( (size_t)asize$count * (d$count + 1) );
+      p$count = (char **)$malloc(sizeof(char *) * (asize$count));
+      ptmp    = (char *)$malloc((size_t)asize$count * (d$count + 1));
       for (i=0; i<asize$count-1; i++) {
           char *p = v$count + i * d$count, *pin, *pdest;
           int j;
@@ -1983,7 +1983,7 @@ sub chararray2_ftoc {
     # arrays are not the same.  In C, for a two dimensional array
     # sized at run time, we must
     # allocate an array of pointers to arrays.
-    #    p = (char ***) malloc( nrows * sizeof(char **) )
+    #    p = (char ***) malloc(sizeof(char **) * nrows)
     # where we are letting using p[nrows][colindex].
     # For MPI_Comm_spawn_multiple, each of these rows is for one command.
     # Each p[k] is a pointer to an array of character strings.
@@ -2004,7 +2004,7 @@ sub chararray2_ftoc {
       int k;
 
       /* Allocate the array of pointers for the commands */
-      p$count = (char ***)$malloc( (size_t)($Array_size) * sizeof(char **) );
+      p$count = (char ***)$malloc(sizeof(char **) * ($Array_size));
 
       for (k=0; k<$Array_size; k++) {
         /* For each command, find the number of command-line arguments.
@@ -2031,8 +2031,8 @@ sub chararray2_ftoc {
 
         /* argcnt is the number of provided arguments.
            Allocate the necessary elements and copy, null terminating copies */
-        pargs = (char **)$malloc( (size_t)(argcnt+1)*sizeof(char *) );
-        pdata = (char *)$malloc( (size_t)arglen );
+        pargs = (char **)$malloc(sizeof(char*) * (argcnt+1));
+        pdata = (char *)$malloc((size_t)arglen );
         p$count\[k\] = pargs;
         pargs\[argcnt\] = '\\0';  /* Null terminate end */
         /* Copy each argument to consequtive locations in pdata,
@@ -2080,7 +2080,7 @@ sub intToAintArr_ftoc {
 #ifdef HAVE_AINT_LARGER_THAN_FINT
     if ($Array_size > 0) {
         int li;
-        l$count = (MPI_Aint *)$malloc( (size_t)($Array_size) * SIZEOF_MPI_AINT );
+        l$count = (MPI_Aint *)$malloc(sizeof(MPI_Aint) * ($Array_size));
         for (li=0; li<$Array_size; li++)
             l$count\[li\] = v$count\[li\];
     }
diff --git a/src/binding/f77/defs b/src/binding/f77/defs
index c504139dc..6b40078a2 100644
--- a/src/binding/f77/defs
+++ b/src/binding/f77/defs
@@ -2066,7 +2066,7 @@ sub intToFintArr_ftoc {
     print $OUTFD "
     {
         int li;
-        l$count = (int*) $malloc((size_t)$Array_size * sizeof(int));
+        l$count = (int*) $malloc(sizeof(int) * ($Array_size));
         for (li=0; li<$Array_size; li++)
             l$count\[li\] = v$count\[li\]; /* convert MPI_Fint to C int */
     }\n";
@@ -2074,7 +2074,7 @@ sub intToFintArr_ftoc {
 sub intToFintArr_out_ftoc {
     my $count = $_[0];
     print $OUTFD "
-    l$count = (int*) $malloc((size_t)$Array_size * sizeof(int));
+    l$count = (int*) $malloc(sizeof(int) * ($Array_size));
     \n";
 }
 sub intToFintArr_in_arg {
@@ -2178,7 +2178,7 @@ sub reorderOffsetArr_ftoc {
     ierr = ncmpi_inq_varndims((int)(*v1), (int)(*v2-1), &ndims); /* get number of dimensions */
     if (ierr != NC_NOERR) return ierr;
 
-    l$count = (MPI_Offset*) $malloc((size_t)ndims * $Array_size * SIZEOF_MPI_OFFSET);
+    l$count = (MPI_Offset*) $malloc(sizeof(MPI_Offset) * ndims * ($Array_size));
     for (li=0; li<ndims; li++) /* convert Fortran order to C order */
         l$count\[li\] = v$count\[ndims-1-li\] - 1; /* convert 1-based to 0-based */\n";
     } else {
@@ -2224,8 +2224,8 @@ sub reorderOffsetArr1DTo2D_ftoc {
     }
     print $OUTFD "
     if (*v3 > 0) {
-        l$count    = (MPI_Offset**) $malloc((size_t)*v3 * sizeof(MPI_Offset*));
-        l$count\[0\] = (MPI_Offset*)  $malloc((size_t)*v3 * (size_t)ndims * SIZEOF_MPI_OFFSET);
+        l$count    = (MPI_Offset**) $malloc(sizeof(MPI_Offset*) * (*v3));
+        l$count\[0\] = (MPI_Offset*)  $malloc(sizeof(MPI_Offset) * (*v3) * (size_t)ndims);
     }
     for (lj=1; lj<*v3; lj++)
         l$count\[lj\] = l$count\[lj-1\] + ndims;
@@ -2282,7 +2282,7 @@ sub reorderIntArr_ftoc {
     if (ierr != NC_NOERR) return ierr;\n"
     }
     print $OUTFD "
-    l$count = (int*) $malloc((size_t)ndims * SIZEOF_INT);
+    l$count = (int*) $malloc(sizeof(int) * ndims);
     for (li=0; li<ndims; li++) /* convert Fortran order to C order */
         l$count\[li\] = v$count\[ndims-1-li\];
     \n";
@@ -2322,7 +2322,7 @@ sub reorderIntArrOut_out_ftoc {
     ierr = ncmpi_inq_varndims((int)(*v1), (int)(*v2-1), &ndims); /* get number of dimensions */
     if (ierr != NC_NOERR) return ierr;
 
-    l$count = (int*) $malloc((size_t)ndims * SIZEOF_INT);
+    l$count = (int*) $malloc(sizeof(int) * ndims);
     \n";
 }
 sub reorderIntArrOut_out_arg {
@@ -2509,7 +2509,7 @@ sub IntIndexInArr_ftoc {
     ln$count = $Array_size;
     if (ln$count > 0) {
         int li;
-        l$count = (int*) $malloc( (size_t)ln$count * SIZEOF_INT);
+        l$count = (int*) $malloc(sizeof(int) * ln$count);
         for (li=0; li<ln$count; li++) /* convert Fortran order to C order */
             l$count\[li\] = v$count\[ln$count-li-1\]-1; /* convert 1-based MPI_Fint to 0-based int */
     }
diff --git a/src/dispatchers/file.c b/src/dispatchers/file.c
index c6c75ac8a..79f05bf78 100644
--- a/src/dispatchers/file.c
+++ b/src/dispatchers/file.c
@@ -815,7 +815,7 @@ ncmpi_open(MPI_Comm    comm,
 
     /* allocate chunk size for pncp->vars[] */
     nalloc = PNETCDF_RNDUP(pncp->nvars, PNC_VARS_CHUNK);
-    pncp->vars = NCI_Malloc(nalloc * sizeof(PNC_var));
+    pncp->vars = NCI_Malloc(sizeof(PNC_var) * nalloc);
     if (pncp->vars == NULL) {
         DEBUG_ASSIGN_ERROR(err, NC_ENOMEM)
         goto fn_exit;
@@ -835,10 +835,10 @@ ncmpi_open(MPI_Comm    comm,
 
         if (ndims > 0) {
             pncp->vars[i].shape = (MPI_Offset*)
-                                  NCI_Malloc(ndims * SIZEOF_MPI_OFFSET);
+                                  NCI_Malloc(sizeof(MPI_Offset) * ndims);
             if (ndims > max_ndims) { /* avoid repeated malloc */
                 if (dimids == DIMIDS) dimids = NULL;
-                dimids = (int*) NCI_Realloc(dimids, ndims * SIZEOF_INT);
+                dimids = (int*) NCI_Realloc(dimids, sizeof(int) * ndims);
                 max_ndims = ndims;
             }
             err = driver->inq_var(pncp->ncp, i, NULL, NULL, NULL,
diff --git a/src/dispatchers/var_getput.m4 b/src/dispatchers/var_getput.m4
index 671697ca2..30d80c76c 100644
--- a/src/dispatchers/var_getput.m4
+++ b/src/dispatchers/var_getput.m4
@@ -27,14 +27,14 @@ define(`GOTO_CHECK',`{ DEBUG_ASSIGN_ERROR(err, $1) goto err_check; }')dnl
 
 #define GET_ONE_COUNT(ndims, count) {                                    \
     int _i;                                                              \
-    count = (MPI_Offset*) NCI_Malloc((size_t)ndims * SIZEOF_MPI_OFFSET); \
+    count = (MPI_Offset*) NCI_Malloc(sizeof(MPI_Offset) * ndims);        \
     for (_i=0; _i<ndims; _i++)                                           \
         count[_i] = 1;                                                   \
 }
 
 #define GET_FULL_DIMENSIONS(pncp, varp, start, count) {                       \
     int _i;                                                                   \
-    start = (MPI_Offset*) NCI_Malloc((size_t)varp.ndims*2*SIZEOF_MPI_OFFSET); \
+    start = (MPI_Offset*) NCI_Malloc(sizeof(MPI_Offset) * varp.ndims * 2);    \
     count = start + varp.ndims;                                               \
                                                                               \
     for (_i=0; _i<varp.ndims; _i++) {                                         \
@@ -661,7 +661,7 @@ MAPINAME($1,$2,$3,$4)(int                ncid,
         return err;
     }')
 
-    reqs = (int*) NCI_Malloc((size_t)nvars * SIZEOF_INT);
+    reqs = (int*) NCI_Malloc(sizeof(int) * nvars);
     for (i=0; i<nvars; i++) {
         MPI_Offset *start, *count, *stride=NULL, *imap=NULL;
 
diff --git a/src/dispatchers/variable.c b/src/dispatchers/variable.c
index 70683014a..ba8c92e16 100644
--- a/src/dispatchers/variable.c
+++ b/src/dispatchers/variable.c
@@ -175,18 +175,18 @@ ncmpi_def_var(int         ncid,    /* IN:  file ID */
 
         /* check if dimids is consistent among all processes */
         if (root_ndims > 0) {
-            int *root_dimids = (int*)NCI_Malloc((size_t)root_ndims *SIZEOF_INT);
+            int *root_dimids = (int*)NCI_Malloc(sizeof(int) * root_ndims);
             if (dimids != NULL)
-                memcpy(root_dimids, dimids, (size_t)root_ndims*SIZEOF_INT);
+                memcpy(root_dimids, dimids, sizeof(int) * root_ndims);
             else
-                memset(root_dimids, 0, (size_t)root_ndims*SIZEOF_INT);
+                memset(root_dimids, 0, sizeof(int) * root_ndims);
             TRACE_COMM(MPI_Bcast)(root_dimids, root_ndims,MPI_INT,0,pncp->comm);
             if (mpireturn != MPI_SUCCESS) {
                 NCI_Free(root_dimids);
                 return ncmpii_error_mpi2nc(mpireturn, "MPI_Bcast");
             }
             if (err == NC_NOERR && dimids != NULL &&
-                memcmp(root_dimids, dimids, (size_t)root_ndims*SIZEOF_INT))
+                memcmp(root_dimids, dimids, sizeof(int) * root_ndims))
                 DEBUG_ASSIGN_ERROR(err, NC_EMULTIDEFINE_VAR_DIMIDS)
             NCI_Free(root_dimids);
         }
@@ -222,7 +222,7 @@ ncmpi_def_var(int         ncid,    /* IN:  file ID */
         }
 
         pncp->vars[*varidp].shape = (MPI_Offset*)
-                                    NCI_Malloc(ndims * SIZEOF_MPI_OFFSET);
+                                    NCI_Malloc(sizeof(MPI_Offset) * ndims);
         for (i=0; i<ndims; i++) {
             /* obtain size of dimension i */
             err = pncp->driver->inq_dim(pncp->ncp, dimids[i], NULL,
diff --git a/src/drivers/common/dtype_decode.c b/src/drivers/common/dtype_decode.c
index 4012943c9..99dc78ff3 100644
--- a/src/drivers/common/dtype_decode.c
+++ b/src/drivers/common/dtype_decode.c
@@ -361,9 +361,9 @@ int ncmpii_dtype_decode(MPI_Datatype  dtype,
         return NC_NOERR;
     }
 
-    array_of_ints = (int *) NCI_Malloc((size_t)num_ints * SIZEOF_INT);
-    array_of_adds = (MPI_Aint *) NCI_Malloc((size_t)num_adds * SIZEOF_MPI_AINT);
-    array_of_dtypes = (MPI_Datatype *) NCI_Malloc((size_t)num_dtypes * sizeof(MPI_Datatype));
+    array_of_ints = (int *) NCI_Malloc(sizeof(int) * num_ints);
+    array_of_adds = (MPI_Aint *) NCI_Malloc(sizeof(MPI_Aint) * num_adds);
+    array_of_dtypes = (MPI_Datatype *) NCI_Malloc(sizeof(MPI_Datatype)* num_dtypes);
 
     if (is_large_type) {
 #ifdef HAVE_MPI_LARGE_COUNT
diff --git a/src/drivers/common/hash_map.c b/src/drivers/common/hash_map.c
index ca45d9f6f..2f3bf1309 100644
--- a/src/drivers/common/hash_map.c
+++ b/src/drivers/common/hash_map.c
@@ -74,7 +74,7 @@ int hash_map_add(hash_map *map, char *key, int val) {
     if (new_node == NULL){
         DEBUG_RETURN_ERROR(NC_ENOMEM);
     }
-    new_node->key = (char*)NCI_Malloc((strlen(key) + 1) * sizeof(char));
+    new_node->key = (char*)NCI_Malloc(sizeof(char) * (strlen(key) + 1));
     if (new_node->key == NULL){
         NCI_Free(new_node);
         DEBUG_RETURN_ERROR(NC_ENOMEM);
diff --git a/src/drivers/common/utf8proc.c b/src/drivers/common/utf8proc.c
index 6beb6349b..b5c5ab4b7 100644
--- a/src/drivers/common/utf8proc.c
+++ b/src/drivers/common/utf8proc.c
@@ -826,7 +826,7 @@ UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map_custom(
   *dstptr = NULL;
   result = utf8proc_decompose_custom(str, strlen, NULL, 0, options, custom_func, custom_data);
   if (result < 0) return result;
-  buffer = (utf8proc_int32_t *) NCI_Malloc(result * sizeof(utf8proc_int32_t) + 1);
+  buffer = (utf8proc_int32_t *) NCI_Malloc(sizeof(utf8proc_int32_t) * result + 1);
   if (!buffer) return UTF8PROC_ERROR_NOMEM;
   result = utf8proc_decompose_custom(str, strlen, buffer, result, options, custom_func, custom_data);
   if (result < 0) {
diff --git a/src/drivers/nc4io/nc4io_file.c b/src/drivers/nc4io/nc4io_file.c
index b19ce526f..7e1c704fa 100644
--- a/src/drivers/nc4io/nc4io_file.c
+++ b/src/drivers/nc4io/nc4io_file.c
@@ -376,13 +376,13 @@ nc4io_inq_misc(void       *ncdp,
          */
         err = nc_inq(nc4p->ncid, &ndim, NULL, NULL, NULL);
         if (err != NC_NOERR) DEBUG_RETURN_ERROR(err);
-        isrec = (int*)NCI_Malloc(SIZEOF_INT * ndim);
-        memset(isrec, 0, SIZEOF_INT * ndim);
+        isrec = (int*)NCI_Malloc(sizeof(int) * ndim);
+        memset(isrec, 0, sizeof(int) * ndim);
 
         /* Get list of unlimited dim */
         err = nc_inq_unlimdims(nc4p->ncid, &nrecdim, NULL);
         if (err != NC_NOERR) DEBUG_RETURN_ERROR(err)
-        recdims = (int*)NCI_Malloc(SIZEOF_INT * nrecdim);
+        recdims = (int*)NCI_Malloc(sizeof(int) * nrecdim);
         err = nc_inq_unlimdims(nc4p->ncid, NULL, recdims);
         if (err != NC_NOERR) DEBUG_RETURN_ERROR(err)
 
@@ -395,7 +395,7 @@ nc4io_inq_misc(void       *ncdp,
         err = nc_inq_varids(nc4p->ncid, &nvar, NULL);
         if (err != NC_NOERR) DEBUG_RETURN_ERROR(err)
 
-        vars = NCI_Malloc(SIZEOF_INT * nvar);
+        vars = NCI_Malloc(sizeof(int) * nvar);
         if (vars == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM)
 
         /* IDs of all variables */
@@ -415,7 +415,7 @@ nc4io_inq_misc(void       *ncdp,
             err = nc_inq_varndims(nc4p->ncid, vars[i], &ndim);
             if (err != NC_NOERR) DEBUG_RETURN_ERROR(err);
 
-            dims = NCI_Malloc(SIZEOF_INT * ndim);
+            dims = NCI_Malloc(sizeof(int) * ndim);
             if (dims == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM);
 
             /* IDs of dimensions */
diff --git a/src/drivers/ncadios/ncadios_bp2ncd.c b/src/drivers/ncadios/ncadios_bp2ncd.c
index 9de53eede..d985ec093 100644
--- a/src/drivers/ncadios/ncadios_bp2ncd.c
+++ b/src/drivers/ncadios/ncadios_bp2ncd.c
@@ -462,9 +462,9 @@ int ncadiosi_parse_header_bp2ncd (NC_ad *ncid)
     uint32_t version = 0;
     is_input_fortran = 0;
 
-    b = malloc (sizeof (struct adios_bp_buffer_struct_v1));
-    b_0 = malloc (sizeof (struct adios_bp_buffer_struct_v1));
-    b_1 = malloc (sizeof (struct adios_bp_buffer_struct_v1));
+    b = malloc(sizeof(struct adios_bp_buffer_struct_v1));
+    b_0 = malloc(sizeof(struct adios_bp_buffer_struct_v1));
+    b_1 = malloc(sizeof(struct adios_bp_buffer_struct_v1));
     adios_buffer_struct_init (b);
 
     rc = adios_posix_open_read_internal (ncid->path, "", b);
@@ -597,14 +597,14 @@ int ncadiosi_parse_header_bp2ncd (NC_ad *ncid)
             err = adios_parse_var_data_header_v1 (b, &var_header);
 
             if (var_header.is_dim == adios_flag_yes) {
-                var_payload.payload = malloc (var_header.payload_size);
+                var_payload.payload = malloc(var_header.payload_size);
                 err = adios_parse_var_data_payload_v1 (b, &var_header, &var_payload
                                                 ,var_header.payload_size
                                                 );
             }
             else {
                 /* alloc size +1 to remove valgrind complaint */
-                var_payload.payload = malloc (var_header.payload_size + 1);
+                var_payload.payload = malloc(var_header.payload_size + 1);
                 err = adios_parse_var_data_payload_v1 (b, &var_header, &var_payload
                                                 ,var_header.payload_size
                                                 );
diff --git a/src/drivers/ncadios/ncadios_internal.c b/src/drivers/ncadios/ncadios_internal.c
index e0a880a36..7443d0df7 100644
--- a/src/drivers/ncadios/ncadios_internal.c
+++ b/src/drivers/ncadios/ncadios_internal.c
@@ -54,8 +54,8 @@ int ncadiosi_def_var(NC_ad* ncadp, char* name, nc_type type, int ndim,
     if (CHECK_NAME(name)){
         var.type = type;
         var.ndim = ndim;
-        var.dimids = NCI_Malloc(SIZEOF_INT * ndim);
-        memcpy(var.dimids, dimids, SIZEOF_INT * ndim);
+        var.dimids = NCI_Malloc(sizeof(int) * ndim);
+        memcpy(var.dimids, dimids, sizeof(int) * ndim);
         var.name = NCI_Malloc(strlen(name) + 1);
         strcpy(var.name, name);
         ncadiosi_att_list_init(&(var.atts));
@@ -167,7 +167,7 @@ int ncadiosi_parse_header_readall (NC_ad *ncadp) {
             if (dimids != NULL){
                 NCI_Free(dimids);
             }
-            dimids = (int*)NCI_Malloc(SIZEOF_INT * maxndim);
+            dimids = (int*)NCI_Malloc(sizeof(int) * maxndim);
         }
 
         /* Record every dimensions */
diff --git a/src/drivers/ncadios/ncadios_lists.c b/src/drivers/ncadios/ncadios_lists.c
index 738ed295d..3bf4e29cb 100644
--- a/src/drivers/ncadios/ncadios_lists.c
+++ b/src/drivers/ncadios/ncadios_lists.c
@@ -73,7 +73,7 @@ int ncadiosi_var_list_add(NC_ad_var_list *list, NC_ad_var data) {
 
     if (list->nalloc == 0){
         list->nalloc = 16;
-        list->data = NCI_Malloc(list->nalloc * sizeof(NC_ad_var));
+        list->data = NCI_Malloc(sizeof(NC_ad_varp) * list->nalloc);
     }
     else if (list->nalloc == id){
         list->nalloc *= 2;
@@ -93,7 +93,7 @@ int ncadiosi_dim_list_add(NC_ad_dim_list *list, NC_ad_dim data) {
 
     if (list->nalloc == 0){
         list->nalloc = 16;
-        list->data = NCI_Malloc(list->nalloc * sizeof(NC_ad_dim));
+        list->data = NCI_Malloc(sizeof(NC_ad_dim) * list->nalloc);
     }
     else if (list->nalloc == id){
         list->nalloc *= 2;
@@ -113,11 +113,11 @@ int ncadiosi_att_list_add(NC_ad_att_list *list, int data) {
 
     if (list->nalloc == 0){
         list->nalloc = 16;
-        list->data = NCI_Malloc(list->nalloc * SIZEOF_INT);
+        list->data = NCI_Malloc(sizeof(int) * list->nalloc);
     }
     else if (list->nalloc == id){
         list->nalloc *= 2;
-        list->data = NCI_Realloc(list->data, list->nalloc * SIZEOF_INT);
+        list->data = NCI_Realloc(list->data, list->nalloc * sizeof(int));
     }
 
     list->data[id] = data;
diff --git a/src/drivers/ncadios/ncadios_nonblocking.c b/src/drivers/ncadios/ncadios_nonblocking.c
index 565bc1b9e..ddb17aee3 100644
--- a/src/drivers/ncadios/ncadios_nonblocking.c
+++ b/src/drivers/ncadios/ncadios_nonblocking.c
@@ -76,9 +76,9 @@ int ncadiosi_get_list_init(NC_ad_get_list *lp) {
     /* Initialize parameter and allocate the array  */
     lp->nused = 0;
     lp->nalloc = PUT_ARRAY_SIZE;
-    lp->reqs = (NC_ad_get_req*)NCI_Malloc(lp->nalloc * sizeof(NC_ad_get_req));
-    lp->ids = (int*)NCI_Malloc(lp->nalloc * SIZEOF_INT);
-    lp->pos = (int*)NCI_Malloc(lp->nalloc * SIZEOF_INT);
+    lp->reqs = (NC_ad_get_req*)NCI_Malloc(sizeof(NC_ad_get_req) * lp->nalloc);
+    lp->ids = (int*)NCI_Malloc(sizeof(int) * lp->nalloc);
+    lp->pos = (int*)NCI_Malloc(sizeof(int) * lp->nalloc);
     if (lp->reqs == NULL || lp->ids == NULL) {
         DEBUG_RETURN_ERROR(NC_ENOMEM);
     }
@@ -114,11 +114,11 @@ static int ncadiosi_get_list_resize(NC_ad_get_list *lp)
     if (ptr == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM);
     lp->reqs = (NC_ad_get_req*)ptr;
 
-    ptr = NCI_Realloc(lp->ids, nsize * SIZEOF_INT);
+    ptr = NCI_Realloc(lp->ids, sizeof(int) * nsize);
     if (ptr == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM);
     lp->ids = (int*)ptr;
 
-    ptr = NCI_Realloc(lp->pos, nsize * SIZEOF_INT);
+    ptr = NCI_Realloc(lp->pos, sizeof(int) * nsize);
     if (ptr == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM);
     lp->pos = (int*)ptr;
 
diff --git a/src/drivers/ncbbio/ncbbio_file.c b/src/drivers/ncbbio/ncbbio_file.c
index 26d4f105f..271f1b969 100644
--- a/src/drivers/ncbbio/ncbbio_file.c
+++ b/src/drivers/ncbbio/ncbbio_file.c
@@ -567,7 +567,7 @@ ncbbio_cancel(void *ncdp,
      * req_ids.  We do onw swap for each put request, so there are at most
      * num_req swaps.
      */
-    swapidx = (int*)NCI_Malloc(SIZEOF_INT * num_req);
+    swapidx = (int*)NCI_Malloc(sizeof(int) * num_req);
 
     /* Count the number of put requests and swap it to the first section.  nput
      * is number of put request known so far, it also mark the end of the first
@@ -755,7 +755,7 @@ ncbbio_wait(void *ncdp,
      * req_ids.  We do onw swap for each put request, so there are at most
      * num_reqs swaps
      */
-    swapidx = (int*)NCI_Malloc(SIZEOF_INT * num_reqs);
+    swapidx = (int*)NCI_Malloc(sizeof(int) * num_reqs);
 
     /* Count the number of put requests and swap it to the first section
      * nput is number of put request known so far, it also mark the end of the
diff --git a/src/drivers/ncbbio/ncbbio_log.c b/src/drivers/ncbbio/ncbbio_log.c
index 5b22b8339..a16fe9ddc 100644
--- a/src/drivers/ncbbio/ncbbio_log.c
+++ b/src/drivers/ncbbio/ncbbio_log.c
@@ -87,7 +87,7 @@ int ncbbio_log_create(NC_bb* ncbbp,
     }
     else {
         size_t i = strlen(path);
-        fdir = (char*)NCI_Malloc((i + 1) * sizeof(char));
+        fdir = (char*)NCI_Malloc(sizeof(char) * (i + 1));
         strncpy(fdir, path, i + 1);
         /* Search for first '\' from the back */
         for (i--; i > -1; i--) {
diff --git a/src/drivers/ncbbio/ncbbio_log_flush.c b/src/drivers/ncbbio/ncbbio_log_flush.c
index a87ee249a..5b4687874 100644
--- a/src/drivers/ncbbio/ncbbio_log_flush.c
+++ b/src/drivers/ncbbio/ncbbio_log_flush.c
@@ -154,8 +154,8 @@ int ncbbio_log_flush_core(NC_bb *ncbbp) {
     }
 
 
-    reqids = (int*)NCI_Malloc(ncbbp->entrydatasize.nused * SIZEOF_INT);
-    stats = (int*)NCI_Malloc(ncbbp->entrydatasize.nused * SIZEOF_INT);
+    reqids = (int*)NCI_Malloc(sizeof(int) * ncbbp->entrydatasize.nused);
+    stats = (int*)NCI_Malloc(sizeof(int) * ncbbp->entrydatasize.nused);
 
     /*
      * Iterate through meta log entries
@@ -299,7 +299,7 @@ int ncbbio_log_flush_core(NC_bb *ncbbp) {
 #endif
 
                     /* Replay event with non-blocking call */
-                    if ((size_t)(entryp->esize) == sizeof(NC_bb_metadataentry) + entryp->ndims * SIZEOF_MPI_OFFSET * num){
+                    if ((size_t)(entryp->esize) == sizeof(NC_bb_metadataentry) + sizeof(MPI_Offset) * entryp->ndims * num){
                         err = ncbbp->ncmpio_driver->iput_varn(ncbbp->ncp, entryp->varid, num, starts, NULL, (void*)(databufferoff), -1, buftype, reqids + j, NC_REQ_WR | NC_REQ_NBI | NC_REQ_HL);
                     }
                     else{
diff --git a/src/drivers/ncbbio/ncbbio_mem.c b/src/drivers/ncbbio/ncbbio_mem.c
index d5b82d628..8e71959d5 100644
--- a/src/drivers/ncbbio/ncbbio_mem.c
+++ b/src/drivers/ncbbio/ncbbio_mem.c
@@ -86,7 +86,7 @@ char* ncbbio_log_buffer_alloc(NC_bb_buffer *bp, size_t size) {
  * IN   ep: array to be initialized
  */
 int ncbbio_log_sizearray_init(NC_bb_sizevector *sp){
-    sp->values = (size_t*)NCI_Malloc(LOG_ARRAY_SIZE * sizeof(size_t));
+    sp->values = (size_t*)NCI_Malloc(sizeof(size_t) * LOG_ARRAY_SIZE);
     if (sp->values == NULL){
         DEBUG_RETURN_ERROR(NC_ENOMEM);
     }
@@ -144,7 +144,7 @@ int ncbbio_log_sizearray_append(NC_bb_sizevector *sp, size_t size) {
  * IN   vp: vector to be initialized
  */
 int ncbbio_log_intvector_init(NC_bb_intvector *vp){
-    vp->values = (int*)NCI_Malloc(LOG_ARRAY_SIZE * SIZEOF_INT);
+    vp->values = (int*)NCI_Malloc(sizeof(int) * LOG_ARRAY_SIZE);
     if (vp->values == NULL){
         DEBUG_RETURN_ERROR(NC_ENOMEM);
     }
@@ -181,7 +181,7 @@ int ncbbio_log_intvector_append(NC_bb_intvector *vp, int size) {
          */
         size_t newsize = vp->nalloc * SIZE_MULTIPLIER;
         /* ret is used to temporaryly hold the allocated buffer so we don't lose ncbbp->metadata.buffer if allocation fails */
-        ret = (int*)NCI_Realloc(vp->values, newsize * SIZEOF_INT);
+        ret = (int*)NCI_Realloc(vp->values, sizeof(int) * newsize);
         /* If not enough memory */
         if (ret == NULL) {
             return NC_ENOMEM;
diff --git a/src/drivers/ncbbio/ncbbio_misc.c b/src/drivers/ncbbio/ncbbio_misc.c
index 35b9d863e..897a9436b 100644
--- a/src/drivers/ncbbio/ncbbio_misc.c
+++ b/src/drivers/ncbbio/ncbbio_misc.c
@@ -39,8 +39,8 @@ int ncbbio_get_node_comm(MPI_Comm global_comm, MPI_Comm *node_comm)
 
     hash_map_init(&map, 65535, hash);
 
-    myname = (char*)NCI_Malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
-    buf = (char*)NCI_Malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char) * np);
+    myname = (char*)NCI_Malloc(MPI_MAX_PROCESSOR_NAME);
+    buf = (char*)NCI_Malloc(MPI_MAX_PROCESSOR_NAME * np);
 
     err = MPI_Get_processor_name(myname, &namelen);
     if (err != MPI_SUCCESS){
diff --git a/src/drivers/ncbbio/ncbbio_nonblocking.c b/src/drivers/ncbbio/ncbbio_nonblocking.c
index 317090512..8a1c2b31f 100644
--- a/src/drivers/ncbbio/ncbbio_nonblocking.c
+++ b/src/drivers/ncbbio/ncbbio_nonblocking.c
@@ -63,8 +63,8 @@ int ncbbio_put_list_init(NC_bb *ncbbp) {
     /* Initialize parameter and allocate the array  */
     lp->nused = 0;
     lp->nalloc = PUT_ARRAY_SIZE;
-    lp->reqs = (NC_bb_put_req*)NCI_Malloc(lp->nalloc * sizeof(NC_bb_put_req));
-    lp->ids = (int*)NCI_Malloc(lp->nalloc * SIZEOF_INT);
+    lp->reqs = (NC_bb_put_req*)NCI_Malloc(sizeof(NC_bb_put_req) * lp->nalloc);
+    lp->ids = (int*)NCI_Malloc(sizeof(int) * lp->nalloc);
     if (lp->reqs == NULL || lp->ids == NULL) {
         DEBUG_RETURN_ERROR(NC_ENOMEM);
     }
@@ -100,7 +100,7 @@ static int ncbbio_put_list_resize(NC_bb *ncbbp)
     if (ptr == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM);
 
     lp->reqs = (NC_bb_put_req*)ptr;
-    ptr = NCI_Realloc(lp->ids, nsize * SIZEOF_INT);
+    ptr = NCI_Realloc(lp->ids, sizeof(int) * nsize);
     if (ptr == NULL) DEBUG_RETURN_ERROR(NC_ENOMEM);
 
     lp->ids = (int*)ptr;
diff --git a/src/drivers/ncmpio/ncmpio_enddef.c b/src/drivers/ncmpio/ncmpio_enddef.c
index 21606f683..b33e00d4a 100644
--- a/src/drivers/ncmpio/ncmpio_enddef.c
+++ b/src/drivers/ncmpio/ncmpio_enddef.c
@@ -80,7 +80,7 @@ move_file_block(NC         *ncp,
     if (nbytes >= p_units)
         do_open = 1;
     else {
-        int n_units = nbytes / MOVE_UNIT;
+        MPI_Offset n_units = nbytes / MOVE_UNIT;
         if (nbytes % MOVE_UNIT) n_units++;
         if (rank < n_units) do_open = 1;
     }
@@ -943,7 +943,7 @@ ncmpio_NC_check_voffs(NC *ncp)
     if (num_fix_vars == 0) goto check_rec_var;
 
     /* check non-record variables first */
-    var_off_len = (off_len*) NCI_Malloc(num_fix_vars * sizeof(off_len));
+    var_off_len = (off_len*) NCI_Malloc(sizeof(off_len) * num_fix_vars);
     for (i=0, j=0; i<ncp->vars.ndefined; i++) {
         NC_var *varp = ncp->vars.value[i];
         if (varp->begin < ncp->xsz) {
@@ -1000,7 +1000,7 @@ ncmpio_NC_check_voffs(NC *ncp)
     if (ncp->vars.num_rec_vars == 0) return NC_NOERR;
 
     /* check record variables */
-    var_off_len = (off_len*) NCI_Malloc(ncp->vars.num_rec_vars * sizeof(off_len));
+    var_off_len = (off_len*) NCI_Malloc(sizeof(off_len) * ncp->vars.num_rec_vars);
     for (i=0, j=0; i<ncp->vars.ndefined; i++) {
         NC_var *varp = ncp->vars.value[i];
         if (!IS_RECVAR(varp)) continue;
diff --git a/src/drivers/ncmpio/ncmpio_filetype.c b/src/drivers/ncmpio/ncmpio_filetype.c
index 4a1090d52..8a7e46d8b 100644
--- a/src/drivers/ncmpio/ncmpio_filetype.c
+++ b/src/drivers/ncmpio/ncmpio_filetype.c
@@ -126,7 +126,7 @@ type_create_subarray64(int               ndims,
 #ifdef HAVE_MPI_LARGE_COUNT
     MPI_Count *sizes, *subsizes, *starts;
 
-    sizes = (MPI_Count*) NCI_Malloc((size_t)ndims * 3 * sizeof(MPI_Count));
+    sizes = (MPI_Count*) NCI_Malloc(sizeof(MPI_Count) * ndims * 3);
     subsizes = sizes    + ndims;
     starts   = subsizes + ndims;
     for (i=0; i<ndims; i++) {
@@ -161,7 +161,7 @@ type_create_subarray64(int               ndims,
         int *sizes, *subsizes, *starts;
         /* none of dimensions > 2^31-1, we can safely use
          * MPI_Type_create_subarray */
-        sizes = (int*) NCI_Malloc((size_t)ndims * 3 * SIZEOF_INT);
+        sizes = (int*) NCI_Malloc(sizeof(int) * ndims * 3);
         subsizes = sizes    + ndims;
         starts   = subsizes + ndims;
         for (i=0; i<ndims; i++) {
diff --git a/src/drivers/ncmpio/ncmpio_fill.c b/src/drivers/ncmpio/ncmpio_fill.c
index d96eb9c25..712c3fd66 100644
--- a/src/drivers/ncmpio/ncmpio_fill.c
+++ b/src/drivers/ncmpio/ncmpio_fill.c
@@ -419,11 +419,11 @@ fillerup_aggregate(NC *ncp, NC *old_ncp)
 
     /* find the number of write segments (upper bound) */
     nsegs = (size_t)(ncp->vars.ndefined + ncp->vars.num_rec_vars * nrecs);
-    count  = (MPI_Offset*) NCI_Malloc(nsegs * SIZEOF_MPI_OFFSET);
+    count  = (MPI_Offset*) NCI_Malloc(sizeof(MPI_Offset) * nsegs);
 #ifdef HAVE_MPI_LARGE_COUNT
-    offset = (MPI_Count*)   NCI_Malloc(nsegs * sizeof(MPI_Count));
+    offset = (MPI_Count*)   NCI_Malloc(sizeof(MPI_Count) * nsegs);
 #else
-    offset = (MPI_Aint*)   NCI_Malloc(nsegs * SIZEOF_MPI_AINT);
+    offset = (MPI_Aint*)   NCI_Malloc(sizeof(MPI_Aint) * nsegs);
 #endif
 
     /* calculate each segment's offset and count */
@@ -513,9 +513,9 @@ fillerup_aggregate(NC *ncp, NC *old_ncp)
 
     /* allocate one contiguous buffer space for all writes */
 #ifdef HAVE_MPI_LARGE_COUNT
-    blocklengths = (MPI_Count*) NCI_Malloc((size_t)j * sizeof(MPI_Count));
+    blocklengths = (MPI_Count*) NCI_Malloc(sizeof(MPI_Count) * j);
 #else
-    blocklengths = (int*) NCI_Malloc((size_t)j * SIZEOF_INT);
+    blocklengths = (int*) NCI_Malloc(sizeof(int) * j);
 #endif
     buf = NCI_Malloc((size_t)buf_len);
     buf_ptr = (char*)buf;
diff --git a/src/drivers/ncmpio/ncmpio_i_varn.m4 b/src/drivers/ncmpio/ncmpio_i_varn.m4
index 0d08666b1..be9af9752 100644
--- a/src/drivers/ncmpio/ncmpio_i_varn.m4
+++ b/src/drivers/ncmpio/ncmpio_i_varn.m4
@@ -75,7 +75,7 @@ igetput_varn(NC                *ncp,
     /* validity of starts and counts has been checked at dispatcher layer */
 
     /* calculate nelems and the number of new non-lead and non-zero requests */
-    req_nelems = (MPI_Offset*) NCI_Malloc(num * SIZEOF_MPI_OFFSET);
+    req_nelems = (MPI_Offset*) NCI_Malloc(sizeof(MPI_Offset) * num);
     new_nreqs = 0;
     nelems    = 0;
     if (counts != NULL) {
@@ -161,7 +161,7 @@ igetput_varn(NC                *ncp,
     /* for nonblocking API, return now if request size is zero */
     if (nbytes == 0) goto fn_exit;
 
-    memChunk = varp->ndims * SIZEOF_MPI_OFFSET;
+    memChunk = sizeof(MPI_Offset) * varp->ndims;
 
     /* check if type conversion and Endianness byte swap is needed */
     need_convert = ncmpii_need_convert(ncp->format, varp->xtype, itype);
diff --git a/src/drivers/ncmpio/ncmpio_subfile.c b/src/drivers/ncmpio/ncmpio_subfile.c
index 3ea09bb7a..8ed72fba3 100644
--- a/src/drivers/ncmpio/ncmpio_subfile.c
+++ b/src/drivers/ncmpio/ncmpio_subfile.c
@@ -394,8 +394,8 @@ int ncmpio_subfile_partition(NC *ncp)
             } /* for each dim */
 
             /* master file: replace the original var with scalar var */
-            vpp[i]->dimids_org = (int*) NCI_Malloc((size_t)vpp[i]->ndims * SIZEOF_INT);
-            memcpy(vpp[i]->dimids_org, vpp[i]->dimids, (size_t)vpp[i]->ndims*SIZEOF_INT);
+            vpp[i]->dimids_org = (int*) NCI_Malloc(sizeof(int) * vpp[i]->ndims);
+            memcpy(vpp[i]->dimids_org, vpp[i]->dimids, sizeof(int) * vpp[i]->ndims);
             vpp[i]->ndims_org = vpp[i]->ndims;
             vpp[i]->ndims = 0;
             if (IS_RECVAR(vpp[i])) {
@@ -509,10 +509,10 @@ ncmpio_subfile_getput_vars(NC               *ncp,
                             &color, MPI_INT);
     if (status != NC_NOERR) DEBUG_RETURN_ERROR(status)
 
-    count_my_req_per_proc = (int *)NCI_Calloc((size_t)nprocs, SIZEOF_INT);
-    count_others_req_per_proc = (int *)NCI_Calloc((size_t)nprocs, SIZEOF_INT);
-    buf_count_my = (MPI_Offset *)NCI_Calloc((size_t)nprocs, SIZEOF_MPI_OFFSET);
-    buf_count_others = (MPI_Offset *)NCI_Calloc((size_t)nprocs, SIZEOF_MPI_OFFSET);
+    count_my_req_per_proc = (int *)NCI_Calloc((size_t)nprocs, sizeof(int));
+    count_others_req_per_proc = (int *)NCI_Calloc((size_t)nprocs, sizeof(int));
+    buf_count_my = (MPI_Offset *)NCI_Calloc((size_t)nprocs, sizeof(MPI_Offset));
+    buf_count_others = (MPI_Offset *)NCI_Calloc((size_t)nprocs, sizeof(MPI_Offset));
 
     /* TODO: shouldn't it be initialized to 0? */
     for (i=0; i<nprocs; i++) {
@@ -525,7 +525,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
 
     /* init allocated my_req */
     for (i=0; i<nprocs; i++) {
-        my_req[i].start = (MPI_Offset*)NCI_Malloc((size_t)(3 * ndims_org * SIZEOF_MPI_OFFSET));
+        my_req[i].start = (MPI_Offset*)NCI_Malloc(sizeof(MPI_Offset) * 3 * ndims_org);
         my_req[i].count = my_req[i].start + ndims_org;
         my_req[i].start_org = my_req[i].count + ndims_org;
         /* init start/count to -1 */
@@ -696,7 +696,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
     others_req = (NC_subfile_access *) NCI_Calloc((size_t)nprocs, sizeof(NC_subfile_access));
     /* init allocated others_req */
     for (i=0; i<nprocs; i++) {
-        others_req[i].start = (MPI_Offset *)NCI_Malloc((size_t)(3 * ndims_org * SIZEOF_MPI_OFFSET));
+        others_req[i].start = (MPI_Offset *)NCI_Malloc(sizeof(MPI_Offset) * 3 * ndims_org);
         others_req[i].count = others_req[i].start + ndims_org;
         others_req[i].start_org = others_req[i].count + ndims_org;
         /* init start/count to -1 */
@@ -851,7 +851,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
     int *array_of_requests;
     int *array_of_statuses;
     /* TODO: each proc can't get more than nprocs-1?? */
-    array_of_requests = (int *)NCI_Malloc((size_t)nprocs * SIZEOF_INT);
+    array_of_requests = (int *)NCI_Malloc(sizeof(int) * nprocs);
     for (i=0; i<nprocs; i++)
         array_of_requests[i] = NC_REQ_NULL;
 
@@ -879,7 +879,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
 
     /* doing other proc's request to my subfile
        TODO: each proc can't get more than nprocs?? */
-    requests = (MPI_Request *)NCI_Malloc((size_t)nprocs*2*sizeof(MPI_Request));
+    requests = (MPI_Request *)NCI_Malloc(sizeof(MPI_Request) * nprocs * 2);
 
     j = 0;
 #ifdef TAU_SSON
@@ -897,7 +897,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
         if (count_others_req_per_proc[i] != 0 && i != myrank)
             TRACE_COMM(MPI_Isend)(&count_my_req_per_proc[i], 1, MPI_INT, i, i+myrank, ncp->comm, &requests[j++]);
 
-    statuses = (MPI_Status *)NCI_Malloc((size_t)j*sizeof(MPI_Status));
+    statuses = (MPI_Status *)NCI_Malloc(sizeof(MPI_Status) * j);
     TRACE_COMM(MPI_Waitall)(j, requests, statuses);
 #ifdef TAU_SSON
     TAU_PHASE_STOP(t52);
@@ -907,7 +907,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
     NCI_Free(requests);
 
     j = 0;
-    requests = (MPI_Request *)NCI_Malloc((size_t)nprocs*2*sizeof(MPI_Request));
+    requests = (MPI_Request *)NCI_Malloc(sizeof(MPI_Request) * nprocs * 2);
 
 #ifdef TAU_SSON
     TAU_PHASE_CREATE_STATIC(t53, "SSON --- getput_vars: exch start,count,", "", TAU_USER);
@@ -916,7 +916,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
     /* when dest rank == myrank */
     if (count_others_req_per_proc[myrank] > 0)
         memcpy(others_req[myrank].start, my_req[myrank].start,
-               (size_t)ndims_org * 3 * SIZEOF_MPI_OFFSET);
+               sizeof(MPI_Offset) * ndims_org * 3);
 
     /* exchange my_req's and others_req's start[], count[], and start_org[] */
     for (i=0; i<nprocs; i++) {
@@ -931,7 +931,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
                       i+myrank, ncp->comm, &requests[j++]);
     }
 
-    statuses = (MPI_Status *)NCI_Malloc((size_t)j*sizeof(MPI_Status));
+    statuses = (MPI_Status *)NCI_Malloc(sizeof(MPI_Status) * j);
     TRACE_COMM(MPI_Waitall)(j, requests, statuses);
     NCI_Free(statuses);
     NCI_Free(requests);
@@ -973,7 +973,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
 #endif
 
     j = 0;
-    requests = (MPI_Request *)NCI_Malloc((size_t)nprocs*2*sizeof(MPI_Request));
+    requests = (MPI_Request *)NCI_Malloc(sizeof(MPI_Request) * nprocs * 2);
 
     xbuf = (void**)NCI_Calloc((size_t)nprocs, sizeof(void *));
 
@@ -1036,7 +1036,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
         } /* end if() */
     } /* end for() */
 
-    statuses = (MPI_Status *)NCI_Malloc((size_t)j * sizeof(MPI_Status));
+    statuses = (MPI_Status *)NCI_Malloc(sizeof(MPI_Status) * j);
     TRACE_COMM(MPI_Waitall)(j, requests, statuses);
     NCI_Free(statuses);
     NCI_Free(requests);
@@ -1083,7 +1083,7 @@ ncmpio_subfile_getput_vars(NC               *ncp,
     double stime, wait_time;
     stime = MPI_Wtime();
     */
-    array_of_statuses = (int *)NCI_Malloc((size_t)nasyncios * SIZEOF_INT);
+    array_of_statuses = (int *)NCI_Malloc(sizeof(int) * nasyncios);
     status = ncmpio_wait(ncp->ncp_sf, nasyncios, array_of_requests, array_of_statuses, NC_REQ_COLL);
     if (status != NC_NOERR) DEBUG_RETURN_ERROR(status)
     NCI_Free(array_of_statuses);
diff --git a/src/drivers/ncmpio/ncmpio_util.c b/src/drivers/ncmpio/ncmpio_util.c
index fb522f0e1..7124c424a 100644
--- a/src/drivers/ncmpio/ncmpio_util.c
+++ b/src/drivers/ncmpio/ncmpio_util.c
@@ -64,7 +64,7 @@ void ncmpio_set_pnetcdf_hints(NC *ncp,
         /* Hint nc_header_align_size is now deprecated. But for backward
          * compatibility, let's still check.
          */
-        int info_h_align = -1;
+        MPI_Offset info_h_align = -1;
         MPI_Info_get(user_info, "nc_header_align_size", MPI_MAX_INFO_VAL-1,
                      value, &flag);
         if (flag) {
@@ -348,7 +348,7 @@ ncmpio_last_offset(const NC         *ncp,
 
     /* when count == NULL, this is called from a var API */
     if (count != NULL) {
-        last_indx = (MPI_Offset*) NCI_Malloc((size_t)ndims * SIZEOF_MPI_OFFSET);
+        last_indx = (MPI_Offset*) NCI_Malloc(sizeof(MPI_Offset) * ndims);
 
         if (stride != NULL) {
             for (i=0; i<ndims; i++) {
diff --git a/src/drivers/ncmpio/ncmpio_var.c b/src/drivers/ncmpio/ncmpio_var.c
index bdc6cd54f..df66a52c0 100644
--- a/src/drivers/ncmpio/ncmpio_var.c
+++ b/src/drivers/ncmpio/ncmpio_var.c
@@ -62,9 +62,9 @@ ncmpio_new_NC_var(char *name, size_t name_len, int ndims)
     if (varp == NULL) return NULL;
 
     if (ndims > 0) {
-        varp->shape  = (MPI_Offset*)NCI_Calloc(ndims, SIZEOF_MPI_OFFSET);
-        varp->dsizes = (MPI_Offset*)NCI_Calloc(ndims, SIZEOF_MPI_OFFSET);
-        varp->dimids = (int *)      NCI_Calloc(ndims, SIZEOF_INT);
+        varp->shape  = (MPI_Offset*)NCI_Calloc(ndims, sizeof(MPI_Offset));
+        varp->dsizes = (MPI_Offset*)NCI_Calloc(ndims, sizeof(MPI_Offset));
+        varp->dimids = (int *)      NCI_Calloc(ndims, sizeof(int));
     }
 
     varp->name     = name;         /* name has been malloc-ed */
@@ -94,7 +94,7 @@ dup_NC_var(const NC_var *rvarp, int attr_hsize)
 
     /* copy dimids[] */
     if (rvarp->ndims != 0 && rvarp->dimids != NULL)
-        memcpy(varp->dimids, rvarp->dimids, (size_t)rvarp->ndims * SIZEOF_INT);
+        memcpy(varp->dimids, rvarp->dimids, sizeof(int) * rvarp->ndims);
 
 #ifndef SEARCH_NAME_LINEARLY
     /* initialize hashing lookup table size for attributes */
@@ -112,8 +112,8 @@ dup_NC_var(const NC_var *rvarp, int attr_hsize)
      * compute_var_shape() to recompute it after a new variable is created
      */
     if (rvarp->ndims > 0) { /* skip memcpy if ndims == 0 (scalar variables) */
-        memcpy(varp->shape,  rvarp->shape,  (size_t)rvarp->ndims * SIZEOF_MPI_OFFSET);
-        memcpy(varp->dsizes, rvarp->dsizes, (size_t)rvarp->ndims * SIZEOF_MPI_OFFSET);
+        memcpy(varp->shape,  rvarp->shape,  sizeof(MPI_Offset) * rvarp->ndims);
+        memcpy(varp->dsizes, rvarp->dsizes, sizeof(MPI_Offset) * rvarp->ndims);
     }
     varp->xsz   = rvarp->xsz;
     varp->len   = rvarp->len;
@@ -384,7 +384,7 @@ ncmpio_def_var(void       *ncdp,
 
     /* copy dimids[] */
     if (ndims != 0 && dimids != NULL)
-        memcpy(varp->dimids, dimids, (size_t)ndims * SIZEOF_INT);
+        memcpy(varp->dimids, dimids, sizeof(int) * ndims);
 
     /* set up array dimensional structures */
     err = ncmpio_NC_var_shape64(varp, &ncp->dims);
@@ -536,11 +536,11 @@ ncmpio_inq_var(void       *ncdp,
 #ifdef ENABLE_SUBFILING
         /* varp->dimids_org is already set during open or enddef */
         if (varp->num_subfiles > 1 && varp->ndims_org > 0)
-            memcpy(dimids, varp->dimids_org, (size_t)varp->ndims_org * SIZEOF_INT);
+            memcpy(dimids, varp->dimids_org, sizeof(int) * varp->ndims_org);
         else
 #endif
         if (varp->ndims > 0)
-            memcpy(dimids, varp->dimids, (size_t)varp->ndims * SIZEOF_INT);
+            memcpy(dimids, varp->dimids, sizeof(int) * varp->ndims);
     }
     if (nattsp != NULL) *nattsp = varp->attrs.ndefined;
 
diff --git a/src/drivers/ncmpio/ncmpio_wait.c b/src/drivers/ncmpio/ncmpio_wait.c
index 9df020f35..a4b2b7f3e 100644
--- a/src/drivers/ncmpio/ncmpio_wait.c
+++ b/src/drivers/ncmpio/ncmpio_wait.c
@@ -354,7 +354,7 @@ construct_filetypes(NC           *ncp,
     }
 
     /* hereinafter, num_reqs > 0 */
-    ftypes = (MPI_Datatype*) NCI_Malloc((size_t)num_reqs * sizeof(MPI_Datatype));
+    ftypes = (MPI_Datatype*) NCI_Malloc(sizeof(MPI_Datatype) * num_reqs);
 
     /* create a filetype for each request */
     last_contig_req = -1; /* index of the last contiguous request */
@@ -777,9 +777,9 @@ extract_reqs(NC      *ncp,
 
     /* allocate put_list and get_list */
     if (*num_w_reqs)
-        *put_list = (NC_req*) NCI_Malloc((*num_w_reqs)*sizeof(NC_req));
+        *put_list = (NC_req*) NCI_Malloc(sizeof(NC_req) * (*num_w_reqs));
     if (*num_r_reqs)
-        *get_list = (NC_req*) NCI_Malloc((*num_r_reqs)*sizeof(NC_req));
+        *get_list = (NC_req*) NCI_Malloc(sizeof(NC_req) * (*num_r_reqs));
 
     /* copy over ncp->put_list and ncp->get_list to *put_list and *get_list */
     put_list_ptr = *put_list;
@@ -1291,7 +1291,7 @@ vars_flatten(int          ndim,    /* number of dimensions */
     }
 
     if (stride == NULL) { /* equivalent to {1, 1, ..., 1} */
-        stride = (MPI_Offset*) NCI_Malloc((size_t)ndim * SIZEOF_MPI_OFFSET);
+        stride = (MPI_Offset*) NCI_Malloc(sizeof(MPI_Offset) * ndim);
         for (i=0; i<ndim; i++) stride[i] = 1;
         to_free_stride = 1;
     }
@@ -1428,7 +1428,7 @@ merge_requests(NC          *ncp,
     }
 
     /* now we can allocate a contiguous memory space for the off-len pairs */
-    off_len *seg_ptr = (off_len*)NCI_Malloc((size_t)(*nsegs) * sizeof(off_len));
+    off_len *seg_ptr = (off_len*)NCI_Malloc(sizeof(off_len) * (*nsegs));
     *segs = seg_ptr;
 
     /* now re-run the loop to fill in the off-len pairs */
@@ -1582,8 +1582,8 @@ type_create_off_len(MPI_Offset    nsegs,    /* no. off-len pairs */
     mpireturn = MPI_Type_create_hindexed_c(j+1, blocklens, disps, MPI_BYTE,
                                            filetype);
 #else
-    blocklens = (int*)      NCI_Malloc(true_nsegs * SIZEOF_INT);
-    disps     = (MPI_Aint*) NCI_Malloc(true_nsegs * SIZEOF_MPI_AINT);
+    blocklens = (int*)      NCI_Malloc(sizeof(int) * true_nsegs);
+    disps     = (MPI_Aint*) NCI_Malloc(sizeof(MPI_Aint) * true_nsegs);
 
     /* coalesce segs[].off and len to disps[] and blocklens[] */
     if (segs[0].len > NC_MAX_INT) {
@@ -1667,8 +1667,8 @@ type_create_off_len(MPI_Offset    nsegs,    /* no. off-len pairs */
                                            buf_type);
 #else
     if (true_nsegs < j + 1) {
-        blocklens = (int*)      NCI_Realloc(blocklens, (j+1) * SIZEOF_INT);
-        disps     = (MPI_Aint*) NCI_Realloc(disps,     (j+1) * SIZEOF_MPI_AINT);
+        blocklens = (int*)      NCI_Realloc(blocklens, sizeof(int) * (j+1));
+        disps     = (MPI_Aint*) NCI_Realloc(disps,     sizeof(MPI_Aint) * (j+1));
     }
 
     /* coalesce segs[].off and len to disps[] and blocklens[] */
@@ -1813,7 +1813,7 @@ req_aggregation(NC     *ncp,
         }
     }
 
-    group_index = (int*) NCI_Malloc((size_t)(ngroups+1) * 2 * SIZEOF_INT);
+    group_index = (int*) NCI_Malloc(sizeof(int) * (ngroups+1) * 2);
     group_type  = group_index + (ngroups+1);
 
     /* calculate the starting index of each group and determine group type */
@@ -1863,7 +1863,7 @@ req_aggregation(NC     *ncp,
      * Then use one collective I/O to commit.
      */
 
-    ftypes = (MPI_Datatype*) NCI_Malloc((size_t)ngroups*2*sizeof(MPI_Datatype));
+    ftypes = (MPI_Datatype*) NCI_Malloc(sizeof(MPI_Datatype) * ngroups * 2);
     btypes = ftypes + ngroups;
 
     /* temp buffers, used by multiple calls to construct_filetypes()  */
@@ -2311,8 +2311,8 @@ mgetput(NC     *ncp,
 #else
     int *blocklens;
     MPI_Aint *disps;
-    blocklens = (int*) NCI_Malloc((size_t)num_reqs * SIZEOF_INT);
-    disps = (MPI_Aint*) NCI_Malloc((size_t)num_reqs * SIZEOF_MPI_AINT);
+    blocklens = (int*) NCI_Malloc(sizeof(int) * num_reqs);
+    disps = (MPI_Aint*) NCI_Malloc(sizeof(MPI_Aint) * num_reqs);
 #endif
 
     lead_list = (rw_flag == NC_REQ_RD) ? ncp->get_lead_list
diff --git a/src/utils/ncmpidiff/cdfdiff.c b/src/utils/ncmpidiff/cdfdiff.c
index 206cbcfb0..be19bc0c7 100644
--- a/src/utils/ncmpidiff/cdfdiff.c
+++ b/src/utils/ncmpidiff/cdfdiff.c
@@ -1035,7 +1035,7 @@ int main(int argc, char **argv)
                                     break;
                             pos = ((long long)m + k * nChunks) / var[0]->xsz;
 
-                            diffStart = (long long*) malloc(var[0]->ndims * sizeof(long long));
+                            diffStart = (long long*) malloc(sizeof(long long) * var[0]->ndims);
                             for (_i=var[0]->ndims-1; _i>=0; _i--) {
                                 if (isRecVar[0] && _i == 0) {
                                     diffStart[_i] = r; /* r-th record */
@@ -1092,7 +1092,7 @@ int main(int argc, char **argv)
         } else {
             int _i;
             long long pos, *diffStart;
-            diffStart = (long long*) malloc(ndims[0] * sizeof(long long));
+            diffStart = (long long*) malloc(sizeof(long long) * ndims[0]);
             if (worst != -1) pos = worst;
             for (_i=ndims[0]-1; _i>=0; _i--) {
                 long long dimLen = var[0]->shape[_i];
diff --git a/src/utils/ncmpidiff/ncmpidiff.c b/src/utils/ncmpidiff/ncmpidiff.c
index 8fb5d4f83..c5b8c7eda 100644
--- a/src/utils/ncmpidiff/ncmpidiff.c
+++ b/src/utils/ncmpidiff/ncmpidiff.c
@@ -225,7 +225,7 @@
         } else {                                                             \
             int _i;                                                          \
             MPI_Offset *diffStart;                                           \
-            diffStart = (MPI_Offset*) malloc(ndims[0] * sizeof(MPI_Offset)); \
+            diffStart = (MPI_Offset*) malloc(sizeof(MPI_Offset) * ndims[0]); \
             if (worst != -1) pos = worst;                                    \
             v1 = b1[pos];                                                    \
             v2 = b2[pos];                                                    \
@@ -669,7 +669,7 @@ int main(int argc, char **argv)
 
             varid[0] = i;
             err = ncmpi_inq_varndims(ncid[0], i, &ndims[0]); HANDLE_ERROR
-            dimids[0] = (int*) calloc((size_t)ndims[0], SIZEOF_INT);
+            dimids[0] = (int*) calloc((size_t)ndims[0], sizeof(int));
             if (!dimids[0]) OOM_ERROR
             err = ncmpi_inq_var(ncid[0], i, name[0], &xtype[0], &ndims[0], dimids[0], &natts[0]);
             HANDLE_ERROR
@@ -686,7 +686,7 @@ int main(int argc, char **argv)
 
             /* inquire variable metadata for varid[1] */
             err = ncmpi_inq_varndims(ncid[1], varid[1], &ndims[1]); HANDLE_ERROR
-            dimids[1] = (int*) calloc((size_t)ndims[1], SIZEOF_INT);
+            dimids[1] = (int*) calloc((size_t)ndims[1], sizeof(int));
             if (!dimids[1]) OOM_ERROR
             err = ncmpi_inq_var(ncid[1], varid[1], name[1], &xtype[1], &ndims[1], dimids[1], &natts[1]);
             HANDLE_ERROR
@@ -901,12 +901,12 @@ int main(int argc, char **argv)
          */
 
         err = ncmpi_inq_varndims(ncid[0], varid1, &ndims[0]); HANDLE_ERROR
-        dimids[0] = (int*) calloc((size_t)ndims[0], SIZEOF_INT);
+        dimids[0] = (int*) calloc((size_t)ndims[0], sizeof(int));
         if (!dimids[0]) OOM_ERROR
         err = ncmpi_inq_var(ncid[0], varid1, name[0], &xtype[0], &ndims[0], dimids[0], &natts[0]);
         HANDLE_ERROR
         err = ncmpi_inq_varndims(ncid[1], varid2, &ndims[1]); HANDLE_ERROR
-        dimids[1] = (int*) calloc((size_t)ndims[1], SIZEOF_INT);
+        dimids[1] = (int*) calloc((size_t)ndims[1], sizeof(int));
         if (!dimids[1]) OOM_ERROR
         err = ncmpi_inq_var(ncid[1], varid2, name[1], &xtype[1], &ndims[1], dimids[1], &natts[1]);
         HANDLE_ERROR
@@ -941,7 +941,7 @@ int main(int argc, char **argv)
         else if (!check_header && !rank && verbose)
             printf("\tSAME: number of dimensions (%d)\n",ndims[0]);
 
-        shape = (MPI_Offset*) calloc((size_t)ndims[0] * 2, SIZEOF_MPI_OFFSET);
+        shape = (MPI_Offset*) calloc((size_t)ndims[0] * 2, sizeof(MPI_Offset));
         if (!shape) OOM_ERROR
         start = shape + ndims[0];
 
diff --git a/src/utils/ncmpidump/ncmpidump.c b/src/utils/ncmpidump/ncmpidump.c
index 8a97e780a..be3d72482 100644
--- a/src/utils/ncmpidump/ncmpidump.c
+++ b/src/utils/ncmpidump/ncmpidump.c
@@ -114,7 +114,7 @@ name_path(const char *path)
     else                /* skip delimeter */
         cp++;
 
-    new = (char *) malloc((unsigned) (strlen(cp)+1));
+    new = (char *) malloc(strlen(cp) + 1);
     if (new == 0) error("out of memory!");
 
     strcpy(new, cp);    /* copy last component of path */
@@ -344,7 +344,7 @@ pr_att(int         ncid,
             free(att.string);
             break;
         default:
-            att.vals = (double *) malloc(att.len * sizeof(double));
+            att.vals = (double *) malloc(sizeof(double) * att.len);
             if (!att.vals) {
                 error("Out of memory!");
                 NC_CHECK( ncmpi_close(ncid) );
@@ -460,7 +460,7 @@ do_ncdump(const char *path, struct fspec* specp)
         /* print dimension info */
         if (ndims > 0) Printf ("dimensions:\n");
 
-        dims = (struct ncdim*) malloc(ndims*sizeof(struct ncdim));
+        dims = (struct ncdim*) malloc(sizeof(struct ncdim) * ndims);
         for (dimid = 0; dimid < ndims; dimid++) {
             NC_CHECK(ncmpi_inq_dim(ncid, dimid, dims[dimid].name,
                                    &dims[dimid].size) );
@@ -532,7 +532,7 @@ do_ncdump(const char *path, struct fspec* specp)
                 if (var.ndims == 0 || var.dims[0] != xdimid ||
                     dims[xdimid].size != 0) {
                     /* Collect variable's dim sizes */
-                    vdims = (size_t*) malloc(var.ndims * sizeof(size_t));
+                    vdims = (size_t*) malloc(sizeof(size_t) * var.ndims);
                     for (id = 0; id < var.ndims; id++)
                          vdims[id] = dims[var.dims[id]].size;
 
@@ -623,7 +623,7 @@ make_lvars(char *optarg, struct fspec* fspecp)
         if (*cp == ',')
             nvars++;
 
-    fspecp->lvars = (char **) malloc(nvars * sizeof(char*));
+    fspecp->lvars = (char **) malloc(sizeof(char*) * nvars);
     if (!fspecp->lvars) error("out of memory");
 
     cpp = fspecp->lvars;
diff --git a/src/utils/ncmpidump/vardata.c b/src/utils/ncmpidump/vardata.c
index caa4cf001..836231153 100644
--- a/src/utils/ncmpidump/vardata.c
+++ b/src/utils/ncmpidump/vardata.c
@@ -574,9 +574,9 @@ vardata(
 	initeps = 1;
     }
 
-    cor = (MPI_Offset*) malloc(vrank * sizeof (MPI_Offset));
-    edg = (MPI_Offset*) malloc(vrank * sizeof (MPI_Offset));
-    add = (size_t*) malloc(vrank * sizeof (size_t));
+    cor = (MPI_Offset*) malloc(sizeof(MPI_Offset) * vrank);
+    edg = (MPI_Offset*) malloc(sizeof(MPI_Offset) * vrank);
+    add = (size_t*) malloc(sizeof(size_t) * vrank);
 
     nels = 1;
     for (id = 0; id < vrank; id++) {
diff --git a/src/utils/ncmpigen/genlib.c b/src/utils/ncmpigen/genlib.c
index 072f44852..1e558a92f 100644
--- a/src/utils/ncmpigen/genlib.c
+++ b/src/utils/ncmpigen/genlib.c
@@ -1265,7 +1265,7 @@ fstrstr(
 	free(istr0);
 	return ostr;
     }
-    ostr = cp = (char *) emalloc(12*ilen);
+    ostr = cp = (char *) emalloc(ilen*12);
     *ostr = '\0';
     if (isprint(*istr)) {	/* handle first character in input */
 	*cp++ = '\'';
@@ -1834,7 +1834,7 @@ grow_iarray(
      int **arpp)		/* address of start of int array */
 {
   if (nar == 0) {
-    *arpp = (int *) emalloc(1 * sizeof(int));
+    *arpp = (int *) emalloc(sizeof(int));
     return;
   }
   if (! pow2(nar))		/* return unless nar is a power of two */
@@ -1860,7 +1860,7 @@ grow_varray(
      struct vars **arpp)	/* address of start of var array */
 {
   if (nar == 0) {
-    *arpp = (struct vars *) emalloc(1 * sizeof(struct vars));
+    *arpp = (struct vars *) emalloc(sizeof(struct vars));
     return;
   }
   if (! pow2(nar))		/* return unless nar is a power of two */
@@ -1886,7 +1886,7 @@ grow_darray(
      struct dims **arpp)	/* address of start of var array */
 {
   if (nar == 0) {
-    *arpp = (struct dims *) emalloc(1 * sizeof(struct dims));
+    *arpp = (struct dims *) emalloc(sizeof(struct dims));
     return;
   }
   if (! pow2(nar))		/* return unless nar is a power of two */
@@ -1912,7 +1912,7 @@ grow_aarray(
      struct atts **arpp)	/* address of start of var array */
 {
   if (nar == 0) {
-    *arpp = (struct atts *) emalloc(1 * sizeof(struct atts));
+    *arpp = (struct atts *) emalloc(sizeof(struct atts));
     return;
   }
   if (! pow2(nar))		/* return unless nar is a power of two */
diff --git a/src/utils/ncmpigen/load.c b/src/utils/ncmpigen/load.c
index d8b9a241b..69fe54e3a 100644
--- a/src/utils/ncmpigen/load.c
+++ b/src/utils/ncmpigen/load.c
@@ -657,7 +657,7 @@ load_netcdf(void *rec_start)
 	break;
     }
 
-    start = (MPI_Offset*) malloc(vars[varnum].ndims * 2 * sizeof(MPI_Offset));
+    start = (MPI_Offset*) malloc(sizeof(MPI_Offset) * vars[varnum].ndims * 2);
     count = start + vars[varnum].ndims;
 
     if (vars[varnum].ndims > 0) {
diff --git a/src/utils/ncmpigen/ncmpigen.y b/src/utils/ncmpigen/ncmpigen.y
index 9efaf9175..4516414b0 100644
--- a/src/utils/ncmpigen/ncmpigen.y
+++ b/src/utils/ncmpigen/ncmpigen.y
@@ -471,7 +471,7 @@ datadecl:       avar
 			   exit(9);
 		       }
 		       rec_len = var_len;
-		       rec_start = malloc ((MPI_Offset)(rec_len*var_size));
+		       rec_start = malloc((size_t)(rec_len*var_size));
 		       if (rec_start == 0) {
 			   derror ("out of memory\n");
 			   exit(3);
@@ -1284,8 +1284,8 @@ YYSTYPE install(  /* install sname in symbol table */
 {
     YYSTYPE sp;
 
-    sp = (YYSTYPE) emalloc (sizeof (struct Symbol));
-    sp -> name = (char *) emalloc (strlen (sname) + 1);/* +1 for '\0' */
+    sp = (YYSTYPE) emalloc(sizeof(struct Symbol));
+    sp -> name = (char *) emalloc(strlen(sname) + 1);/* +1 for '\0' */
     (void) strcpy (sp -> name, sname);
     sp -> next = symlist;	/* put at front of list */
     sp -> is_dim = 0;
diff --git a/src/utils/ncmpigen/ncmpigentab.c b/src/utils/ncmpigen/ncmpigentab.c
index c2bd12e8e..117e7d494 100644
--- a/src/utils/ncmpigen/ncmpigentab.c
+++ b/src/utils/ncmpigen/ncmpigentab.c
@@ -546,8 +546,8 @@ YYSTYPE install(  /* install sname in symbol table */
 {
     YYSTYPE sp;
 
-    sp = (YYSTYPE) emalloc (sizeof (struct Symbol));
-    sp -> name = (char *) emalloc (strlen (sname) + 1);/* +1 for '\0' */
+    sp = (YYSTYPE) emalloc(sizeof(struct Symbol));
+    sp -> name = (char *) emalloc(strlen(sname) + 1);/* +1 for '\0' */
     (void) strcpy (sp -> name, sname);
     sp -> next = symlist;	/* put at front of list */
     sp -> is_dim = 0;
@@ -594,16 +594,16 @@ static int yygrowstack(void)
 
     i = yyssp - yyss;
     newss = (yyss != 0)
-          ? (short *)realloc(yyss, newsize * sizeof(*newss))
-          : (short *)malloc(newsize * sizeof(*newss));
+          ? (short *)realloc(yyss, sizeof(*newss) * newsize)
+          : (short *)malloc(sizeof(*newss) * newsize);
     if (newss == 0)
         return -1;
 
     yyss  = newss;
     yyssp = newss + i;
     newvs = (yyvs != 0)
-          ? (YYSTYPE *)realloc(yyvs, newsize * sizeof(*newvs))
-          : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
+          ? (YYSTYPE *)realloc(yyvs, sizeof(*newvs) * newsize)
+          : (YYSTYPE *)malloc(sizeof(*newvs) * newsize);
     if (newvs == 0)
         return -1;
 
@@ -1123,7 +1123,7 @@ case 75:
 			   exit(9);
 		       }
 		       rec_len = var_len;
-		       rec_start = malloc ((MPI_Offset)(rec_len*var_size));
+		       rec_start = malloc((size_t)(rec_len*var_size));
 		       if (rec_start == 0) {
 			   derror ("out of memory\n");
 			   exit(3);
diff --git a/src/utils/ncoffsets/ncoffsets.c b/src/utils/ncoffsets/ncoffsets.c
index 0f003d5f4..977f199dd 100644
--- a/src/utils/ncoffsets/ncoffsets.c
+++ b/src/utils/ncoffsets/ncoffsets.c
@@ -1114,7 +1114,7 @@ hdr_get_NC_dimarray(bufferinfo  *gbp,
     } else {
         if (type != NC_DIMENSION) DEBUG_RETURN_ERROR(NC_ENOTNC);
 
-        ncap->value = (NC_dim **) malloc(ndefined * sizeof(NC_dim*));
+        ncap->value = (NC_dim **) malloc(sizeof(NC_dim*) * ndefined);
         MALLOC_CHECK(ncap->value)
         ncap->nalloc = (int)ndefined;
 
@@ -1389,7 +1389,7 @@ hdr_get_NC_attrarray(bufferinfo   *gbp,
         if (type != NC_ATTRIBUTE)
             DEBUG_RETURN_ERROR(NC_ENOTNC);
 
-        ncap->value = (NC_attr **)malloc((size_t)ndefined * sizeof(NC_attr*));
+        ncap->value = (NC_attr **)malloc(sizeof(NC_attr*) * ndefined);
         MALLOC_CHECK(ncap->value)
         ncap->nalloc = (int)ndefined;
 
@@ -1617,7 +1617,7 @@ hdr_get_NC_vararray(bufferinfo  *gbp,
         if (type != NC_VARIABLE)
             DEBUG_RETURN_ERROR(NC_ENOTNC);
 
-        ncap->value = (NC_var **) malloc((size_t)ndefined * sizeof(NC_var*));
+        ncap->value = (NC_var **) malloc(sizeof(NC_var*) * ndefined);
         MALLOC_CHECK(ncap->value)
         ncap->nalloc = (int)ndefined;
 
@@ -1814,7 +1814,7 @@ make_lvars(char *optarg, struct fspec* fspecp)
         if (*cp == ',')
             nvars++;
 
-    fspecp->lvars = (char **) malloc(nvars * sizeof(char*));
+    fspecp->lvars = (char **) malloc(sizeof(char*) * nvars);
     MALLOC_CHECK(fspecp->lvars)
 
     cpp = fspecp->lvars;
@@ -1828,7 +1828,7 @@ make_lvars(char *optarg, struct fspec* fspecp)
         cpp++;
     }
     fspecp->nlvars = nvars;
-    fspecp->varp = (NC_var**) malloc(nvars * sizeof(NC_var*));
+    fspecp->varp = (NC_var**) malloc(sizeof(NC_var*) * nvars);
     MALLOC_CHECK(fspecp->varp)
 }
 
@@ -1981,7 +1981,7 @@ int main(int argc, char *argv[])
     /* First check if all selected variables can be found in input file. */
     if (fspecp->nlvars > 0) {
         /* print a selected list of variables */
-        fspecp->varids = (int*) malloc(fspecp->nlvars * sizeof(int));
+        fspecp->varids = (int*) malloc(sizeof(int) * fspecp->nlvars);
         MALLOC_CHECK(fspecp->varids)
         for (i=0; i<fspecp->nlvars; i++) {
             for (j=0; j<ncp->vars.ndefined; j++) {
@@ -2033,9 +2033,9 @@ int main(int argc, char *argv[])
     }
 
     if (fspecp->nlvars == 0) { /* print all variables */
-        fspecp->varp = (NC_var**) malloc(ncp->vars.ndefined * sizeof(NC_var*));
+        fspecp->varp = (NC_var**) malloc(sizeof(NC_var*) * ncp->vars.ndefined);
         MALLOC_CHECK(fspecp->varp)
-        fspecp->varids = (int*) malloc(ncp->vars.ndefined * sizeof(int));
+        fspecp->varids = (int*) malloc(sizeof(int) * ncp->vars.ndefined);
         MALLOC_CHECK(fspecp->varids)
         fspecp->nlvars = ncp->vars.ndefined;
         fspecp->lvars = NULL;
diff --git a/src/utils/ncvalidator/ncvalidator.c b/src/utils/ncvalidator/ncvalidator.c
index d7ef9a59a..da58bcf6c 100644
--- a/src/utils/ncvalidator/ncvalidator.c
+++ b/src/utils/ncvalidator/ncvalidator.c
@@ -2111,7 +2111,7 @@ val_NC_check_voff(NC *ncp)
     if (num_fix_vars == 0) goto check_rec_var;
 
     /* check non-record variables first */
-    var_off_len = (off_len*) malloc(num_fix_vars * sizeof(off_len));
+    var_off_len = (off_len*) malloc(sizeof(off_len) * num_fix_vars);
     for (i=0, j=0; i<ncp->vars.ndefined; i++) {
         NC_var *varp = ncp->vars.value[i];
         if (varp->begin < ncp->begin_var) {
@@ -2166,7 +2166,7 @@ val_NC_check_voff(NC *ncp)
     if (ncp->vars.num_rec_vars == 0) return status;
 
     /* check record variables */
-    var_off_len = (off_len*) malloc(ncp->vars.num_rec_vars * sizeof(off_len));
+    var_off_len = (off_len*) malloc(sizeof(off_len) * ncp->vars.num_rec_vars);
     for (i=0, j=0; i<ncp->vars.ndefined; i++) {
         NC_var *varp = ncp->vars.value[i];
         if (!IS_RECVAR(varp)) continue;
diff --git a/test/C/pres_temp_4D_rd.c b/test/C/pres_temp_4D_rd.c
index a5a4999f3..bcc9b71c0 100644
--- a/test/C/pres_temp_4D_rd.c
+++ b/test/C/pres_temp_4D_rd.c
@@ -177,10 +177,10 @@ int main(int argc, char **argv)
         start[1] = 0;
 
     /* allocate read buffers */
-    pres_in = (float **)malloc(count[1] * 2 * sizeof(float *));
+    pres_in = (float **)malloc(sizeof(float *) * count[1] * 2);
     temp_in = pres_in + count[1];
     if (count[1] > 0) {
-        pres_in[0] = (float *)malloc(count[1] * 2 * NLAT * NLON * sizeof(float));
+        pres_in[0] = (float *)malloc(sizeof(float) * count[1] * 2 * NLAT * NLON);
         temp_in[0] = pres_in[0] + count[1] * NLAT * NLON;
         for (i = 1; i < count[1]; i++) {
             pres_in[i] = pres_in[i - 1] + NLAT * NLON;
diff --git a/test/C/pres_temp_4D_wr.c b/test/C/pres_temp_4D_wr.c
index 127b65642..d7dbf1a47 100644
--- a/test/C/pres_temp_4D_wr.c
+++ b/test/C/pres_temp_4D_wr.c
@@ -231,10 +231,10 @@ int main(int argc, char **argv)
         start[1] = 0;
 
     /* allocate write buffers */
-    pres_out = (float **)malloc(count[1] * 2 * sizeof(float *));
+    pres_out = (float **)malloc(sizeof(float *) * count[1] * 2);
     temp_out = pres_out + count[1];
     if (count[1] > 0) {
-        pres_out[0] = (float *)malloc(count[1] * 2 * NLAT * NLON * sizeof(float));
+        pres_out[0] = (float *)malloc(sizeof(float) * count[1] * 2 * NLAT * NLON);
         temp_out[0] = pres_out[0] + count[1] * NLAT * NLON;
         for (i = 1; i < count[1]; i++) {
             pres_out[i] = pres_out[i - 1] + NLAT * NLON;
diff --git a/test/adios/header.c b/test/adios/header.c
index cdd12d70a..e9d0c1afe 100644
--- a/test/adios/header.c
+++ b/test/adios/header.c
@@ -27,7 +27,7 @@ int cmp_int(int *in, int n, char *lbl){
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     MPI_Comm_size(MPI_COMM_WORLD, &np);
 
-    all = malloc(np * sizeof(int));
+    all = malloc(sizeof(int) * np);
 
     MPI_Gather(&n, 1, MPI_INT, all, 1, MPI_INT, 0, MPI_COMM_WORLD);
     if (rank == 0) {
diff --git a/test/fandc/csnap.c b/test/fandc/csnap.c
index fe425b63c..fb39eed98 100644
--- a/test/fandc/csnap.c
+++ b/test/fandc/csnap.c
@@ -232,10 +232,10 @@ void write_file(char *filename, double *t) {
   count_2d[0] = locsiz_2d[0];
   count_2d[1] = locsiz_2d[1];
 
-  tt = (double*)malloc(locsiz_3d[0]*locsiz_3d[1]*locsiz_3d[2]*sizeof(double));
+  tt = (double*)malloc(sizeof(double) * locsiz_3d[0]*locsiz_3d[1]*locsiz_3d[2]);
 
   if (has_2d)
-    smf = (double*)malloc(locsiz_2d[0]*locsiz_2d[1]*sizeof(double));
+    smf = (double*)malloc(sizeof(double) * locsiz_2d[0]*locsiz_2d[1]);
   else
     smf = (double*)malloc(sizeof(double));
 
@@ -322,14 +322,14 @@ void read_file(char *filename, double *t) {
   count_2d[0] = locsiz_2d[0];
   count_2d[1] = locsiz_2d[1];
 
-  tt = (double*)malloc(locsiz_3d[0]*locsiz_3d[1]*locsiz_3d[2]*sizeof(double));
+  tt = (double*)malloc(sizeof(double) * locsiz_3d[0]*locsiz_3d[1]*locsiz_3d[2]);
 
   if (has_2d)
-    smf = (double*)malloc(locsiz_2d[0]*locsiz_2d[1]*sizeof(double));
+    smf = (double*)malloc(sizeof(double) * locsiz_2d[0]*locsiz_2d[1]);
   else
     smf = (double*)malloc(sizeof(double));
 
-  buf = (double*)malloc(locsiz_3d[0]*locsiz_3d[1]*locsiz_3d[2]*sizeof(double));
+  buf = (double*)malloc(sizeof(double) * locsiz_3d[0]*locsiz_3d[1]*locsiz_3d[2]);
 
   get_fields(tt, smf);
 
diff --git a/test/largefile/high_dim_var.c b/test/largefile/high_dim_var.c
index f9507dc94..a15d6e4c9 100644
--- a/test/largefile/high_dim_var.c
+++ b/test/largefile/high_dim_var.c
@@ -86,7 +86,7 @@ int main(int argc, char** argv) {
 
     nelms = (NRECS > DIMLEN) ? NRECS : DIMLEN;
     for (i=1; i<NDIMS; i++) nelms *= DIMLEN;
-    buffer = (short*) malloc(nelms * sizeof(short));
+    buffer = (short*) malloc(sizeof(short) * nelms);
     if (buffer == NULL) {
         printf("Error %s at line %d: fail to allocate buffer of size %zu\n",
                argv[0], __LINE__, nelms * sizeof(int));
diff --git a/test/largefile/large_dims_vars_attrs.c b/test/largefile/large_dims_vars_attrs.c
index 6029a8aa8..badcf64bd 100644
--- a/test/largefile/large_dims_vars_attrs.c
+++ b/test/largefile/large_dims_vars_attrs.c
@@ -57,8 +57,8 @@ int main(int argc, char** argv)
         free(cmd_str);
     }
 
-    dimids = (int*) malloc(LARGE_NUM * sizeof(int));
-    varid = (int*) malloc(LARGE_NUM * sizeof(int));
+    dimids = (int*) malloc(sizeof(int) * LARGE_NUM);
+    varid = (int*) malloc(sizeof(int) * LARGE_NUM);
 
     /* create a new file for writing ----------------------------------------*/
     cmode = NC_CLOBBER;
diff --git a/test/largefile/large_reqs.c b/test/largefile/large_reqs.c
index 1b87feafe..8a0711b72 100644
--- a/test/largefile/large_reqs.c
+++ b/test/largefile/large_reqs.c
@@ -80,7 +80,7 @@ int tst_one_var(char *filename, MPI_Comm comm)
 
     /* user buffer is contiguous */
     buf_len = (size_t)NY * NX;
-    buf = (int*) malloc(buf_len * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * buf_len);
     for (i=0; i<buf_len; i++) buf[i] = (i + rank) % 128;
 
     /* write the entire variable */
@@ -175,7 +175,7 @@ int tst_vars(char *filename, MPI_Comm comm)
     err = ncmpi_def_dim(ncid, "Y", LEN*psize[0], &dimid[1]); CHECK_ERR
     err = ncmpi_def_dim(ncid, "X", LEN*psize[1], &dimid[2]); CHECK_ERR
 
-    varid = (int*) malloc(NVARS * sizeof(int));
+    varid = (int*) malloc(sizeof(int) * NVARS);
 
     for (i=0; i<NVARS; i++) {
         /* define a 2D variables of integer type */
@@ -200,7 +200,7 @@ int tst_vars(char *filename, MPI_Comm comm)
     /* make user buffer noncontiguous */
     gap = 2;
     buf_len = (LEN * LEN + gap) * NVARS;
-    buf = (int*) malloc(buf_len * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * buf_len);
     for (i=0; i<buf_len; i++) buf[i] = (i + rank) % 128;
 
     /* create a subarray datatype for user buffer */
diff --git a/test/largefile/large_var.c b/test/largefile/large_var.c
index fdf1f5d6c..442c9eadb 100644
--- a/test/largefile/large_var.c
+++ b/test/largefile/large_var.c
@@ -124,7 +124,7 @@ int main(int argc, char** argv)
     count[1] = 2;
     count[2] = 10;
 
-    buf = (int*) malloc(40 * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * 40);
     for (i=0; i<40; i++) buf[i] = rank*100 + i;
 
     /* write: subarray of 1 x 2 x 10 at start 1 x 8 x (2G + rank * 10) */
@@ -282,7 +282,7 @@ int main(int argc, char** argv)
     count[1] = 2;
     count[2] = 10;
 
-    buf = (int*) malloc(40 * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * 40);
     for (i=0; i<40; i++) buf[i] = rank*100 + i;
 
     /* write: subarray of 1 x 2 x 10 at start 1 x 8 x (2G + rank * 10) */
diff --git a/test/nc4/pres_temp_4D.c b/test/nc4/pres_temp_4D.c
index 6991f8fd7..642ff526e 100644
--- a/test/nc4/pres_temp_4D.c
+++ b/test/nc4/pres_temp_4D.c
@@ -193,10 +193,10 @@ pres_temp_4D_wr(char *filename, int rank, int nprocs)
    if (count[1] == 0) start[1] = 0;
 
    /* allocate write buffers */
-   pres_out = (float**) malloc(count[1]*2 * sizeof(float*));
+   pres_out = (float**) malloc(sizeof(float*) * count[1]*2);
    temp_out = pres_out + count[1];
    if (count[1] > 0) {
-       pres_out[0] = (float*) malloc(count[1]*2 * NLAT*NLON * sizeof(float));
+       pres_out[0] = (float*) malloc(sizeof(float) * count[1]*2 * NLAT*NLON);
        temp_out[0] = pres_out[0] + count[1] * NLAT*NLON;
        for (i=1; i<count[1]; i++) {
            pres_out[i] = pres_out[i-1] + NLAT*NLON;
@@ -323,10 +323,10 @@ pres_temp_4D_rd(char *filename, int rank, int nprocs)
    if (count[1] == 0) start[1] = 0;
 
    /* allocate read buffers */
-   pres_in = (float**) malloc(count[1]*2 * sizeof(float*));
+   pres_in = (float**) malloc(sizeof(float*) * count[1]*2);
    temp_in = pres_in + count[1];
    if (count[1] > 0) {
-       pres_in[0] = (float*) malloc(count[1]*2 * NLAT*NLON * sizeof(float));
+       pres_in[0] = (float*) malloc(sizeof(float) * count[1]*2 * NLAT*NLON);
        temp_in[0] = pres_in[0] + count[1] * NLAT*NLON;
        for (i=1; i<count[1]; i++) {
            pres_in[i] = pres_in[i-1] + NLAT*NLON;
diff --git a/test/nc4/put_get_all_kinds.m4 b/test/nc4/put_get_all_kinds.m4
index d18903394..9a4483143 100644
--- a/test/nc4/put_get_all_kinds.m4
+++ b/test/nc4/put_get_all_kinds.m4
@@ -198,8 +198,8 @@ int main(int argc, char **argv)
     }
 
     /* allocate buffer and initialize with contiguous numbers */
-    buf = (double *) malloc(bufsize * sizeof(double));
-    rbuf = (double *) malloc(bufsize * sizeof(double));
+    buf = (double *) malloc(sizeof(double) * bufsize);
+    rbuf = (double *) malloc(sizeof(double) * bufsize);
     for (k=0; k<count[0]; k++)
     for (j=0; j<count[1]; j++)
     for (i=0; i<count[2]; i++)
diff --git a/test/nc4/rd_compressed.c b/test/nc4/rd_compressed.c
index 1eab83895..bd878de4b 100644
--- a/test/nc4/rd_compressed.c
+++ b/test/nc4/rd_compressed.c
@@ -45,7 +45,7 @@ static int create_nc4(char *filename)
     err = nc_enddef(ncid); CHECK_ERR
 
     /* initialize buffer contents */
-    buf = (int*) malloc(NZ*NY*NZ * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * NZ*NY*NZ);
     for (i=0; i<NZ*NY*NZ; i++) buf[i] = i;
 
     /* write the entire variable */
@@ -142,7 +142,7 @@ int main(int argc, char **argv) {
         bufLen *= dimLen;
     }
 
-    buf = (int*) malloc(bufLen * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * bufLen);
 
     /* read the entire variable */
     err = ncmpi_get_var_int_all(ncid, varid, buf); CHECK_ERR
diff --git a/test/nc4/tst_zero_req.c b/test/nc4/tst_zero_req.c
index 71451980f..7f94a676d 100644
--- a/test/nc4/tst_zero_req.c
+++ b/test/nc4/tst_zero_req.c
@@ -38,7 +38,7 @@ tst_fmt(char *filename, int cmode)
         return 1;
     }
 
-    buf = (int*)malloc(Y_LEN*X_LEN*sizeof(int));
+    buf = (int*)malloc(sizeof(int) * Y_LEN*X_LEN);
     for (i=0; i<Y_LEN*X_LEN; i++) buf[i] = rank*100+i;
 
     /* To test HDF5 1.10.2 bug, it must use a record variable, fixed-size
diff --git a/test/nc_test/t_nc.c b/test/nc_test/t_nc.c
index cbd543500..9bc1829dc 100644
--- a/test/nc_test/t_nc.c
+++ b/test/nc_test/t_nc.c
@@ -455,7 +455,7 @@ int t_nc(char *filename, int cmode)
 	{
 		int jj;
 		err = ncmpi_inq_varndims(id, ii, &vdesc->ndims); ERR
-                vdesc->dims = (int*) malloc(vdesc->ndims * sizeof(int));
+                vdesc->dims = (int*) malloc(sizeof(int) * vdesc->ndims);
 
 		err = ncmpi_inq_var(id, ii,
 			vdesc->mnem,
diff --git a/test/nc_test/tst_nofill.c b/test/nc_test/tst_nofill.c
index 9c4f8caf9..48e14a07c 100644
--- a/test/nc_test/tst_nofill.c
+++ b/test/nc_test/tst_nofill.c
@@ -401,7 +401,7 @@ main(int argc, char **argv)
 	   char varname2[NC_MAX_NAME];
 	   /* How many values in this variable to compare? */
 	   err = ncmpi_inq_varndims(ncid1, varid, &ndims); ERR
-	   dimids = malloc((ndims + 1) * sizeof(int));
+	   dimids = malloc(sizeof(int) * (ndims + 1));
 	   if (!dimids) printf("Error in file %s line %d\n",__FILE__,__LINE__);
 	   err = ncmpi_inq_vardimid (ncid1, varid, dimids); ERR
 	   nvals = 1;
@@ -417,9 +417,9 @@ main(int argc, char **argv)
 	   if (vtype != NC_CHAR) {  /* numeric data, just read in as doubles */
 	       double *data1, *data2;
 	       /* Allocate space to hold values in both files */
-	       data1 = malloc((nvals + 1) * sizeof(double));
+	       data1 = malloc(sizeof(double) * (nvals + 1));
 	       if (!data1) printf("Error in file %s line %d\n",__FILE__,__LINE__);
-	       data2 = malloc((nvals + 1) * sizeof(double));
+	       data2 = malloc(sizeof(double) * (nvals + 1));
 	       if (!data2) printf("Error in file %s line %d\n",__FILE__,__LINE__);
 	       /* Read in values */
 	       err = ncmpi_get_var_double_all(ncid1, varid, data1); ERR
@@ -439,9 +439,9 @@ main(int argc, char **argv)
 	   } else {		/* character data */
 	       char *data1, *data2;
 	       /* Allocate space to hold values in both files */
-	       data1 = malloc((nvals + 1) * sizeof(char));
+	       data1 = malloc(sizeof(char) * (nvals + 1));
 	       if (!data1) printf("Error in file %s line %d\n",__FILE__,__LINE__);
-	       data2 = malloc((nvals + 1) * sizeof(char));
+	       data2 = malloc(sizeof(char) * (nvals + 1));
 	       if (!data2) printf("Error in file %s line %d\n",__FILE__,__LINE__);
 	       /* Read in values */
 	       err = ncmpi_get_var_text_all(ncid1, varid, data1); ERR
diff --git a/test/nonblocking/bput_varn.m4 b/test/nonblocking/bput_varn.m4
index 67377a071..58cb0daaf 100644
--- a/test/nonblocking/bput_varn.m4
+++ b/test/nonblocking/bput_varn.m4
@@ -165,7 +165,7 @@ static
 int clear_file_contents_$1(int ncid, int *varid)
 {
     int i, err, nerrs=0, rank;
-    $1 *w_buffer = ($1*) malloc(NY*NX * sizeof($1));
+    $1 *w_buffer = ($1*) malloc(sizeof($1) * NY*NX);
     for (i=0; i<NY*NX; i++) w_buffer[i] = 99;
 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
@@ -205,7 +205,7 @@ int check_contents_for_fail_$1(int ncid, int *varid)
                               12, 12, 13, 10, 10, 10, 11, 11, 12, 12,
                               11, 11, 11, 13, 12, 12, 12, 10, 10, 10}};
 
-    $1 *r_buffer = ($1*) malloc(NY*NX * sizeof($1));
+    $1 *r_buffer = ($1*) malloc(sizeof($1) * NY*NX);
 
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
     if (nprocs > 4) MPI_Barrier(MPI_COMM_WORLD);
@@ -309,8 +309,8 @@ test_bput_varn_$1(char *filename, int cdf)
     err = ncmpi_enddef(ncid); CHECK_ERR
 
     /* allocate space for starts and counts */
-    starts[0] = (MPI_Offset**) malloc(4 * 6 * sizeof(MPI_Offset*));
-    counts[0] = (MPI_Offset**) malloc(4 * 6 * sizeof(MPI_Offset*));
+    starts[0] = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 4 * 6);
+    counts[0] = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 4 * 6);
     starts[0][0] = (MPI_Offset*) calloc(4 * 6 * NDIMS, sizeof(MPI_Offset));
     counts[0][0] = (MPI_Offset*) calloc(4 * 6 * NDIMS, sizeof(MPI_Offset));
     for (i=1; i<4; i++) {
@@ -363,7 +363,7 @@ test_bput_varn_$1(char *filename, int cdf)
         }
 
         /* allocate I/O buffer and initialize its contents */
-        buffer[i] = ($1*) malloc(req_lens[i] * sizeof($1));
+        buffer[i] = ($1*) malloc(sizeof($1) * req_lens[i]);
         for (j=0; j<req_lens[i]; j++) buffer[i][j] = ($1)rank+10;
         bufsize += req_lens[i];
     }
@@ -461,7 +461,7 @@ test_bput_varn_$1(char *filename, int cdf)
         MPI_Datatype buftype;
         MPI_Type_vector(req_lens[i], 1, 2, ITYPE2MPI($1), &buftype);
         MPI_Type_commit(&buftype);
-        buffer[i] = ($1*)malloc(req_lens[i]*2*sizeof($1));
+        buffer[i] = ($1*)malloc(sizeof($1) * req_lens[i]*2);
         for (j=0; j<req_lens[i]*2; j++) buffer[i][j] = ($1)rank+10;
 
         err = ncmpi_bput_varn(ncid, varid[i], my_nsegs[i], starts[i],
diff --git a/test/nonblocking/column_wise.m4 b/test/nonblocking/column_wise.m4
index 0f7abe395..fd148dbf7 100644
--- a/test/nonblocking/column_wise.m4
+++ b/test/nonblocking/column_wise.m4
@@ -112,7 +112,7 @@ int test_column_wise_$1(char *filename, int cdf)
 
     /* First, fill the entire array with zeros, using a blocking I/O.
        Every process writes a subarray of size NY * myNX */
-    buf    = ($1**) malloc(myNX * sizeof($1*));
+    buf    = ($1**) malloc(sizeof($1*) * myNX);
     buf[0] = ($1*)  calloc(NY * myNX, sizeof($1));
     start[0] = 0;   start[1] = myOff;
     count[0] = NY;  count[1] = myNX;
@@ -127,12 +127,12 @@ int test_column_wise_$1(char *filename, int cdf)
     /* initialize the buffer with rank ID. Also make the case interesting,
        by allocatsing buffersd separately */
     for (i=0; i<myNX; i++) {
-        buf[i] = ($1*) malloc(NY * sizeof($1));
+        buf[i] = ($1*) malloc(sizeof($1) * NY);
         for (j=0; j<NY; j++) buf[i][j] = ($1)rank+10;
     }
 
-    reqs = (int*) malloc(myNX * sizeof(int));
-    sts  = (int*) malloc(myNX * sizeof(int));
+    reqs = (int*) malloc(sizeof(int) * myNX);
+    sts  = (int*) malloc(sizeof(int) * myNX);
 
     /* each proc writes myNX single columns of the 2D array */
     start[0]  = 0;   start[1] = rank;
diff --git a/test/nonblocking/i_varn_indef.c b/test/nonblocking/i_varn_indef.c
index 2e7066eee..10c102dcd 100644
--- a/test/nonblocking/i_varn_indef.c
+++ b/test/nonblocking/i_varn_indef.c
@@ -85,7 +85,7 @@ static
 int clear_file_contents(int ncid, int *varid)
 {
     int i, err, nerrs=0, rank;
-    long long *w_buffer = (long long*) malloc(NY*NX * sizeof(long long));
+    long long *w_buffer = (long long*) malloc(sizeof(long long) * NY*NX);
     for (i=0; i<NY*NX; i++) w_buffer[i] = -1;
 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
@@ -120,7 +120,7 @@ int check_contents_for_fail(int ncid, int *varid, int lineno)
                                      12, 12, 13, 10, 10, 10, 11, 11, 12, 12,
                                      11, 11, 11, 13, 12, 12, 12, 10, 10, 10}};
 
-    long long *r_buffer = (long long*) malloc(NY*NX * sizeof(long long));
+    long long *r_buffer = (long long*) malloc(sizeof(long long) * NY*NX);
 
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
     if (nprocs > 4) MPI_Barrier(MPI_COMM_WORLD);
@@ -238,8 +238,8 @@ int main(int argc, char** argv)
 #endif
 
     /* allocate space for starts and counts */
-    starts[0] = (MPI_Offset**) malloc(4 * 6 * sizeof(MPI_Offset*));
-    counts[0] = (MPI_Offset**) malloc(4 * 6 * sizeof(MPI_Offset*));
+    starts[0] = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 4 * 6);
+    counts[0] = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 4 * 6);
     starts[0][0] = (MPI_Offset*) calloc(4 * 6 * NDIMS, sizeof(MPI_Offset));
     counts[0][0] = (MPI_Offset*) calloc(4 * 6 * NDIMS, sizeof(MPI_Offset));
     for (i=1; i<4; i++) {
@@ -289,7 +289,7 @@ int main(int argc, char** argv)
         }
 
         /* allocate I/O buffer and initialize its contents */
-        buffer[i] = (long long*) malloc(req_lens[i] * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i]);
         for (j=0; j<req_lens[i]; j++) buffer[i][j] = rank+10;
     }
     varname[0] = "var0";
@@ -381,7 +381,7 @@ int main(int argc, char** argv)
     /* try with buffer being a single contiguous space ----------------------*/
     for (i=0; i<nreqs; i++) bufsize += req_lens[i];
     cbuffer[0] = NULL;
-    if (bufsize>0) cbuffer[0] = (long long*) malloc(bufsize * sizeof(long long));
+    if (bufsize>0) cbuffer[0] = (long long*) malloc(sizeof(long long) * bufsize);
     for (i=1; i<nreqs; i++) cbuffer[i] = cbuffer[i-1] + req_lens[i-1];
     for (i=0; i<bufsize; i++) cbuffer[0][i] = rank+10;
 
@@ -541,9 +541,9 @@ int main(int argc, char** argv)
     for (i=0; i<nreqs; i++) {
         MPI_Type_vector(req_lens[i], 1, 2, MPI_LONG_LONG, &buftype[i]);
         MPI_Type_commit(&buftype[i]);
-        buffer[i] = (long long*) malloc(req_lens[i] * 2 * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i] * 2);
         for (j=0; j<req_lens[i]*2; j++) buffer[i][j] = rank+10;
-        rbuffer[i] = (long long*) malloc(req_lens[i] * 2 * sizeof(long long));
+        rbuffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i] * 2);
         for (j=0; j<req_lens[i]*2; j++) rbuffer[i][j] = -1;
     }
 
diff --git a/test/nonblocking/i_varn_int64.c b/test/nonblocking/i_varn_int64.c
index dd5c8678e..692e47529 100644
--- a/test/nonblocking/i_varn_int64.c
+++ b/test/nonblocking/i_varn_int64.c
@@ -121,7 +121,7 @@ int clear_file_contents(int ncid, int *varid)
 {
     int i, err, rank, nerrs=0;
     MPI_Offset start[2], count[2];
-    long long *w_buffer = (long long*) malloc(NY*NX * sizeof(long long));
+    long long *w_buffer = (long long*) malloc(sizeof(long long) * NY*NX);
 
     for (i=0; i<NY*NX; i++) w_buffer[i] = -1;
 
@@ -173,7 +173,7 @@ int check_contents_for_fail(int ncid, int *varid)
                                      12, 12, 13, 10, 10, 10, 11, 11, 12, 12,
                                      11, 11, 11, 13, 12, 12, 12, 10, 10, 10}};
 
-    long long *r_buffer = (long long*) malloc(NY*NX * sizeof(long long));
+    long long *r_buffer = (long long*) malloc(sizeof(long long) * NY*NX);
 
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
     if (nprocs > 4) MPI_Barrier(MPI_COMM_WORLD);
@@ -264,8 +264,8 @@ test_varn(int ncid, int rank, int *varid)
      */
 
     /* allocate space for starts and counts */
-    starts[0] = (MPI_Offset**) malloc(4 * 6 * sizeof(MPI_Offset*));
-    counts[0] = (MPI_Offset**) malloc(4 * 6 * sizeof(MPI_Offset*));
+    starts[0] = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 4 * 6);
+    counts[0] = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 4 * 6);
     starts[0][0] = (MPI_Offset*) calloc(4 * 6 * NDIMS, sizeof(MPI_Offset));
     counts[0][0] = (MPI_Offset*) calloc(4 * 6 * NDIMS, sizeof(MPI_Offset));
     for (i=1; i<4; i++) {
@@ -318,7 +318,7 @@ test_varn(int ncid, int rank, int *varid)
         }
 
         /* allocate I/O buffer and initialize its contents */
-        buffer[i] = (long long*) malloc(req_lens[i] * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i]);
         for (j=0; j<req_lens[i]; j++) buffer[i][j] = rank+10;
     }
 
@@ -351,7 +351,7 @@ test_varn(int ncid, int rank, int *varid)
     /* try with buffer being a single contiguous space */
     for (i=0; i<nreqs; i++) bufsize += req_lens[i];
     if (bufsize>0) {
-        cbuffer[0] = (long long*) malloc(bufsize * sizeof(long long));
+        cbuffer[0] = (long long*) malloc(sizeof(long long) * bufsize);
         for (i=1; i<nreqs; i++) cbuffer[i] = cbuffer[i-1] + req_lens[i-1];
         for (i=0; i<bufsize; i++) cbuffer[0][i] = rank+10;
     }
@@ -450,7 +450,7 @@ test_varn(int ncid, int rank, int *varid)
         MPI_Datatype buftype;
         MPI_Type_vector(req_lens[i], 1, 2, MPI_LONG_LONG, &buftype);
         MPI_Type_commit(&buftype);
-        buffer[i] = (long long*) malloc(req_lens[i] * 2 * sizeof(long long));
+        buffer[i] = (long long*) malloc(sizeof(long long) * req_lens[i] * 2);
         for (j=0; j<req_lens[i]*2; j++) buffer[i][j] = rank+10;
 
         err = ncmpi_iput_varn(ncid, varid[i], my_nsegs[i], starts[i],
diff --git a/test/nonblocking/interleaved.c b/test/nonblocking/interleaved.c
index e462c4a0e..c4e71d8c8 100644
--- a/test/nonblocking/interleaved.c
+++ b/test/nonblocking/interleaved.c
@@ -143,7 +143,7 @@ int main(int argc, char** argv)
     err = ncmpi_enddef(ncid); CHECK_ERR
 
     /* now we are in data mode */
-    buf = (int*) malloc(NY*NX * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * NY*NX);
 
     /* fill the entire variable var0 with -1s */
     for (i=0; i<NY*NX; i++) buf[i] = -1;
@@ -159,7 +159,7 @@ int main(int argc, char** argv)
     start[0] = 0; start[1] = 3;
     count[0] = 8; count[1] = 2;
     len = (size_t)(count[0] * count[1]);
-    buf0 = (int*) malloc(len * sizeof(int));
+    buf0 = (int*) malloc(sizeof(int) * len);
     for (i=0; i<len; i++) buf0[i] = 50+i;
     err = ncmpi_iput_vara_int(ncid, varid[0], start, count, buf0, &req[0]);
     CHECK_ERR
@@ -168,7 +168,7 @@ int main(int argc, char** argv)
     start[0] = 1; start[1] = 8;
     count[0] = 1; count[1] = 5;
     len = (size_t)(count[0] * count[1]);
-    buf1 = (int*) malloc(len * sizeof(int));
+    buf1 = (int*) malloc(sizeof(int) * len);
     for (i=0; i<len; i++) buf1[i] = 60+i;
     err = ncmpi_iput_vara_int(ncid, varid[0], start, count, buf1, &req[1]);
     CHECK_ERR
@@ -177,7 +177,7 @@ int main(int argc, char** argv)
     start[0] = 3; start[1] = 7;
     count[0] = 1; count[1] = 5;
     len = (size_t)(count[0] * count[1]);
-    buf2 = (int*) malloc(len * sizeof(int));
+    buf2 = (int*) malloc(sizeof(int) * len);
     for (i=0; i<len; i++) buf2[i] = 70+i;
     err = ncmpi_iput_vara_int(ncid, varid[0], start, count, buf2, &req[2]);
     CHECK_ERR
@@ -199,7 +199,7 @@ int main(int argc, char** argv)
     start[0] = 0; start[1] = 3;
     count[0] = 8; count[1] = 2;
     len = (size_t)(count[0] * count[1]);
-    buf0 = (int*) malloc(len * sizeof(int));
+    buf0 = (int*) malloc(sizeof(int) * len);
     for (i=0; i<count[0]*count[1]; i++) buf0[i] = 50+i;
     err = ncmpi_iput_vara_int(ncid, varid[1], start, count, buf0, &req[0]);
     CHECK_ERR
diff --git a/test/nonblocking/large_num_reqs.c b/test/nonblocking/large_num_reqs.c
index 4e76b6d11..8171b81b6 100644
--- a/test/nonblocking/large_num_reqs.c
+++ b/test/nonblocking/large_num_reqs.c
@@ -66,7 +66,7 @@ int main(int argc, char **argv) {
     err = ncmpi_def_var(ncid, "var", NC_INT, 2, dimid, &varid); CHECK_ERR
     err = ncmpi_enddef(ncid); CHECK_ERR
 
-    req = (int*) malloc(NUM_REQS * 2 * sizeof(int));
+    req = (int*) malloc(sizeof(int) * NUM_REQS * 2);
     status = req + NUM_REQS;
 
     buf = (int*) calloc(NUM_REQS * 6,  sizeof(int));
diff --git a/test/nonblocking/mcoll_perf.c b/test/nonblocking/mcoll_perf.c
index 72d47eeb1..5eae1e08d 100644
--- a/test/nonblocking/mcoll_perf.c
+++ b/test/nonblocking/mcoll_perf.c
@@ -182,8 +182,8 @@ int ncmpi_diff(char *filename1, char *filename2)
         CHECK_ERR
         err = ncmpi_inq_varndims(ncid2, i, &ndims2);
         CHECK_ERR
-        dimids1 = (int*) malloc(ndims1 * sizeof(int));
-        dimids2 = (int*) malloc(ndims2 * sizeof(int));
+        dimids1 = (int*) malloc(sizeof(int) * ndims1);
+        dimids2 = (int*) malloc(sizeof(int) * ndims2);
 
         err = ncmpi_inq_var(ncid1, i, name1, &type1, &ndims1, dimids1, &natts1);
         CHECK_ERR
@@ -262,7 +262,7 @@ int ncmpi_diff(char *filename1, char *filename2)
         CHECK_ERR
         shape = (MPI_Offset*) calloc(ndims1 * 2, sizeof(MPI_Offset));
         start = shape + ndims1;
-        dimids1 = (int*) malloc(ndims1 * sizeof(int));
+        dimids1 = (int*) malloc(sizeof(int) * ndims1);
 
         varsize = 1;
         err = ncmpi_inq_var(ncid1, i, name1, &type1, &ndims1, dimids1, &natts1);
@@ -354,42 +354,42 @@ int main(int argc, char **argv)
 
     nvars = 4;
 
-    buf = (int **)malloc(nvars*sizeof(int*));
+    buf = (int **)malloc(sizeof(int*)*nvars);
     if (buf == NULL){
         printf("buf malloc error\n");
         nerrs++; goto fn_exit;
     }
-    bufcounts = (MPI_Offset *)malloc(nvars*sizeof(MPI_Offset));
+    bufcounts = (MPI_Offset *)malloc(sizeof(MPI_Offset)*nvars);
     if (bufcounts == NULL){
         printf("bufcounts malloc error\n");
         nerrs++; goto fn_exit;
     }
-    starts = (MPI_Offset **)malloc(nvars*sizeof(MPI_Offset *));
+    starts = (MPI_Offset **)malloc(sizeof(MPI_Offset*)*nvars);
     if (starts== NULL){
         printf("starts malloc error\n");
         nerrs++; goto fn_exit;
     }
-    counts = (MPI_Offset **)malloc(nvars*sizeof(MPI_Offset *));
+    counts = (MPI_Offset **)malloc(sizeof(MPI_Offset*)*nvars);
     if (counts == NULL){
         printf("counts malloc error\n");
         nerrs++; goto fn_exit;
     }
-    datatype_list = (MPI_Datatype*)malloc(nvars*sizeof(MPI_Datatype));
+    datatype_list = (MPI_Datatype*)malloc(sizeof(MPI_Datatype)*nvars);
     if (datatype_list == NULL){
         printf("counts malloc error\n");
         nerrs++; goto fn_exit;
     }
 
-    reqs = (int *)malloc(nvars*sizeof(int));
-    sts = (int *)malloc(nvars*sizeof(int));
+    reqs = (int *)malloc(sizeof(int)*nvars);
+    sts = (int *)malloc(sizeof(int)*nvars);
 
     for (i=0; i<nvars; i++) {
-        starts[i] = (MPI_Offset *)malloc(ndims*sizeof(MPI_Offset));
+        starts[i] = (MPI_Offset *)malloc(sizeof(MPI_Offset)*ndims);
         if (starts[i] == NULL){
             printf("starts[%d] malloc error\n", i);
             nerrs++; goto fn_exit;
         }
-        counts[i] = (MPI_Offset *)malloc(ndims*sizeof(MPI_Offset));
+        counts[i] = (MPI_Offset *)malloc(sizeof(MPI_Offset)*ndims);
         if (counts[i] == NULL){
             printf("counts[%d] malloc error\n", i);
             nerrs++; goto fn_exit;
@@ -431,7 +431,7 @@ int main(int argc, char **argv)
         printf("rank %d: starts[0][3]=%lld %lld %lld counts[0][3]=%lld %lld %lld\n",
                rank,starts[0][0],starts[0][2],starts[0][2], counts[0][0],counts[0][1],counts[0][2]);
 
-    buf[0] = (int *) malloc(bufcount * nvars * sizeof(int));
+    buf[0] = (int *) malloc(sizeof(int) * bufcount * nvars);
     if (buf[0] == NULL) {
         printf("buf[i]malloc error\n");
         nerrs++; goto fn_exit;
@@ -442,12 +442,12 @@ int main(int argc, char **argv)
         for (j=0; j<bufcount; j++)
             buf[i][j]=rank+1;
     }
-    buf_var = (int *) malloc(bufcount*nprocs*sizeof(int));
+    buf_var = (int *) malloc(sizeof(int)*bufcount*nprocs);
     for (i=0; i<bufcount*nprocs; i++)
         buf_var[i] = rank + 1;
 
     nvars2 = (nvars > nprocs) ? nvars : nprocs;
-    varid = (int *)malloc(nvars2*sizeof(int));
+    varid = (int *)malloc(sizeof(int)*nvars2);
     if (varid == NULL){
         printf("varid malloc error\n");
         nerrs++; goto fn_exit;
diff --git a/test/subfile/test_subfile.c b/test/subfile/test_subfile.c
index dbbb9cf6b..0bb6cdd53 100644
--- a/test/subfile/test_subfile.c
+++ b/test/subfile/test_subfile.c
@@ -114,39 +114,39 @@ int main(int argc, char **argv)
 
     array_of_gsizes[0] = array_of_gsizes[1] = array_of_gsizes[2] = length;
 
-    buf = (int **)malloc(nvars*sizeof(int*));
+    buf = (int **)malloc(sizeof(int*) * nvars);
     if (buf == NULL){
         printf("buf malloc error\n");
         nerrs++; goto fn_exit;
     }
-    bufcount_list = (MPI_Offset *)malloc(nvars*sizeof(MPI_Offset));
+    bufcount_list = (MPI_Offset *)malloc(sizeof(MPI_Offset)*nvars);
     if (bufcount_list == NULL){
         printf("bufcount_list malloc error\n");
         nerrs++; goto fn_exit;
     }
-    starts_list = (MPI_Offset **)malloc(nvars*sizeof(MPI_Offset *));
+    starts_list = (MPI_Offset **)malloc(sizeof(MPI_Offset *)*nvars);
     if (starts_list== NULL){
         printf("starts_list malloc error\n");
         nerrs++; goto fn_exit;
     }
-    count_list = (MPI_Offset **)malloc(nvars*sizeof(MPI_Offset *));
+    count_list = (MPI_Offset **)malloc(sizeof(MPI_Offset *)*nvars);
     if (count_list == NULL){
         printf("count_list malloc error\n");
         nerrs++; goto fn_exit;
     }
-    datatype_list = (MPI_Datatype*)malloc(nvars*sizeof(MPI_Datatype));
+    datatype_list = (MPI_Datatype*)malloc(sizeof(MPI_Datatype)*nvars);
     if (datatype_list == NULL){
         printf("count_list malloc error\n");
         nerrs++; goto fn_exit;
     }
 
     for (i=0; i<nvars; i++) {
-        starts_list[i] = (MPI_Offset *)malloc(ndims*sizeof(MPI_Offset));
+        starts_list[i] = (MPI_Offset *)malloc(sizeof(MPI_Offset)*ndims);
         if (starts_list[i] == NULL){
             printf("starts_list[%d] malloc error\n", i);
             nerrs++; goto fn_exit;
         }
-        count_list[i] = (MPI_Offset *)malloc(ndims*sizeof(MPI_Offset));
+        count_list[i] = (MPI_Offset *)malloc(sizeof(MPI_Offset)*ndims);
         if (count_list[i] == NULL){
             printf("count_list[%d] malloc error\n", i);
             nerrs++; goto fn_exit;
@@ -186,7 +186,7 @@ int main(int argc, char **argv)
     }
 
     for (i=0; i<nvars; i++) {
-        buf[i] = (int *) malloc(bufcount * sizeof(int));
+        buf[i] = (int *) malloc(sizeof(int) * bufcount);
         if (buf[i] == NULL){
             printf("buf[i]malloc error\n");
             nerrs++; goto fn_exit;
@@ -225,7 +225,7 @@ int main(int argc, char **argv)
     }
 
     /* define variables */
-    varid = (int *)malloc(nvars*sizeof(int));
+    varid = (int *)malloc(sizeof(int)*nvars);
     for (i=0; i<nvars; i++) {
         sprintf(varname, "var0_%d", i);
         err = ncmpi_def_var(ncid, varname, NC_INT, ndims, dimids0, &varid[i]);
diff --git a/test/testcases/alignment_test.c b/test/testcases/alignment_test.c
index 0ce81ca9b..b5faaec9f 100644
--- a/test/testcases/alignment_test.c
+++ b/test/testcases/alignment_test.c
@@ -91,7 +91,7 @@ int main(int argc, char** argv) {
     err = ncmpi_enddef(ncid); CHECK_ERR
 
     /* write all variables */
-    buf = (int*) malloc(NX * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * NX);
     for (i=0; i<NVARS; i++) {
         for (j=0; j<NX; j++) buf[j] = rank*1000 + i*10 + j;
 #ifdef TEST_FIXED_VAR
diff --git a/test/testcases/flexible.c b/test/testcases/flexible.c
index 8655af319..cc7799dad 100644
--- a/test/testcases/flexible.c
+++ b/test/testcases/flexible.c
@@ -245,7 +245,7 @@ int main(int argc, char **argv) {
     }
 
     /* create a buftype with ghost cells on each side */
-    ncbuf = (int *) malloc((count[0]+4)*(count[1]+4)*sizeof(int));
+    ncbuf = (int *) malloc(sizeof(int) * (count[0]+4) * (count[1]+4));
     array_of_sizes[0] = (int)count[0]+4;
     array_of_sizes[1] = (int)count[1]+4;
     array_of_subsizes[0] = (int)count[0];
diff --git a/test/testcases/flexible2.c b/test/testcases/flexible2.c
index 47e3e2651..0e2e2ee77 100644
--- a/test/testcases/flexible2.c
+++ b/test/testcases/flexible2.c
@@ -144,7 +144,7 @@ int main(int argc, char** argv)
     MPI_Type_commit(&subarray);
 
     int buffer_len = (NZ+2*ghost_len) * (NY+2*ghost_len);
-    buf_zy = (int*) malloc(buffer_len * sizeof(int));
+    buf_zy = (int*) malloc(sizeof(int) * buffer_len);
     for (i=0; i<buffer_len; i++) buf_zy[i] = rank+10;
 
     start[0] = NZ * rank; start[1] = 0;
@@ -203,7 +203,7 @@ int main(int argc, char** argv)
     MPI_Type_commit(&subarray);
 
     buffer_len = (NY+2*ghost_len) * (NX+2*ghost_len);
-    buf_yx = (double*) malloc(buffer_len * sizeof(double));
+    buf_yx = (double*) malloc(sizeof(double) * buffer_len);
     for (i=0; i<buffer_len; i++) buf_yx[i] = rank+10;
 
     start[0] = 0;  start[1] = NX * rank;
diff --git a/test/testcases/iput_all_kinds.m4 b/test/testcases/iput_all_kinds.m4
index 63a21aaaa..87b95e38e 100644
--- a/test/testcases/iput_all_kinds.m4
+++ b/test/testcases/iput_all_kinds.m4
@@ -199,7 +199,7 @@ int main(int argc, char **argv)
     }
 
     /* allocate buffer and initialize with contiguous numbers */
-    buf = (double *) malloc(bufsize * sizeof(double));
+    buf = (double *) malloc(sizeof(double) * bufsize);
     for (k=0; k<count[0]; k++)
     for (j=0; j<count[1]; j++)
     for (i=0; i<count[2]; i++)
diff --git a/test/testcases/ivarn.c b/test/testcases/ivarn.c
index a12898482..4f8d8dd45 100644
--- a/test/testcases/ivarn.c
+++ b/test/testcases/ivarn.c
@@ -229,8 +229,8 @@ int main(int argc, char** argv)
     ncmpi_sync(ncid);
 #endif
 
-    starts    = (MPI_Offset**) malloc(2 *    sizeof(MPI_Offset*));
-    counts    = (MPI_Offset**) malloc(2 *    sizeof(MPI_Offset*));
+    starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 2);
+    counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * 2);
     starts[0] = (MPI_Offset*)  calloc(2 * 2, sizeof(MPI_Offset));
     counts[0] = (MPI_Offset*)  calloc(2 * 2, sizeof(MPI_Offset));
     for (i=1; i<2; i++) {
diff --git a/test/testcases/ncmpi_vars_null_stride.c b/test/testcases/ncmpi_vars_null_stride.c
index 5dcc9a132..3808b9c84 100644
--- a/test/testcases/ncmpi_vars_null_stride.c
+++ b/test/testcases/ncmpi_vars_null_stride.c
@@ -58,7 +58,7 @@ tst_fmt(char *filename, int cmode)
     start[1] = rank*NX;
     count[0] = NY;
     count[1] = NX;
-    buf = (int*) malloc((size_t)NY * NX * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * NY * NX);
     for (i=0; i<NY*NX; i++) buf[i] = rank+10;
 
     err = ncmpi_put_vara_int_all(ncid, varid[0], start, count, buf); CHECK_ERR
@@ -114,7 +114,7 @@ tst_fmt(char *filename, int cmode)
         err = ncmpi_buffer_detach(ncid); CHECK_ERR
     }
 
-    buf = (int*) malloc((size_t)NY * NX * nprocs * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * NY * NX * nprocs);
     memset(buf, 0, (size_t)NY * NX * nprocs * sizeof(int));
     err = ncmpi_get_var_int_all(ncid, varid[0], buf); CHECK_ERR
 
diff --git a/test/testcases/profile.c b/test/testcases/profile.c
index 169c4d26c..45c76d7fb 100644
--- a/test/testcases/profile.c
+++ b/test/testcases/profile.c
@@ -121,8 +121,8 @@ static int test_vard(int ncid, int *varid)
     MPI_Type_commit(&fix_filetype);
 
     /* create a file type for the record variable */
-    int *array_of_blocklengths=(int*) malloc(count[0]*sizeof(int));
-    MPI_Aint *array_of_displacements=(MPI_Aint*) malloc(count[0]*sizeof(MPI_Aint));
+    int *array_of_blocklengths=(int*) malloc(sizeof(int) * count[0]);
+    MPI_Aint *array_of_displacements=(MPI_Aint*) malloc(sizeof(MPI_Aint) * count[0]);
     MPI_Offset recsize;
     err = ncmpi_inq_recsize(ncid, &recsize);
     for (i=0; i<count[0]; i++) {
@@ -168,8 +168,8 @@ static int test_varn(int ncid)
     else if (rank == 2) num_reqs = 5;
     else if (rank == 3) num_reqs = 4;
 
-    starts    = (MPI_Offset**) malloc(num_reqs *    sizeof(MPI_Offset*));
-    counts    = (MPI_Offset**) malloc(num_reqs *    sizeof(MPI_Offset*));
+    starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+    counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
     starts[0] = (MPI_Offset*)  calloc(num_reqs * 2, sizeof(MPI_Offset));
     counts[0] = (MPI_Offset*)  calloc(num_reqs * 2, sizeof(MPI_Offset));
     for (i=1; i<num_reqs; i++) {
@@ -227,7 +227,7 @@ static int test_varn(int ncid)
                   -  -  -  -  -  -  -  3  3  3
          */
     }
-    buffer = (int*) malloc(4*10 * sizeof(int));
+    buffer = (int*) malloc(sizeof(int) * 4*10);
 
     TRC(ncmpi_redef)(ncid); CHECK_ERR
     err = ncmpi_def_dim(ncid, "M",  4, &dimids[0]); CHECK_ERR
@@ -267,8 +267,8 @@ static int test_ivarn(int ncid)
     num_reqs[3] = 4;
 
     for (i=0; i<4; i++) {
-        starts[i]    = (MPI_Offset**) malloc(num_reqs[i] *    sizeof(MPI_Offset*));
-        counts[i]    = (MPI_Offset**) malloc(num_reqs[i] *    sizeof(MPI_Offset*));
+        starts[i]    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs[i]);
+        counts[i]    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs[i]);
         starts[i][0] = (MPI_Offset*)  calloc(num_reqs[i] * 2, sizeof(MPI_Offset));
         counts[i][0] = (MPI_Offset*)  calloc(num_reqs[i] * 2, sizeof(MPI_Offset));
         for (j=1; j<num_reqs[i]; j++) {
@@ -303,7 +303,7 @@ static int test_ivarn(int ncid)
     starts[3][3][y] = 3; starts[3][3][x] = 7; counts[3][3][y] = 1; counts[3][3][x] = 3;
 
     for (i=0; i<4; i++) {
-        buffer[i] = (int*) malloc(4*10 * sizeof(int));
+        buffer[i] = (int*) malloc(sizeof(int) * 4*10);
         for (j=0; j<4*10; j++) buffer[i][j] = rank+100;
     }
 
diff --git a/test/testcases/put_all_kinds.m4 b/test/testcases/put_all_kinds.m4
index 407d19f3d..fbf6d811d 100644
--- a/test/testcases/put_all_kinds.m4
+++ b/test/testcases/put_all_kinds.m4
@@ -204,7 +204,7 @@ int main(int argc, char **argv)
     }
 
     /* allocate buffer and initialize with contiguous numbers */
-    buf = (double *) malloc(bufsize * sizeof(double));
+    buf = (double *) malloc(sizeof(double) * bufsize);
     for (k=0; k<count[0]; k++)
     for (j=0; j<count[1]; j++)
     for (i=0; i<count[2]; i++)
diff --git a/test/testcases/redef1.c b/test/testcases/redef1.c
index b1240f0c5..29f15c05e 100644
--- a/test/testcases/redef1.c
+++ b/test/testcases/redef1.c
@@ -69,7 +69,7 @@ tst_fmt(char *filename, int cmode)
     count[0] = len0;
     count[1] = len1;
 
-    data = (int*) malloc(len0*len1 * sizeof(int));
+    data = (int*) malloc(sizeof(int) * len0*len1);
     k=0;
     for (i=0; i<len0; i++)
         for (j=0; j<len1; j++)
@@ -81,7 +81,7 @@ tst_fmt(char *filename, int cmode)
 
     count[0] = len0;
     count[1] = len5;
-    data = (int*) malloc(len0*len5 * sizeof(int));
+    data = (int*) malloc(sizeof(int) * len0*len5);
     k=0;
     for (i=0; i<len0; i++)
         for (j=0; j<len5; j++)
@@ -93,7 +93,7 @@ tst_fmt(char *filename, int cmode)
 
     count[0] = len0;
     count[1] = len9;
-    data = (int*) malloc(len0*len9 * sizeof(int));
+    data = (int*) malloc(sizeof(int) * len0*len9);
     k=0;
     for (i=0; i<len0; i++)
         for (j=0; j<len9; j++)
@@ -124,7 +124,7 @@ tst_fmt(char *filename, int cmode)
     count[0] = len0;
     count[1] = len2;
     k=0;
-    dbl_data = (double*) malloc(len0*len2 * sizeof(double));
+    dbl_data = (double*) malloc(sizeof(double) * len0*len2);
     for (i=0; i<len0; i++)
         for (j=0; j<len2; j++) {
             dbl_data[i*len2+j] = (k*k);
diff --git a/test/testcases/test_get_varn.c b/test/testcases/test_get_varn.c
index 3818c2836..321c7ca7c 100644
--- a/test/testcases/test_get_varn.c
+++ b/test/testcases/test_get_varn.c
@@ -98,8 +98,8 @@ int main(int argc, char** argv)
     /* num_reqs = 1; => works fine*/
     num_reqs = 2;
 
-    starts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
-    counts    = (MPI_Offset**) malloc(num_reqs*       sizeof(MPI_Offset*));
+    starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+    counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
     starts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
     counts[0] = (MPI_Offset*)  calloc(num_reqs*NDIMS, sizeof(MPI_Offset));
     for (i = 1; i < num_reqs; i++) {
diff --git a/test/testcases/test_vard.c b/test/testcases/test_vard.c
index 9a11288cf..405a5efcc 100644
--- a/test/testcases/test_vard.c
+++ b/test/testcases/test_vard.c
@@ -91,7 +91,7 @@ int get_var_and_verify(int ncid,
     int i, j, rank, err, *ncbuf, nerrs=0;
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
-    ncbuf = (int *) malloc((count[0]+4)*(count[1]+4)*sizeof(int));
+    ncbuf = (int *) malloc(sizeof(int) * (count[0]+4) * (count[1]+4));
 
     /* clear the contents of the read buffer */
     for (j=0; j<count[0]; j++) for (i=0; i<count[1]; i++) buf[j][i] = -1;
@@ -184,8 +184,8 @@ int main(int argc, char **argv) {
 
     /* construct various MPI derived data types */
 
-    buf = (int**)malloc(NY * sizeof(int*));
-    buf[0] = (int*)malloc(NY * NX * sizeof(int));
+    buf = (int**)malloc(sizeof(int*) * NY);
+    buf[0] = (int*)malloc(sizeof(int) * NY * NX);
     for (i=1; i<NY; i++) buf[i] = buf[i-1] + NX;
 
     /* construct an MPI derived data type for swapping 1st row with 2nd row */
@@ -247,8 +247,8 @@ int main(int argc, char **argv) {
     err = ncmpi_fill_var_rec(ncid, varid2, 1); CHECK_ERR
 
     /* create a file type for the record variable */
-    int *array_of_blocklengths=(int*) malloc(count[0]*sizeof(int));
-    MPI_Aint *array_of_displacements=(MPI_Aint*) malloc(count[0]*sizeof(MPI_Aint));
+    int *array_of_blocklengths=(int*) malloc(sizeof(int) * count[0]);
+    MPI_Aint *array_of_displacements=(MPI_Aint*) malloc(sizeof(MPI_Aint) * count[0]);
     MPI_Offset recsize;
     err = ncmpi_inq_recsize(ncid, &recsize);
     for (i=0; i<count[0]; i++) {
@@ -339,8 +339,8 @@ int main(int argc, char **argv) {
     nerrs += get_var_and_verify(ncid, varid1, start, count, buf, buftype, ghost_buftype, fix_filetype);
 
     /* test type conversion from float to int */
-    flt_buf = (float**)malloc(NY * sizeof(float*));
-    flt_buf[0] = (float*)malloc(NY * NX * sizeof(float));
+    flt_buf = (float**)malloc(sizeof(float*) * NY);
+    flt_buf[0] = (float*)malloc(sizeof(float) * NY * NX);
     for (i=1; i<NY; i++) flt_buf[i] = flt_buf[i-1] + NX;
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         flt_buf[j][i] = rank*100.0 + j*10.0 + i;
@@ -392,8 +392,8 @@ int main(int argc, char **argv) {
     }
 
     /* test type conversion from double to int */
-    dbl_buf = (double**)malloc(NY * sizeof(double*));
-    dbl_buf[0] = (double*)malloc(NY * NX * sizeof(double));
+    dbl_buf = (double**)malloc(sizeof(double*) * NY);
+    dbl_buf[0] = (double*)malloc(sizeof(double) * NY * NX);
     for (i=1; i<NY; i++) dbl_buf[i] = dbl_buf[i-1] + NX;
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         dbl_buf[j][i] = rank*100.0 + j*10.0 + i;
diff --git a/test/testcases/test_vard_multiple.c b/test/testcases/test_vard_multiple.c
index 52d13d184..fc8c024a2 100644
--- a/test/testcases/test_vard_multiple.c
+++ b/test/testcases/test_vard_multiple.c
@@ -106,11 +106,11 @@ int main(int argc, char **argv) {
         free(cmd_str);
     }
 
-    buf[0] = (int*)malloc(NY * NX * sizeof(int));
+    buf[0] = (int*)malloc(sizeof(int) * NY * NX);
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         buf[0][j*NX+i] = rank*100 + j*10 + i;
 
-    buf[1] = (int*)malloc(NY * NX * sizeof(int));
+    buf[1] = (int*)malloc(sizeof(int) * NY * NX);
     for (j=0; j<NY; j++) for (i=0; i<NX; i++)
         buf[1][j*NX+i] = 1000 + rank*100 + j*10 + i;
 
diff --git a/test/testcases/tst_def_var_fill.c b/test/testcases/tst_def_var_fill.c
index 00b07c720..5fffe5b60 100644
--- a/test/testcases/tst_def_var_fill.c
+++ b/test/testcases/tst_def_var_fill.c
@@ -41,7 +41,7 @@ tst_fmt(char *filename, int cmode)
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
 
     /* allocate I/O buffer */
-    buf = (int*) malloc(NY*NX * sizeof(int));
+    buf = (int*) malloc(sizeof(int) * NY*NX);
 
     /* create a new file for writing ------------------------------------*/
     cmode |= NC_CLOBBER;
diff --git a/test/testcases/tst_grow_header.c b/test/testcases/tst_grow_header.c
index e31ffc0b1..a4a08abce 100644
--- a/test/testcases/tst_grow_header.c
+++ b/test/testcases/tst_grow_header.c
@@ -53,7 +53,7 @@ check_vars(MPI_Comm    comm,
            MPI_Offset *start,
            MPI_Offset *count)
 {
-    int id, j, r, nerrs=0, err, rank, *buf, rec_dim, dimids[3], nvars;
+    int id, j, r, nerrs=0, err, rank, *buf=NULL, rec_dim, dimids[3], nvars;
     MPI_Offset nrecs;
 
     MPI_Comm_rank(comm, &rank);
@@ -111,7 +111,7 @@ check_vars(MPI_Comm    comm,
     }
 
 err_out:
-    free(buf);
+    if (buf != NULL) free(buf);
     return err;
 }
 
@@ -186,7 +186,7 @@ check_vars(MPI_Comm    comm,
 }
 #define WRITE_REC_VAR(id) { \
     for (i=0; i<count[1] * count[2]; i++) \
-        buf[i] = rank + i + id * 10 + start[0]; \
+        buf[i] = rank + i + id * 10 + (int)start[0]; \
     err = ncmpi_put_vara_int_all(ncid, varid[id], start, count, buf); \
     CHECK_ERR \
 }
@@ -196,7 +196,7 @@ tst_fmt(char *filename,
         int   cmode)
 {
     int i, rank, nprocs, ncid, err, nerrs=0;
-    int *buf, dimid[3], varid[16];
+    int *buf=NULL, dimid[3], varid[16];
     MPI_Info info=MPI_INFO_NULL;
     MPI_Offset start[3], count[3], increment;
 
@@ -379,9 +379,10 @@ tst_fmt(char *filename,
     exp_extent = 1024 * 5;
     CHECK_HEADER_SIZE
 
-err_out:
     err = ncmpi_close(ncid); CHECK_ERR
-    free(buf);
+
+err_out:
+    if (buf != NULL) free(buf);
     MPI_Info_free(&info);
 
     return nerrs;
diff --git a/test/testcases/tst_max_var_dims.c b/test/testcases/tst_max_var_dims.c
index a675dc34c..be3106dd3 100644
--- a/test/testcases/tst_max_var_dims.c
+++ b/test/testcases/tst_max_var_dims.c
@@ -58,7 +58,7 @@ int main(int argc, char** argv) {
     err = ncmpi_create(MPI_COMM_WORLD, filename, NC_CLOBBER, MPI_INFO_NULL, &ncid); CHECK_ERR
 
     /* define dimensions */
-    dimid = (int*) malloc((NC_MAX_VAR_DIMS+2) * sizeof(int));
+    dimid = (int*) malloc(sizeof(int) * (NC_MAX_VAR_DIMS+2));
     err = ncmpi_def_dim(ncid, "dim0", NC_UNLIMITED, &dimid[0]); CHECK_ERR
     err = ncmpi_def_dim(ncid, "dim1", 1, &dimid[1]); CHECK_ERR
 
diff --git a/test/testcases/tst_pthread.c b/test/testcases/tst_pthread.c
index fab60252b..fa799ad96 100644
--- a/test/testcases/tst_pthread.c
+++ b/test/testcases/tst_pthread.c
@@ -156,8 +156,8 @@ void* thread_func(void *arg)
     sprintf(filename, "%s.%d", ((thread_arg*)arg)->fname, id);
 
     /* allocate I/O buffers and initialize their contents */
-    ibuf = (int*)    malloc(NY * NX * sizeof(int));
-    dbuf = (double*) malloc(NY * NX * sizeof(double));
+    ibuf = (int*)    malloc(sizeof(int) * NY * NX);
+    dbuf = (double*) malloc(sizeof(double) * NY * NX);
     for (i=0; i<NY*NX; i++) {
         ibuf[i] = id;
         dbuf[i] = 1.0 * id;
diff --git a/test/testcases/tst_redefine.c b/test/testcases/tst_redefine.c
index 8a362adc4..d607dbef5 100644
--- a/test/testcases/tst_redefine.c
+++ b/test/testcases/tst_redefine.c
@@ -55,7 +55,7 @@ static int verbose;
 static int
 check_vars(MPI_Comm comm, int ncid, int *varid)
 {
-    int i, nerrs=0, err, rank, *buf, nvars;
+    int i, nerrs=0, err, rank, *buf=NULL, nvars;
     MPI_Offset start[2], count[2];
 
     MPI_Comm_rank(comm, &rank);
@@ -102,7 +102,7 @@ check_vars(MPI_Comm comm, int ncid, int *varid)
         CHECK_VAL(ncid, varid[3], i, buf[i], rank+i+100)
 
 err_out:
-    free(buf);
+    if (buf != NULL) free(buf);
     return nerrs;
 }
 
diff --git a/test/testcases/varn_contig.c b/test/testcases/varn_contig.c
index 8f0c9a7fe..f9b4bc2b1 100644
--- a/test/testcases/varn_contig.c
+++ b/test/testcases/varn_contig.c
@@ -133,8 +133,8 @@ int main(int argc, char** argv)
     else if (rank == 3) num_reqs = 5;
 
     if (num_reqs > 0) {
-        starts    = (MPI_Offset**) malloc(num_reqs *        sizeof(MPI_Offset*));
-        counts    = (MPI_Offset**) malloc(num_reqs *        sizeof(MPI_Offset*));
+        starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+        counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
         starts[0] = (MPI_Offset*)  calloc(num_reqs * NDIMS, sizeof(MPI_Offset));
         counts[0] = (MPI_Offset*)  calloc(num_reqs * NDIMS, sizeof(MPI_Offset));
         for (i=1; i<num_reqs; i++) {
@@ -197,8 +197,8 @@ int main(int argc, char** argv)
     w_len = NX; /* total write length for this process */
 
     /* allocate I/O buffer and initialize its contents */
-    r_buffer = (int*) malloc(NY*NX * sizeof(int));
-    buffer   = (int*) malloc(w_len * sizeof(int));
+    r_buffer = (int*) malloc(sizeof(int) * NY*NX);
+    buffer   = (int*) malloc(sizeof(int) * w_len);
     for (i=0; i<w_len; i++) buffer[i] = rank*100 + 100;
 
     /* check error code: NC_ENULLSTART */
diff --git a/test/testcases/varn_int.c b/test/testcases/varn_int.c
index 5cd1fadd2..9fbaab875 100644
--- a/test/testcases/varn_int.c
+++ b/test/testcases/varn_int.c
@@ -156,8 +156,8 @@ int main(int argc, char** argv)
     else if (rank == 3) num_reqs = 4;
 
     if (num_reqs > 0) {
-        starts    = (MPI_Offset**) malloc(num_reqs *        sizeof(MPI_Offset*));
-        counts    = (MPI_Offset**) malloc(num_reqs *        sizeof(MPI_Offset*));
+        starts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
+        counts    = (MPI_Offset**) malloc(sizeof(MPI_Offset*) * num_reqs);
         starts[0] = (MPI_Offset*)  calloc(num_reqs * NDIMS, sizeof(MPI_Offset));
         counts[0] = (MPI_Offset*)  calloc(num_reqs * NDIMS, sizeof(MPI_Offset));
         for (i=1; i<num_reqs; i++) {
@@ -226,8 +226,8 @@ int main(int argc, char** argv)
     }
 
     /* allocate I/O buffer and initialize its contents */
-    r_buffer = (int*) malloc(NY*NX * sizeof(int));
-    buffer   = (int*) malloc(w_len * sizeof(int));
+    r_buffer = (int*) malloc(sizeof(int) * NY*NX);
+    buffer   = (int*) malloc(sizeof(int) * w_len);
     for (i=0; i<w_len; i++) buffer[i] = rank+10;
 
     /* check error code: NC_ENULLSTART */
@@ -302,7 +302,7 @@ int main(int argc, char** argv)
     MPI_Type_vector((int)w_len, 1, 2, MPI_INT, &buftype);
     MPI_Type_commit(&buftype);
     free(buffer);
-    buffer = (int*) malloc(w_len * 2 * sizeof(int));
+    buffer = (int*) malloc(sizeof(int) * w_len * 2);
     for (i=0; i<2*w_len; i++) buffer[i] = -1;
     err = ncmpi_get_varn_all(ncid, varid[0], num_reqs, starts, counts, buffer, 1, buftype);
     CHECK_ERR