Fix a bunch of compiler warnings in "make check"

test/asm/atomic_cmpset.c

@@ -101,71 +101,95 @@ int main(int argc, char *argv[])
 
     /* -- cmpset 32-bit tests -- */
 
-    vol32 = 42, old32 = 42, new32 = 50;
+    vol32 = 42;
+    old32 = 42;
+    new32 = 50;
     assert(opal_atomic_compare_exchange_strong_32(&vol32, &old32, new32) == true);
     opal_atomic_rmb();
     assert(vol32 == new32);
     assert(old32 == 42);
 
-    vol32 = 42, old32 = 420, new32 = 50;
+    vol32 = 42;
+    old32 = 420;
+    new32 = 50;
     assert(opal_atomic_compare_exchange_strong_32(&vol32, &old32, new32) == false);
     opal_atomic_rmb();
     assert(vol32 == 42);
     assert(old32 == 42);
 
-    vol32 = 42, old32 = 42, new32 = 50;
+    vol32 = 42;
+    old32 = 42;
+    new32 = 50;
     assert(opal_atomic_compare_exchange_strong_32(&vol32, &old32, new32) == true);
     assert(vol32 == new32);
     assert(old32 == 42);
 
-    vol32 = 42, old32 = 420, new32 = 50;
+    vol32 = 42;
+    old32 = 420;
+    new32 = 50;
     assert(opal_atomic_compare_exchange_strong_acq_32(&vol32, &old32, new32) == false);
     assert(vol32 == 42);
     assert(old32 == 42);
 
-    vol32 = 42, old32 = 42, new32 = 50;
+    vol32 = 42;
+    old32 = 42;
+    new32 = 50;
     assert(opal_atomic_compare_exchange_strong_rel_32(&vol32, &old32, new32) == true);
     opal_atomic_rmb();
     assert(vol32 == new32);
     assert(old32 == 42);
 
-    vol32 = 42, old32 = 420, new32 = 50;
+    vol32 = 42;
+    old32 = 420;
+    new32 = 50;
     assert(opal_atomic_compare_exchange_strong_rel_32(&vol32, &old32, new32) == false);
     opal_atomic_rmb();
     assert(vol32 == 42);
     assert(old32 == 42);
 
     /* -- cmpset 64-bit tests -- */
 
-    vol64 = 42, old64 = 42, new64 = 50;
+    vol64 = 42;
+    old64 = 42;
+    new64 = 50;
     assert(opal_atomic_compare_exchange_strong_64(&vol64, &old64, new64) == true);
     opal_atomic_rmb();
     assert(new64 == vol64);
     assert(old64 == 42);
 
-    vol64 = 42, old64 = 420, new64 = 50;
+    vol64 = 42;
+    old64 = 420;
+    new64 = 50;
     assert(opal_atomic_compare_exchange_strong_64(&vol64, &old64, new64) == false);
     opal_atomic_rmb();
     assert(vol64 == 42);
     assert(old64 == 42);
 
-    vol64 = 42, old64 = 42, new64 = 50;
+    vol64 = 42;
+    old64 = 42;
+    new64 = 50;
     assert(opal_atomic_compare_exchange_strong_acq_64(&vol64, &old64, new64) == true);
     assert(vol64 == new64);
     assert(old64 == 42);
 
-    vol64 = 42, old64 = 420, new64 = 50;
+    vol64 = 42;
+    old64 = 420;
+    new64 = 50;
     assert(opal_atomic_compare_exchange_strong_acq_64(&vol64, &old64, new64) == false);
     assert(vol64 == 42);
     assert(old64 == 42);
 
-    vol64 = 42, old64 = 42, new64 = 50;
+    vol64 = 42;
+    old64 = 42;
+    new64 = 50;
     assert(opal_atomic_compare_exchange_strong_rel_64(&vol64, &old64, new64) == true);
     opal_atomic_rmb();
     assert(vol64 == new64);
     assert(old64 == 42);
 
-    vol64 = 42, old64 = 420, new64 = 50;
+    vol64 = 42;
+    old64 = 420;
+    new64 = 50;
     assert(opal_atomic_compare_exchange_strong_rel_64(&vol64, &old64, new64) == false);
     opal_atomic_rmb();
     assert(vol64 == 42);
@@ -174,50 +198,114 @@ int main(int argc, char *argv[])
     /* -- cmpset 128-bit tests -- */
 
 #if OPAL_HAVE_ATOMIC_COMPARE_EXCHANGE_128
-    vol128 = 42, old128 = 42, new128 = 50;
+    vol128 = 42;
+    old128 = 42;
+    new128 = 50;
     assert(opal_atomic_compare_exchange_strong_128(&vol128, &old128, new128) == true);
     opal_atomic_rmb();
     assert(new128 == vol128);
     assert(old128 == 42);
 
-    vol128 = 42, old128 = 420, new128 = 50;
+    vol128 = 42;
+    old128 = 420;
+    new128 = 50;
     assert(opal_atomic_compare_exchange_strong_128(&vol128, &old128, new128) == false);
     opal_atomic_rmb();
     assert(vol128 == 42);
     assert(old128 == 42);
 #endif
 
+    /* -- cmpset int tests -- */
+
+    volint = 42;
+    oldint = 42;
+    newint = 50;
+    assert(opal_atomic_compare_exchange_strong_32(&volint, &oldint, newint) == true);
+    opal_atomic_rmb();
+    assert(volint == newint);
+    assert(oldint == 42);
+
+    volint = 42;
+    oldint = 420;
+    newint = 50;
+    assert(opal_atomic_compare_exchange_strong_32(&volint, &oldint, newint) == false);
+    opal_atomic_rmb();
+    assert(volint == 42);
+    assert(oldint == 42);
+
+    volint = 42;
+    oldint = 42;
+    newint = 50;
+    assert(opal_atomic_compare_exchange_strong_acq_32(&volint, &oldint, newint) == true);
+    assert(volint == newint);
+    assert(oldint == 42);
+
+    volint = 42;
+    oldint = 420;
+    newint = 50;
+    assert(opal_atomic_compare_exchange_strong_acq_32(&volint, &oldint, newint) == false);
+    assert(volint == 42);
+    assert(oldint == 42);
+
+    volint = 42;
+    oldint = 42;
+    newint = 50;
+    assert(opal_atomic_compare_exchange_strong_rel_32(&volint, &oldint, newint) == true);
+    opal_atomic_rmb();
+    assert(volint == newint);
+    assert(oldint == 42);
+
+    volint = 42;
+    oldint = 420;
+    newint = 50;
+    assert(opal_atomic_compare_exchange_strong_rel_32(&volint, &oldint, newint) == false);
+    opal_atomic_rmb();
+    assert(volint == 42);
+    assert(oldint == 42);
+
     /* -- cmpset ptr tests -- */
 
-    volptr = 42, oldptr = 42, newptr = 50;
+    volptr = 42;
+    oldptr = 42;
+    newptr = 50;
     assert(opal_atomic_compare_exchange_strong_ptr(&volptr, &oldptr, newptr) == true);
     opal_atomic_rmb();
     assert(volptr == newptr);
     assert(oldptr == 42);
 
-    volptr = 42, oldptr = 420, newptr = 50;
+    volptr = 42;
+    oldptr = 420;
+    newptr = 50;
     assert(opal_atomic_compare_exchange_strong_ptr(&volptr, &oldptr, newptr) == false);
     opal_atomic_rmb();
     assert(volptr == 42);
     assert(oldptr == 42);
 
-    volptr = 42, oldptr = 42, newptr = 50;
+    volptr = 42;
+    oldptr = 42;
+    newptr = 50;
     assert(opal_atomic_compare_exchange_strong_acq_ptr(&volptr, &oldptr, newptr) == true);
     assert(volptr == newptr);
     assert(oldptr == 42);
 
-    volptr = 42, oldptr = 420, newptr = 50;
+    volptr = 42;
+    oldptr = 420;
+    newptr = 50;
     assert(opal_atomic_compare_exchange_strong_acq_ptr(&volptr, &oldptr, newptr) == false);
     assert(volptr == 42);
     assert(oldptr == 42);
 
-    volptr = 42, oldptr = 42, newptr = 50;
+    volptr = 42;
+    oldptr = 42;
+    newptr = 50;
     assert(opal_atomic_compare_exchange_strong_rel_ptr(&volptr, &oldptr, newptr) == true);
     opal_atomic_rmb();
     assert(volptr == newptr);
     assert(oldptr == 42);
 
-    volptr = 42, oldptr = 420, newptr = 50;
+    volptr = 42;
+    oldptr = 420;
+    newptr = 50;
     assert(opal_atomic_compare_exchange_strong_rel_ptr(&volptr, &oldptr, newptr) == false);
     opal_atomic_rmb();
     assert(volptr == 42);

test/class/ompi_rb_tree.c

@@ -34,7 +34,7 @@
 
 #define NUM_KEYS 10000
 #define SEED     1
-int keys[] = {0, 1, 2, 3, 4, 5, 6, 7};
+int global_keys[] = {0, 1, 2, 3, 4, 5, 6, 7};
 
 int values[] = {10, 11, 12, 13, 14, 15, 16, 17};
 
@@ -137,95 +137,95 @@ void test1(void)
         test_failure("failed to properly initialize the tree");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[0], &values[0]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[0], &values[0]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[0]);
+    result = opal_rb_tree_find(&tree, &global_keys[0]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[0], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[1], &values[1]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[1], &values[1]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[1]);
+    result = opal_rb_tree_find(&tree, &global_keys[1]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[1], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[2], &values[2]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[2], &values[2]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[2]);
+    result = opal_rb_tree_find(&tree, &global_keys[2]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[2], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[3], &values[3]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[3], &values[3]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[3]);
+    result = opal_rb_tree_find(&tree, &global_keys[3]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[3], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[4], &values[4]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[4], &values[4]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[4]);
+    result = opal_rb_tree_find(&tree, &global_keys[4]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[4], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[5], &values[5]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[5], &values[5]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[5]);
+    result = opal_rb_tree_find(&tree, &global_keys[5]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[5], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[6], &values[6]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[6], &values[6]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[6]);
+    result = opal_rb_tree_find(&tree, &global_keys[6]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
     if (!test_verify_int(values[6], *((int *) result))) {
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_insert(&tree, &keys[7], &values[7]);
+    rc = opal_rb_tree_insert(&tree, &global_keys[7], &values[7]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly insert a new node");
     }
-    result = opal_rb_tree_find(&tree, &keys[7]);
+    result = opal_rb_tree_find(&tree, &global_keys[7]);
     if (NULL == result) {
         test_failure("lookup returned null!");
     }
@@ -238,11 +238,11 @@ void test1(void)
         test_failure("failed to properly insert a new node");
     }
 
-    rc = opal_rb_tree_delete(&tree, &keys[0]);
+    rc = opal_rb_tree_delete(&tree, &global_keys[0]);
     if (!test_verify_int(OPAL_SUCCESS, rc)) {
         test_failure("failed to properly delete a node");
     }
-    result = opal_rb_tree_find(&tree, &keys[0]);
+    result = opal_rb_tree_find(&tree, &global_keys[0]);
     if (NULL != result) {
         test_failure("lookup returned a value instead of null!");
     } else {

test/class/opal_proc_table.c

@@ -164,10 +164,10 @@ static void test_ptable(opal_proc_table_t *table)
     opal_process_name_t key;
     fprintf(error_out, "\nTesting integer keys...\n");
     for (j = 0; num_keys[j]; j += 3) {
-        opal_process_name_t key;
-        key.jobid = atoi(num_keys[j]);
-        key.vpid = atoi(num_keys[j + 1]);
-        opal_proc_table_set_value(table, key, num_keys[j + 2]);
+        opal_process_name_t key2;
+        key2.jobid = atoi(num_keys[j]);
+        key2.vpid = atoi(num_keys[j + 1]);
+        opal_proc_table_set_value(table, key2, num_keys[j + 2]);
     }
     validate_table(table, num_keys);
     rc = opal_proc_table_get_first_key(table, &key, (void **) &v, (void **) &n1, (void **) &n2);

test/datatype/ddt_lib.c

@@ -345,7 +345,7 @@ struct structure {
 ompi_datatype_t *create_struct_constant_gap_resized_ddt(ompi_datatype_t *type)
 {
     struct structure data[1];
-    ompi_datatype_t *struct_type, *temp_type;
+    ompi_datatype_t *struct_type = NULL, *temp_type = NULL;
     ompi_datatype_t *types[2] = {type, type};
     int blocklens[2] = {1, 1};
     MPI_Aint disps[3];
@@ -390,7 +390,7 @@ ompi_datatype_t *create_strange_dt(void)
     ompi_datatype_t *types[3] = {&ompi_mpi_int.dt};
     sstrange t[2];
     int pBlock[3] = {1, 10, 1}, dispi[3];
-    ompi_datatype_t *pdt, *pdt1, *pdt2, *pdtTemp;
+    ompi_datatype_t *pdt = NULL, *pdt1 = NULL, *pdt2 = NULL, *pdtTemp = NULL;
 
     dispi[0] = (int) ((char *) &(v[0].i1) - (char *) &(v[0]));                   /* 0 */
     dispi[1] = (int) (((char *) (&(v[0].i2)) - (char *) &(v[0])) / sizeof(int)); /* 2 */