[OpenMP] Eliminate some compiler warnings

[jlpeyton]

Summary

1. Remove accidental == for =
2. Assign values to variables to appease compiler
3. Surround debug code with KMP_DEBUG
4. Remove unused local typedefs

[tlwilmar]

LGTM

runtime/src/kmp_affinity.cpp

static int __kmp_hwloc_check_numa() {
 
   // check NUMA node below PACKAGE
   hN = hwloc_get_ancestor_obj_by_type(tp, HWLOC_OBJ_NUMANODE, hT);
   hS = hwloc_get_ancestor_obj_by_type(tp, HWLOC_OBJ_PACKAGE, hT);
   KMP_DEBUG_ASSERT(hS != NULL);
   if (hN != NULL && hN->depth > hS->depth) {
     __kmp_numa_detected = TRUE; // socket includes node(s)
     if (__kmp_affinity_gran == affinity_gran_node) {
-      __kmp_affinity_gran == affinity_gran_numa;
+      __kmp_affinity_gran = affinity_gran_numa;
     }
   }
 
   // check tile, get object by depth because of multiple caches possible
   depth = hwloc_get_cache_type_depth(tp, 2, HWLOC_OBJ_CACHE_UNIFIED);
   hL = hwloc_get_ancestor_obj_by_depth(tp, depth, hT);
   hC = NULL; // not used, but reset it here just in case
   if (hL != NULL &&

runtime/src/kmp_atomic.cpp

__kmp_acquire_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);                       \
                                                                                \
   if (*lhs OP rhs) { /* still need actions? */                                 \
     old_value = *lhs;                                                          \
     *lhs = rhs;                                                                \
     if (flag)                                                                  \
       new_value = rhs;                                                         \
     else                                                                       \
       new_value = old_value;                                                   \
+  } else {                                                                     \
+    new_value = *lhs;                                                          \
   }                                                                            \
   __kmp_release_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);                       \
   return new_value;
 
 // -------------------------------------------------------------------------
 #ifdef KMP_GOMP_COMPAT
 #define GOMP_MIN_MAX_CRITSECT_CPT(OP, FLAG)                                    \
   if ((FLAG) && (__kmp_atomic_mode == 2)) {                                    \

runtime/src/kmp_dispatch_hier.h

  * inside barrier() until all fellow threads who are attached to that
  * kmp_hier_top_unit_t structure have arrived.
  */
 
 // Core barrier implementation
 // Can be used in a unit with between 2 to 8 threads
 template <typename T> class core_barrier_impl {
   static inline kmp_uint64 get_wait_val(int num_active) {
-    kmp_uint64 wait_val;
+    kmp_uint64 wait_val = 0LL;
     switch (num_active) {
     case 2:
       wait_val = 0x0101LL;
       break;
     case 3:
       wait_val = 0x010101LL;
       break;
     case 4:
template <typename T> struct kmp_hier_top_unit_t {
   dispatch_private_info_template<T> *get_my_pr() { return &hier_pr; }
   kmp_hier_top_unit_t<T> *get_parent() { return hier_parent; }
   dispatch_private_info_template<T> *get_parent_pr() {
     return &(hier_parent->hier_pr);
   }
 
   kmp_int32 is_active() const { return active; }
   kmp_int32 get_num_active() const { return active; }
+#ifdef KMP_DEBUG
   void print() {
     KD_TRACE(
         10,
         ("    kmp_hier_top_unit_t: active:%d pr:%p lb:%d ub:%d st:%d tc:%d\n",
          active, &hier_pr, hier_pr.u.p.lb, hier_pr.u.p.ub, hier_pr.u.p.st,
          hier_pr.u.p.tc));
   }
+#endif
 };
 
 // Information regarding a single layer within the scheduling hierarchy
 template <typename T> struct kmp_hier_layer_info_t {
   int num_active; // number of threads active in this level
   kmp_hier_layer_e type; // LAYER_L1, LAYER_L2, etc.
   enum sched_type sched; // static, dynamic, guided, etc.
   typename traits_t<T>::signed_t chunk; // chunk size associated with schedule
   int length; // length of the kmp_hier_top_unit_t array
 
+#ifdef KMP_DEBUG
   // Print this layer's information
   void print() {
     const char *t = __kmp_get_hier_str(type);
     KD_TRACE(
         10,
         ("    kmp_hier_layer_info_t: num_active:%d type:%s sched:%d chunk:%d "
          "length:%d\n",
          num_active, t, sched, chunk, length));
   }
+#endif
 };
 
 /*
  * Structure to implement entire hierarchy
  *
  * The hierarchy is kept as an array of arrays to represent the different
  * layers.  Layer 0 is the lowest layer to layer num_layers - 1 which is the
  * highest layer.
#endif
   // Returns the number of layers in the hierarchy
   int get_num_layers() const { return num_layers; }
   // Returns the number of threads in the top layer
   // This is necessary because we don't store a topology unit as
   // the very top level and the scheduling algorithms need this information
   int get_top_level_nproc() const { return top_level_nproc; }
   // Return whether this hierarchy is valid or not
   bool is_valid() const { return valid; }
+#ifdef KMP_DEBUG
   // Print the hierarchy
   void print() {
     KD_TRACE(10, ("kmp_hier_t:\n"));
     for (int i = num_layers - 1; i >= 0; --i) {
       KD_TRACE(10, ("Info[%d] = ", i));
       info[i].print();
     }
     for (int i = num_layers - 1; i >= 0; --i) {
       KD_TRACE(10, ("Layer[%d] =\n", i));
       for (int j = 0; j < info[i].length; ++j) {
         layers[i][j].print();
       }
     }
   }
+#endif
 };
 
 template <typename T>
 void __kmp_dispatch_init_hierarchy(ident_t *loc, int n,
                                    kmp_hier_layer_e *new_layers,
                                    enum sched_type *new_scheds,
                                    typename traits_t<T>::signed_t *new_chunks,
                                    T lb, T ub,
                                    typename traits_t<T>::signed_t st) {
-  typedef typename traits_t<T>::signed_t ST;
-  typedef typename traits_t<T>::unsigned_t UT;
   int tid, gtid, num_hw_threads, num_threads_per_layer1, active;
   int my_buffer_index;
   kmp_info_t *th;
   kmp_team_t *team;
   dispatch_private_info_template<T> *pr;
   dispatch_shared_info_template<T> volatile *sh;
   gtid = __kmp_entry_gtid();
   tid = __kmp_tid_from_gtid(gtid);