[runtime] Run clang-format to fix warnings; NFC

Fix -Wmisleading-indentation warnings in a number of files by running
clang-format on the affected code sections with the following options,
to stay close to the original Classic Flang style:

    BasedOnStyle: LLVM
    AlwaysBreakAfterDefinitionReturnType: TopLevel
    BreakBeforeBraces: WebKit
    SortIncludes: false

This also removes tabs and extraneous spaces, and corrects non-compliant
coding style.

Author: bryanpkc

runtime/flang/type.c

@@ -6,14 +6,14 @@
  */
 
 #include <stddef.h>
-#include <stdlib.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 #ifndef _WIN64
 #include <pthread.h>
 #endif
-#include <stdioInterf.h>
 #include "komp.h"
+#include <stdioInterf.h>
 
 /* This routine makes a simple omp library call to force lazy initialization of
  * kmpc to occur early.
@@ -71,7 +71,8 @@ static int is_init_nest = 0;
 static int is_init_nest_red = 0;
 static int is_atfork_registered = 0;
 
-static void __llcrit_atfork(void)
+static void
+__llcrit_atfork(void)
 {
   is_init_nest = 0;
   is_init_nest_red = 0;
@@ -153,28 +154,27 @@ _mp_ecs_nest_red(void)
 void
 _mp_cdeclp(void *blk, void ***blk_tp, int size)
 {
-  __kmpc_threadprivate_cached(0, __kmpc_global_thread_num(0), (void*)blk, (size_t)size, blk_tp);
-
+  __kmpc_threadprivate_cached(0, __kmpc_global_thread_num(0), (void *)blk,
+                              (size_t)size, blk_tp);
 }
 
 void
 _mp_cdecli(void *blk, void ***blk_tp, int size)
 {
-  __kmpc_threadprivate_cached(0, __kmpc_global_thread_num(0), (void*)blk, (size_t)size, blk_tp);
- 
+  __kmpc_threadprivate_cached(0, __kmpc_global_thread_num(0), (void *)blk,
+                              (size_t)size, blk_tp);
 }
 
 void
 _mp_cdecl(void *blk, void ***blk_tp, int size)
 {
-  __kmpc_threadprivate_cached(0, __kmpc_global_thread_num(0), (void*)blk, (size_t)size, blk_tp);
- 
+  __kmpc_threadprivate_cached(0, __kmpc_global_thread_num(0), (void *)blk,
+                              (size_t)size, blk_tp);
 }
 
 static char *singadr;
 static long singlen;
 
-
 /* C/C++: copy a private stack or other other variable */
 void
 _mp_copypriv(char *adr, long len, int thread)
@@ -219,20 +219,21 @@ _mp_copypriv_move(void *blk_tp, int off, int size, int single_thread)
   char *to;
   char *garbage = 0;
 
-  if (single_thread != -1) {  /* single thread */
-    singadr =  __kmpc_threadprivate_cached(0, single_thread, garbage, (size_t)size, blk_tp);
+  if (single_thread != -1) { /* single thread */
+    singadr = __kmpc_threadprivate_cached(0, single_thread, garbage,
+                                          (size_t)size, blk_tp);
     singlen = size;
   }
   __kmpc_barrier(0, __kmpc_global_thread_num(0));
-  if (single_thread == -1) {  /* single thread */
-     lcpu = __kmpc_global_thread_num(0);
-     to = __kmpc_threadprivate_cached(0, lcpu, garbage, (size_t)size, blk_tp);
-     memcpy(to, singadr, size);
+  if (single_thread == -1) { /* single thread */
+    lcpu = __kmpc_global_thread_num(0);
+    to = __kmpc_threadprivate_cached(0, lcpu, garbage, (size_t)size, blk_tp);
+    memcpy(to, singadr, size);
   }
   __kmpc_barrier(0, __kmpc_global_thread_num(0));
 }
 
-/* C/C++: copy data from the threads' block to the other threads blocks. 
+/* C/C++: copy data from the threads' block to the other threads blocks.
  * Use when experiment flag 69,0x80
  */
 
@@ -243,29 +244,29 @@ _mp_copypriv_move_tls(void **blk_tp, int off, int size, int single_thread)
   char *to;
   char *garbage = 0;
 
-  if (single_thread != -1) {  /* single thread */
+  if (single_thread != -1) { /* single thread */
     if (*blk_tp == 0)
-      singadr =  (char*)__kmpc_threadprivate(0, single_thread, garbage, (size_t)size);
+      singadr =
+          (char *)__kmpc_threadprivate(0, single_thread, garbage, (size_t)size);
     else
       singadr = *blk_tp;
     singlen = size;
   }
   __kmpc_barrier(0, __kmpc_global_thread_num(0));
-  if (single_thread == -1) {  /* single thread */
-     lcpu = __kmpc_global_thread_num(0);
-     if (*blk_tp == 0)
-       to = __kmpc_threadprivate(0, lcpu, garbage, (size_t)size);
-     else
-       to = *blk_tp;
-     memcpy(to, singadr, size);
+  if (single_thread == -1) { /* single thread */
+    lcpu = __kmpc_global_thread_num(0);
+    if (*blk_tp == 0)
+      to = __kmpc_threadprivate(0, lcpu, garbage, (size_t)size);
+    else
+      to = *blk_tp;
+    memcpy(to, singadr, size);
   }
   __kmpc_barrier(0, __kmpc_global_thread_num(0));
 }
 
-
-/*C: copy data from the master's block to the other threads blocks 
+/*C: copy data from the master's block to the other threads blocks
  * Don't use: keep for backward compatibility
-*/
+ */
 
 void
 _mp_copyin_move(void *blk_tp, int off, int size)
@@ -274,18 +275,18 @@ _mp_copyin_move(void *blk_tp, int off, int size)
   char *to, *fr;
   char *garbage = 0;
 
-  lcpu =__kmpc_global_thread_num(0);  
+  lcpu = __kmpc_global_thread_num(0);
 
   if (lcpu != 0) {
-    fr =  __kmpc_threadprivate_cached(0, 0, garbage, (size_t)size, blk_tp);
-    to =  __kmpc_threadprivate_cached(0, lcpu, garbage, (size_t)size, blk_tp);
+    fr = __kmpc_threadprivate_cached(0, 0, garbage, (size_t)size, blk_tp);
+    to = __kmpc_threadprivate_cached(0, lcpu, garbage, (size_t)size, blk_tp);
     if (to != fr)
       memcpy(to, fr, size);
   }
   __kmpc_barrier(0, __kmpc_global_thread_num(0));
 }
 
-/* C: copy data from the master's block to the other threads blocks 
+/* C: copy data from the master's block to the other threads blocks
  * Use when experiment flag 69,0x80
  */
 
@@ -296,65 +297,62 @@ _mp_copyin_move_tls(void *blk_tp, int off, int size)
   char *to, *fr;
   char *garbage = 0;
 
-  lcpu =__kmpc_global_thread_num(0);  
+  lcpu = __kmpc_global_thread_num(0);
 
   if (lcpu != 0) {
-    fr =  __kmpc_threadprivate(0, 0, garbage, (size_t)size);
-    to =  __kmpc_threadprivate(0, lcpu, garbage, (size_t)size);
+    fr = __kmpc_threadprivate(0, 0, garbage, (size_t)size);
+    to = __kmpc_threadprivate(0, lcpu, garbage, (size_t)size);
     if (to != fr)
       memcpy(to, fr, size);
   }
   __kmpc_barrier(0, __kmpc_global_thread_num(0));
 }
 
-typedef void (*assign_func_ptr) (void * , void * );
+typedef void (*assign_func_ptr)(void *, void *);
 
-/* C++: copy data from the master's block to the other threads blocks 
-   using the assignment operator 
-	vector_size is 1 for non arrays
-                       n for array[n]
+/* C++: copy data from the master's block to the other threads blocks
+   using the assignment operator
+   vector_size is 1 for non arrays
+                  n for array[n]
  * Don't use: keep for backward compatibility
  */
 
 void
-_mp_copyin_move_cpp(void *blk_tp, int off, int class_size, 
-                     int vector_size,assign_func_ptr assign_op)
+_mp_copyin_move_cpp(void *blk_tp, int off, int class_size, int vector_size,
+                    assign_func_ptr assign_op)
 {
   int lcpu;
   char *to, *fr;
   char *garbage = 0;
   int i;
 
-  lcpu =__kmpc_global_thread_num(0);  
+  lcpu = __kmpc_global_thread_num(0);
 
   __kmpc_barrier(0, lcpu);
   if (lcpu != 0) {
-    fr =  __kmpc_threadprivate_cached(0, 0, garbage, 
-			               (size_t) (class_size * vector_size), 
-					blk_tp);
-    to =  __kmpc_threadprivate_cached(0, lcpu, garbage, 
-				       (size_t)(class_size * vector_size), 
-					blk_tp);
-
-    for(i = 0 ; i < vector_size; i++) {
-        if (to != fr)
-	    (*assign_op)(to, fr);
-	to += class_size;
-	fr += class_size;
-     }
+    fr = __kmpc_threadprivate_cached(
+        0, 0, garbage, (size_t)(class_size * vector_size), blk_tp);
+    to = __kmpc_threadprivate_cached(
+        0, lcpu, garbage, (size_t)(class_size * vector_size), blk_tp);
+
+    for (i = 0; i < vector_size; i++) {
+      if (to != fr)
+        (*assign_op)(to, fr);
+      to += class_size;
+      fr += class_size;
+    }
   }
   __kmpc_barrier(0, lcpu);
-} 
+}
 
-/* C++: copy data from the master's block to the other threads blocks 
-   using the assignment operator 
-	vector_size is 1 for non arrays
+/* C++: copy data from the master's block to the other threads blocks
+   using the assignment operator
+        vector_size is 1 for non arrays
                        n for array[n]
  */
 void
-_mp_copyin_move_cpp_new(void *blk_tp, int off, int class_size, 
-                       int vector_size,assign_func_ptr assign_op,
-                       char* fr)
+_mp_copyin_move_cpp_new(void *blk_tp, int off, int class_size, int vector_size,
+                        assign_func_ptr assign_op, char *fr)
 {
   int lcpu;
   char *to;
@@ -364,60 +362,60 @@ _mp_copyin_move_cpp_new(void *blk_tp, int off, int class_size,
   if (!fr)
     return;
 
-  lcpu =__kmpc_global_thread_num(0);  
+  lcpu = __kmpc_global_thread_num(0);
 
-  to =  __kmpc_threadprivate_cached(0, lcpu, garbage, 
-				    (size_t)(class_size * vector_size), 
-				    blk_tp);
+  to = __kmpc_threadprivate_cached(0, lcpu, garbage,
+                                   (size_t)(class_size * vector_size), blk_tp);
 
-  for(i = 0 ; i < vector_size; i++) {
+  for (i = 0; i < vector_size; i++) {
     if (to != fr)
       (*assign_op)(to, fr);
-      to += class_size;
-      fr += class_size;
+    to += class_size;
+    fr += class_size;
   }
-
-} 
+}
 
 /*
  * Use when experiment flag 69,0x80
  */
 void
-_mp_copyin_move_cpp_tls(void *master, void* slave, int class_size, 
-                     int vector_size,assign_func_ptr assign_op)
+_mp_copyin_move_cpp_tls(void *master, void *slave, int class_size,
+                        int vector_size, assign_func_ptr assign_op)
 {
   char *to, *fr;
   int i;
 
-  fr =  (char*)master;
-  to =  (char*)slave;
+  fr = (char *)master;
+  to = (char *)slave;
   if (fr && to) {
-     for(i = 0 ; i < vector_size; i++) {
-	(*assign_op)(to, fr);
-	to += class_size;
-	fr += class_size;
-     }
+    for (i = 0; i < vector_size; i++) {
+      (*assign_op)(to, fr);
+      to += class_size;
+      fr += class_size;
+    }
   }
-} 
-    
-/* Copy multiple items from master to children threads. 
+}
+
+/* Copy multiple items from master to children threads.
  * Don't use: keep for backward compatibility
  */
 void
 _mp_copyin_move_multiple(int n_entries, void *data)
 {
   int i;
   const int tid = __kmpc_global_thread_num(NULL);
-  struct pair_t {size_t size; void *data;};
-
+  struct pair_t {
+    size_t size;
+    void *data;
+  };
 
   if (tid != 0) {
-    for (i=0; i<n_entries; ++i) {
+    for (i = 0; i < n_entries; ++i) {
       struct pair_t *item = (struct pair_t *)data + i;
       void *key = item->data;
       const size_t size = item->size;
       void *to = __kmpc_threadprivate_cached(NULL, tid, NULL, size, key);
-      /* FIXME: Should this be 0 or the team master? 
+      /* FIXME: Should this be 0 or the team master?
        * I think the gtid of team master.
        */
       void *fr = __kmpc_threadprivate_cached(NULL, 0, NULL, size, key);
@@ -440,8 +438,8 @@ _mp_copyin_move_al(void *blk_tp, int off, long size)
 
   lcpu = __kmpc_global_thread_num(0);
   if (lcpu != 0) {
-    fr =  __kmpc_threadprivate_cached(0, 0, garbage, (size_t)size, blk_tp);
-    to =  __kmpc_threadprivate_cached(0, lcpu, garbage, (size_t)size, blk_tp);
+    fr = __kmpc_threadprivate_cached(0, 0, garbage, (size_t)size, blk_tp);
+    to = __kmpc_threadprivate_cached(0, lcpu, garbage, (size_t)size, blk_tp);
     if (to && to != fr) {
       memcpy(to, fr, size);
     }
@@ -455,25 +453,29 @@ _mp_copyin_move_al(void *blk_tp, int off, long size)
 void
 _mp_copypriv_kmpc(void *dest, void *src)
 {
-  struct pair_t {size_t *size; void *data;};
-  const struct pair_t *to   = (struct pair_t *)dest;
+  struct pair_t {
+    size_t *size;
+    void *data;
+  };
+  const struct pair_t *to = (struct pair_t *)dest;
   const struct pair_t *from = (struct pair_t *)src;
 
-  for ( ; from->size; ++from, ++to) {
+  for (; from->size; ++from, ++to) {
     if (to->data != from->data)
       memcpy(to->data, from->data, *from->size);
   }
 }
 
-/* duplicate kmpc_threadprivate_cached but we assume each thread has its own addr
- * in its own [tls] address space so that it does not need to access memory in other
- * thread's area. Use when experiment flag 69,0x80
+/* duplicate kmpc_threadprivate_cached but we assume each thread has its own
+ * addr in its own [tls] address space so that it does not need to access memory
+ * in other thread's area. Use when experiment flag 69,0x80
  */
-void* 
-_mp_get_threadprivate(ident_t * ident, kmp_int32 gtid, void* tpv, size_t size, void** addr)
+void *
+_mp_get_threadprivate(ident_t *ident, kmp_int32 gtid, void *tpv, size_t size,
+                      void **addr)
 {
   if (*addr == NULL) {
-    *addr =  __kmpc_threadprivate(ident, gtid, tpv, size);
+    *addr = __kmpc_threadprivate(ident, gtid, tpv, size);
   }
   return *addr;
 }