Remove const from variables with dynamic memory

[Hahnfeld]

Summary

Allocated memory is typically not 'const' if it needs to be freed.
This patch removes around 50 wrong const attributes, modifies the
corresponding functions and finally gets rid of some const_casts.
These have especially been strange for __kmp_str_fname_free() that
added a 'const' to call __kmp_str_free() which removed it again.

Two minor cleanups that I performed in this process:

• __kmp_tool_libraries now lives in kmp_settings.cpp as it is used nowhere else.
• __kmp_msg_empty was removed as it was never used and Clang now complained that it was assigned a string literal that is 'const char *'.

[AndreyChurbanov]

LGTM

runtime/src/kmp_i18n.h

111 ↗

(On Diff #121958)

This comment now looks ugly, as only one special message remains. I think it'd be better to combine the two comments into single one, something like "Special message to denote the end of variadic list of arguments".

[AndreyChurbanov]

Sorry, was too hasty.

This patch gives me compile error:

trunk/runtime/src/kmp_settings.cpp:1571:3: error: no matching function for call to

    '__kmp_stg_parse_str'
__kmp_stg_parse_str(name, value, &__kmp_cpuinfo_file);
^~~~~~~~~~~~~~~~~~~

So probably the __kmp_cpuinfo_file type should be changed to "char*", or const should be casted out.

[Hahnfeld]

Remove const from __kmp_cpuinfo_file.

[Hahnfeld]

In D39755#920386, @AndreyChurbanov wrote:

Sorry, was too hasty.

This patch gives me compile error:

trunk/runtime/src/kmp_settings.cpp:1571:3: error: no matching function for call to

    '__kmp_stg_parse_str'
__kmp_stg_parse_str(name, value, &__kmp_cpuinfo_file);
^~~~~~~~~~~~~~~~~~~

So probably the __kmp_cpuinfo_file type should be changed to "char*", or const should be casted out.

Damn, this code was covered by KMP_AFFINITY_SUPPORTED which is set neither on my MacBook nor on Power. I "hacked" this by temporarily enabling it on Power. Would you be able to retest on x86 Linux?

[AndreyChurbanov]

LGTM

I've checked both const related patches (this one and D39756) on Linux x86 using clang and icc. They work for me now.

[Hahnfeld]

In D39755#920491, @AndreyChurbanov wrote:

LGTM

I've checked both const related patches (this one and D39756) on Linux x86 using clang and icc. They work for me now.

Thanks, much appreciated. Maybe I should look into enabling affinity on Power to reduce the amount of code that isn't built and tested there...

openmp/trunk/runtime/src/kmp.h

 extern int __kmp_affinity_warnings; /* KMP_AFFINITY warnings enabled ? */
 extern int __kmp_affinity_respect_mask; // Respect process' init affinity mask?
 extern char *__kmp_affinity_proclist; /* proc ID list */
 extern kmp_affin_mask_t *__kmp_affinity_masks;
 extern unsigned __kmp_affinity_num_masks;
 extern void __kmp_affinity_bind_thread(int which);
 
 extern kmp_affin_mask_t *__kmp_affin_fullMask;
-extern char const *__kmp_cpuinfo_file;
+extern char *__kmp_cpuinfo_file;
 
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 #if OMP_40_ENABLED
 
 // This needs to be kept in sync with the values in omp.h !!!
 typedef enum kmp_proc_bind_t {
   proc_bind_false = 0,

 extern kmp_hws_item_t __kmp_hws_socket;
 extern kmp_hws_item_t __kmp_hws_node;
 extern kmp_hws_item_t __kmp_hws_tile;
 extern kmp_hws_item_t __kmp_hws_core;
 extern kmp_hws_item_t __kmp_hws_proc;
 extern int __kmp_hws_requested;
 extern int __kmp_hws_abs_flag; // absolute or per-item number requested
 
-#if OMP_50_ENABLED && LIBOMP_OMPT_SUPPORT
-extern char const *__kmp_tool_libraries;
-#endif // OMP_50_ENABLED && LIBOMP_OMPT_SUPPORT
-
 /* ------------------------------------------------------------------------ */
 
 #define KMP_PAD(type, sz)                                                      \
   (sizeof(type) + (sz - ((sizeof(type) - 1) % (sz)) - 1))
 
 // We need to avoid using -1 as a GTID as +1 is added to the gtid
 // when storing it in a lock, and the value 0 is reserved.
 #define KMP_GTID_DNE (-2) /* Does not exist */

openmp/trunk/runtime/src/kmp_dispatch.cpp

if (__kmp_env_consistency_check) {
                                &p->stack_data[p->w_top]);
       }
     }
 #endif /* !defined(KMP_GOMP_COMPAT) */
 
     KMP_MB();
 #ifdef KMP_DEBUG
     {
-      const char *buff;
+      char *buff;
       // create format specifiers before the debug output
       buff = __kmp_str_format("__kmp_dispatch_deo: T#%%d before wait: "
                               "ordered_iter:%%%s lower:%%%s\n",
                               traits_t<UT>::spec, traits_t<UT>::spec);
       KD_TRACE(1000, (buff, gtid, sh->u.s.ordered_iteration, lower));
       __kmp_str_free(&buff);
     }
 #endif
 
     __kmp_wait_yield<UT>(&sh->u.s.ordered_iteration, lower,
                          __kmp_ge<UT> USE_ITT_BUILD_ARG(NULL));
     KMP_MB(); /* is this necessary? */
 #ifdef KMP_DEBUG
     {
-      const char *buff;
+      char *buff;
       // create format specifiers before the debug output
       buff = __kmp_str_format("__kmp_dispatch_deo: T#%%d after wait: "
                               "ordered_iter:%%%s lower:%%%s\n",
                               traits_t<UT>::spec, traits_t<UT>::spec);
       KD_TRACE(1000, (buff, gtid, sh->u.s.ordered_iteration, lower));
       __kmp_str_free(&buff);
     }
 #endif
__kmp_dispatch_init(ident_t *loc, int gtid, enum sched_type schedule, T lb,
   if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 
 #if INCLUDE_SSC_MARKS
   SSC_MARK_DISPATCH_INIT();
 #endif
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmp_dispatch_init: T#%%d called: schedule:%%d "
                             "chunk:%%%s lb:%%%s ub:%%%s st:%%%s\n",
                             traits_t<ST>::spec, traits_t<T>::spec,
                             traits_t<T>::spec, traits_t<ST>::spec);
     KD_TRACE(10, (buff, gtid, schedule, chunk, lb, ub, st));
     __kmp_str_free(&buff);
   }
if (schedule == kmp_sch_runtime) {
       // Use the chunk size specified by OMP_SCHEDULE (or default if not
       // specified)
       chunk = team->t.t_sched.chunk;
 #if USE_ITT_BUILD
       cur_chunk = chunk;
 #endif
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format(
             "__kmp_dispatch_init: T#%%d new: schedule:%%d chunk:%%%s\n",
             traits_t<ST>::spec);
         KD_TRACE(10, (buff, gtid, schedule, chunk));
         __kmp_str_free(&buff);
       }
 #endif
     } else {
       if (schedule == kmp_sch_guided_chunked) {
         schedule = __kmp_guided;
       }
       if (chunk <= 0) {
         chunk = KMP_DEFAULT_CHUNK;
       }
     }
 
     if (schedule == kmp_sch_auto) {
       // mapping and differentiation: in the __kmp_do_serial_initialize()
       schedule = __kmp_auto;
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format("__kmp_dispatch_init: kmp_sch_auto: T#%%d new: "
                                 "schedule:%%d chunk:%%%s\n",
                                 traits_t<ST>::spec);
         KD_TRACE(10, (buff, gtid, schedule, chunk));
         __kmp_str_free(&buff);
       }
 #endif
if (schedule == kmp_sch_runtime_simd) {
         }
         chunk = team->t.t_sched.chunk * chunk;
       }
 #if USE_ITT_BUILD
       cur_chunk = chunk;
 #endif
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format("__kmp_dispatch_init: T#%%d new: schedule:%%d"
                                 " chunk:%%%s\n",
                                 traits_t<ST>::spec);
         KD_TRACE(10, (buff, gtid, schedule, chunk));
         __kmp_str_free(&buff);
       }
 #endif
if (itt_need_metadata_reporting) {
       }
       __kmp_itt_metadata_loop(loc, schedtype, tc, cur_chunk);
     }
 #endif /* USE_ITT_BUILD */
   }
 
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format(
         "__kmp_dispatch_init: T#%%d returning: schedule:%%d ordered:%%%s "
         "lb:%%%s ub:%%%s"
         " st:%%%s tc:%%%s count:%%%s\n\tordered_lower:%%%s ordered_upper:%%%s"
         " parm1:%%%s parm2:%%%s parm3:%%%s parm4:%%%s\n",
         traits_t<UT>::spec, traits_t<T>::spec, traits_t<T>::spec,
         traits_t<ST>::spec, traits_t<UT>::spec, traits_t<UT>::spec,
if (pr->ordered_bumped) {
           ("__kmp_dispatch_finish: T#%d resetting ordered_bumped to zero\n",
            gtid));
       pr->ordered_bumped = 0;
     } else {
       UT lower = pr->u.p.ordered_lower;
 
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format("__kmp_dispatch_finish: T#%%d before wait: "
                                 "ordered_iteration:%%%s lower:%%%s\n",
                                 traits_t<UT>::spec, traits_t<UT>::spec);
         KD_TRACE(1000, (buff, gtid, sh->u.s.ordered_iteration, lower));
         __kmp_str_free(&buff);
       }
 #endif
 
       __kmp_wait_yield<UT>(&sh->u.s.ordered_iteration, lower,
                            __kmp_ge<UT> USE_ITT_BUILD_ARG(NULL));
       KMP_MB(); /* is this necessary? */
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format("__kmp_dispatch_finish: T#%%d after wait: "
                                 "ordered_iteration:%%%s lower:%%%s\n",
                                 traits_t<UT>::spec, traits_t<UT>::spec);
         KD_TRACE(1000, (buff, gtid, sh->u.s.ordered_iteration, lower));
         __kmp_str_free(&buff);
       }
 #endif
if (pr->ordered_bumped == inc) {
           ("__kmp_dispatch_finish: T#%d resetting ordered_bumped to zero\n",
            gtid));
       pr->ordered_bumped = 0;
     } else {
       inc -= pr->ordered_bumped;
 
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format(
             "__kmp_dispatch_finish_chunk: T#%%d before wait: "
             "ordered_iteration:%%%s lower:%%%s upper:%%%s\n",
             traits_t<UT>::spec, traits_t<UT>::spec, traits_t<UT>::spec);
         KD_TRACE(1000, (buff, gtid, sh->u.s.ordered_iteration, lower, upper));
         __kmp_str_free(&buff);
       }
 #endif
 
       __kmp_wait_yield<UT>(&sh->u.s.ordered_iteration, lower,
                            __kmp_ge<UT> USE_ITT_BUILD_ARG(NULL));
 
       KMP_MB(); /* is this necessary? */
       KD_TRACE(1000, ("__kmp_dispatch_finish_chunk: T#%d resetting "
                       "ordered_bumped to zero\n",
                       gtid));
       pr->ordered_bumped = 0;
 //!!!!! TODO check if the inc should be unsigned, or signed???
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format(
             "__kmp_dispatch_finish_chunk: T#%%d after wait: "
             "ordered_iteration:%%%s inc:%%%s lower:%%%s upper:%%%s\n",
             traits_t<UT>::spec, traits_t<UT>::spec, traits_t<UT>::spec,
             traits_t<UT>::spec);
         KD_TRACE(1000,
                  (buff, gtid, sh->u.s.ordered_iteration, inc, lower, upper));
#endif
   int status;
   dispatch_private_info_template<T> *pr;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
 
   KMP_DEBUG_ASSERT(p_lb && p_ub && p_st); // AC: these cannot be NULL
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmp_dispatch_next: T#%%d called p_lb:%%%s "
                             "p_ub:%%%s p_st:%%%s p_last: %%p\n",
                             traits_t<T>::spec, traits_t<T>::spec,
                             traits_t<ST>::spec);
     KD_TRACE(1000, (buff, gtid, *p_lb, *p_ub, p_st ? *p_st : 0, p_last));
     __kmp_str_free(&buff);
   }
#endif /* KMP_OS_WINDOWS */
           *p_ub = start + limit * incr;
         }
 
         if (pr->ordered) {
           pr->u.p.ordered_lower = init;
           pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
           {
-            const char *buff;
+            char *buff;
             // create format specifiers before the debug output
             buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                     "ordered_lower:%%%s ordered_upper:%%%s\n",
                                     traits_t<UT>::spec, traits_t<UT>::spec);
             KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                             pr->u.p.ordered_upper));
             __kmp_str_free(&buff);
           }

 #endif /* KMP_OS_WINDOWS */
       if (p_last != NULL)
         *p_last = TRUE;
       if (p_st != NULL)
         *p_st = pr->u.p.st;
     } // if
 #ifdef KMP_DEBUG
     {
-      const char *buff;
+      char *buff;
       // create format specifiers before the debug output
       buff = __kmp_str_format(
           "__kmp_dispatch_next: T#%%d serialized case: p_lb:%%%s "
           "p_ub:%%%s p_st:%%%s p_last:%%p %%d  returning:%%d\n",
           traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec);
       KD_TRACE(10, (buff, gtid, *p_lb, *p_ub, *p_st, p_last, *p_last, status));
       __kmp_str_free(&buff);
     }
#endif
             *p_ub = start + limit * incr;
           }
 
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif // ( KMP_STATIC_STEAL_ENABLED )
           if (p_st != NULL)
             *p_st = pr->u.p.st;
         } else { /* no iterations to do */
           pr->u.p.lb = pr->u.p.ub + pr->u.p.st;
         }
         if (pr->ordered) {
 #ifdef KMP_DEBUG
           {
-            const char *buff;
+            char *buff;
             // create format specifiers before the debug output
             buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                     "ordered_lower:%%%s ordered_upper:%%%s\n",
                                     traits_t<UT>::spec, traits_t<UT>::spec);
             KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                             pr->u.p.ordered_upper));
             __kmp_str_free(&buff);
           }
#endif
             *p_ub = start + limit * incr;
           }
 
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif
             *p_ub = start + limit * incr;
           }
 
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif
             *p_st = incr;
           *p_lb = start + init * incr;
           *p_ub = start + limit * incr;
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif
             *p_st = incr;
           *p_lb = start + init * incr;
           *p_ub = start + limit * incr;
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif
             *p_st = incr;
           *p_lb = start + init * incr;
           *p_ub = start + limit * incr;
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif
             *p_ub = start + limit * incr;
           }
 
           if (pr->ordered) {
             pr->u.p.ordered_lower = init;
             pr->u.p.ordered_upper = limit;
 #ifdef KMP_DEBUG
             {
-              const char *buff;
+              char *buff;
               // create format specifiers before the debug output
               buff = __kmp_str_format("__kmp_dispatch_next: T#%%d "
                                       "ordered_lower:%%%s ordered_upper:%%%s\n",
                                       traits_t<UT>::spec, traits_t<UT>::spec);
               KD_TRACE(1000, (buff, gtid, pr->u.p.ordered_lower,
                               pr->u.p.ordered_upper));
               __kmp_str_free(&buff);
             }
#endif
     } // if tc == 0;
 
     if (status == 0) {
       UT num_done;
 
       num_done = test_then_inc<ST>((volatile ST *)&sh->u.s.num_done);
 #ifdef KMP_DEBUG
       {
-        const char *buff;
+        char *buff;
         // create format specifiers before the debug output
         buff = __kmp_str_format(
             "__kmp_dispatch_next: T#%%d increment num_done:%%%s\n",
             traits_t<UT>::spec);
         KD_TRACE(100, (buff, gtid, sh->u.s.num_done));
         __kmp_str_free(&buff);
       }
 #endif
#if KMP_OS_WINDOWS
     }
 #endif /* KMP_OS_WINDOWS */
     if (p_last != NULL && status != 0)
       *p_last = last;
   } // if
 
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format(
         "__kmp_dispatch_next: T#%%d normal case: "
         "p_lb:%%%s p_ub:%%%s p_st:%%%s p_last:%%p  returning:%%d\n",
         traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec);
     KD_TRACE(10, (buff, gtid, *p_lb, *p_ub, p_st ? *p_st : 0, p_last, status));
     __kmp_str_free(&buff);
   }
static void __kmp_dist_get_bounds(ident_t *loc, kmp_int32 gtid,
   UT trip_count;
   kmp_team_t *team;
   kmp_info_t *th;
 
   KMP_DEBUG_ASSERT(plastiter && plower && pupper);
   KE_TRACE(10, ("__kmpc_dist_get_bounds called (%d)\n", gtid));
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmpc_dist_get_bounds: T#%%d liter=%%d "
                             "iter=(%%%s, %%%s, %%%s) signed?<%s>\n",
                             traits_t<T>::spec, traits_t<T>::spec,
                             traits_t<ST>::spec, traits_t<T>::spec);
     KD_TRACE(100, (buff, gtid, *plastiter, *plower, *pupper, incr));
     __kmp_str_free(&buff);
   }

openmp/trunk/runtime/src/kmp_environment.h

 __kmp_env_blk_sort( & block ); // Optionally, sort list.
 for ( i = 0; i < block.count; ++ i ) {
     // Process block.vars[ i ].name and block.vars[ i ].value...
 }
 __kmp_env_block_free( & block );
 */
 
 struct __kmp_env_var {
-  char const *name;
-  char const *value;
+  char *name;
+  char *value;
 };
 typedef struct __kmp_env_var kmp_env_var_t;
 
 struct __kmp_env_blk {
-  char const *bulk;
-  kmp_env_var_t const *vars;
+  char *bulk;
+  kmp_env_var_t *vars;
   int count;
 };
 typedef struct __kmp_env_blk kmp_env_blk_t;
 
 void __kmp_env_blk_init(kmp_env_blk_t *block, char const *bulk);
 void __kmp_env_blk_free(kmp_env_blk_t *block);
 void __kmp_env_blk_sort(kmp_env_blk_t *block);
 char const *__kmp_env_blk_var(kmp_env_blk_t *block, char const *name);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // KMP_ENVIRONMENT_H
 
 // end of file //

openmp/trunk/runtime/src/kmp_error.cpp

static void __kmp_expand_cons_stack(int gtid, struct cons_header *p) {
 
   for (i = p->stack_top; i >= 0; --i)
     p->stack_data[i] = d[i];
 
   /* NOTE: we do not free the old stack_data */
 }
 
 // NOTE: Function returns allocated memory, caller must free it!
-static char const *__kmp_pragma(int ct, ident_t const *ident) {
+static char *__kmp_pragma(int ct, ident_t const *ident) {
   char const *cons = NULL; // Construct name.
   char *file = NULL; // File name.
   char *func = NULL; // Function (routine) name.
   char *line = NULL; // Line number.
   kmp_str_buf_t buffer;
   kmp_msg_t prgm;
   __kmp_str_buf_init(&buffer);
   if (0 < ct && ct < cons_text_c_num) {

 } // __kmp_pragma
 
 /* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */
 
 void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier.
                            enum cons_type ct, // Construct type.
                            ident_t const *ident // Construct ident.
                            ) {
-  char const *construct = __kmp_pragma(ct, ident);
+  char *construct = __kmp_pragma(ct, ident);
   __kmp_fatal(__kmp_msg_format(id, construct), __kmp_msg_null);
-  KMP_INTERNAL_FREE(CCAST(char *, construct));
+  KMP_INTERNAL_FREE(construct);
 }
 
 void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier.
                             enum cons_type ct, // First construct type.
                             ident_t const *ident, // First construct ident.
                             struct cons_data const *cons // Second construct.
                             ) {
-  char const *construct1 = __kmp_pragma(ct, ident);
-  char const *construct2 = __kmp_pragma(cons->type, cons->ident);
+  char *construct1 = __kmp_pragma(ct, ident);
+  char *construct2 = __kmp_pragma(cons->type, cons->ident);
   __kmp_fatal(__kmp_msg_format(id, construct1, construct2), __kmp_msg_null);
-  KMP_INTERNAL_FREE(CCAST(char *, construct1));
-  KMP_INTERNAL_FREE(CCAST(char *, construct2));
+  KMP_INTERNAL_FREE(construct1);
+  KMP_INTERNAL_FREE(construct2);
 }
 
 struct cons_header *__kmp_allocate_cons_stack(int gtid) {
   struct cons_header *p;
 
   /* TODO for monitor perhaps? */
   if (gtid < 0) {
     __kmp_check_null_func();

openmp/trunk/runtime/src/kmp_global.cpp

 int __kmp_affinity_offset = 0;
 int __kmp_affinity_verbose = FALSE;
 int __kmp_affinity_warnings = TRUE;
 int __kmp_affinity_respect_mask = affinity_respect_mask_default;
 char *__kmp_affinity_proclist = NULL;
 kmp_affin_mask_t *__kmp_affinity_masks = NULL;
 unsigned __kmp_affinity_num_masks = 0;
 
-char const *__kmp_cpuinfo_file = NULL;
+char *__kmp_cpuinfo_file = NULL;
 
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 #if OMP_40_ENABLED
 kmp_nested_proc_bind_t __kmp_nested_proc_bind = {NULL, 0, 0};
 int __kmp_affinity_num_places = 0;
 #endif
 

 #endif
 
 kmp_tasking_mode_t __kmp_tasking_mode = tskm_task_teams;
 #if OMP_45_ENABLED
 kmp_int32 __kmp_max_task_priority = 0;
 kmp_uint64 __kmp_taskloop_min_tasks = 0;
 #endif
 
-#if OMP_50_ENABLED && OMPT_SUPPORT
-char const *__kmp_tool_libraries = NULL;
-#endif
-
 /* This check ensures that the compiler is passing the correct data type for the
    flags formal parameter of the function kmpc_omp_task_alloc(). If the type is
    not a 4-byte type, then give an error message about a non-positive length
    array pointing here.  If that happens, the kmp_tasking_flags_t structure must
    be redefined to have exactly 32 bits. */
 KMP_BUILD_ASSERT(sizeof(kmp_tasking_flags_t) == 4);
 
 kmp_int32 __kmp_task_stealing_constraint =

openmp/trunk/runtime/src/kmp_i18n.h

enum kmp_msg_type {
   kmp_mt_hint = 5, // Hint to the user.
   kmp_mt_syserr = -1 // System error message.
 }; // enum kmp_msg_type
 typedef enum kmp_msg_type kmp_msg_type_t;
 
 struct kmp_msg {
   kmp_msg_type_t type;
   int num;
-  char const *str;
+  char *str;
   int len;
 }; // struct kmp_message
 typedef struct kmp_msg kmp_msg_t;
 
-// Two special messages.
-extern kmp_msg_t __kmp_msg_empty; // Can be used in place where message is
-// required syntactically.
-extern kmp_msg_t
-    __kmp_msg_null; // Denotes the end of variadic list of arguments.
+// Special message to denote the end of variadic list of arguments.
+extern kmp_msg_t __kmp_msg_null;
 
 // Helper functions. Creates messages either from message catalog or from
 // system. Note: these functions allocate memory. You should pass created
 // messages to __kmp_msg() function, it will print messages and destroy them.
 kmp_msg_t __kmp_msg_format(unsigned id_arg, ...);
 kmp_msg_t __kmp_msg_error_code(int code);
 kmp_msg_t __kmp_msg_error_mesg(char const *mesg);
 

openmp/trunk/runtime/src/kmp_i18n.cpp

 #include "kmp_i18n_default.inc"
 #include "kmp_str.h"
 
 #undef KMP_I18N_OK
 
 #define get_section(id) ((id) >> 16)
 #define get_number(id) ((id)&0xFFFF)
 
-kmp_msg_t __kmp_msg_empty = {kmp_mt_dummy, 0, "", 0};
 kmp_msg_t __kmp_msg_null = {kmp_mt_dummy, 0, NULL, 0};
 static char const *no_message_available = "(No message available)";
 
 static void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message,
                       va_list ap);
 
 enum kmp_i18n_cat_status {
   KMP_I18N_CLOSED, // Not yet opened or closed.
void __kmp_msg(kmp_msg_severity_t severity, kmp_msg_t message, va_list args) {
   __kmp_str_free(&fmsg.str);
 
   // Format other messages.
   for (;;) {
     message = va_arg(args, kmp_msg_t);
     if (message.type == kmp_mt_dummy && message.str == NULL) {
       break;
     }
-    if (message.type == kmp_mt_dummy && message.str == __kmp_msg_empty.str) {
-      continue;
-    }
     switch (message.type) {
     case kmp_mt_hint: {
       format = kmp_i18n_fmt_Hint;
     } break;
     case kmp_mt_syserr: {
       format = kmp_i18n_fmt_SysErr;
     } break;
     default: { KMP_DEBUG_ASSERT(0); }

openmp/trunk/runtime/src/kmp_itt.inl

if (loc->reserved_2 == 0) {
         // loc->reserved_2 field but put region index to the low two bytes and
         // barrier indexes to the high two bytes. It is OK because
         // KMP_MAX_FRAME_DOMAINS = 512.
         loc->reserved_2 |= (frm + 1); // save "new" value
 
         // Transform compiler-generated region location into the format
         // that the tools more or less standardized on:
         //   "<func>$omp$parallel@[file:]<line>[:<col>]"
-        const char *buff = NULL;
+        char *buff = NULL;
         kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
         buff = __kmp_str_format("%s$omp$parallel:%d@%s:%d:%d", str_loc.func,
                                 team_size, str_loc.file, str_loc.line,
                                 str_loc.col);
 
         __itt_suppress_push(__itt_suppress_memory_errors);
         __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
         __itt_suppress_pop();
 
         __kmp_str_free(&buff);
         if (barriers) {
           if (__kmp_barrier_domain_count < KMP_MAX_FRAME_DOMAINS) {
             int frm = KMP_TEST_THEN_INC32(
                 &__kmp_barrier_domain_count); // get "old" value
             if (frm >= KMP_MAX_FRAME_DOMAINS) {
               KMP_TEST_THEN_DEC32(
                   &__kmp_barrier_domain_count); // revert the count
               return; // loc->reserved_2 is still 0
             }
-            const char *buff = NULL;
+            char *buff = NULL;
             buff = __kmp_str_format("%s$omp$barrier@%s:%d", str_loc.func,
                                     str_loc.file, str_loc.col);
             __itt_suppress_push(__itt_suppress_memory_errors);
             __kmp_itt_barrier_domains[frm] = __itt_domain_create(buff);
             __itt_suppress_pop();
             __kmp_str_free(&buff);
             // Save the barrier frame index to the high two bytes.
             loc->reserved_2 |= (frm + 1) << 16;
           }
         }
         __kmp_str_loc_free(&str_loc);
         __itt_frame_begin_v3(__kmp_itt_region_domains[frm], NULL);
       }
     } else { // Region domain exists for this location
       // Check if team size was changed. Then create new region domain for this
       // location
       unsigned int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
       if ((frm < KMP_MAX_FRAME_DOMAINS) &&
           (__kmp_itt_region_team_size[frm] != team_size)) {
-        const char *buff = NULL;
+        char *buff = NULL;
         kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
         buff = __kmp_str_format("%s$omp$parallel:%d@%s:%d:%d", str_loc.func,
                                 team_size, str_loc.file, str_loc.line,
                                 str_loc.col);
 
         __itt_suppress_push(__itt_suppress_memory_errors);
         __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
         __itt_suppress_pop();
if ((loc->reserved_2 & 0x0000FFFF) == 0) {
         // loc->reserved_2 field but put region index to the low two bytes and
         // barrier indexes to the high two bytes. It is OK because
         // KMP_MAX_FRAME_DOMAINS = 512.
         loc->reserved_2 |= (frm + 1); // save "new" value
 
         // Transform compiler-generated region location into the format
         // that the tools more or less standardized on:
         //   "<func>$omp$parallel:team_size@[file:]<line>[:<col>]"
-        const char *buff = NULL;
+        char *buff = NULL;
         kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
         buff = __kmp_str_format("%s$omp$parallel:%d@%s:%d:%d", str_loc.func,
                                 team_size, str_loc.file, str_loc.line,
                                 str_loc.col);
 
         __itt_suppress_push(__itt_suppress_memory_errors);
         __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
         __itt_suppress_pop();
 
         __kmp_str_free(&buff);
         __kmp_str_loc_free(&str_loc);
         __kmp_itt_region_team_size[frm] = team_size;
         __itt_frame_submit_v3(__kmp_itt_region_domains[frm], NULL, begin, end);
       }
     } else { // Region domain exists for this location
       // Check if team size was changed. Then create new region domain for this
       // location
       unsigned int frm = (loc->reserved_2 & 0x0000FFFF) - 1;
       if ((frm < KMP_MAX_FRAME_DOMAINS) &&
           (__kmp_itt_region_team_size[frm] != team_size)) {
-        const char *buff = NULL;
+        char *buff = NULL;
         kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
         buff = __kmp_str_format("%s$omp$parallel:%d@%s:%d:%d", str_loc.func,
                                 team_size, str_loc.file, str_loc.line,
                                 str_loc.col);
 
         __itt_suppress_push(__itt_suppress_memory_errors);
         __kmp_itt_region_domains[frm] = __itt_domain_create(buff);
         __itt_suppress_pop();
if (loc) {
           // Save the barrier frame index to the high two bytes.
           loc->reserved_2 |= (frm + 1) << 16; // save "new" value
 
           // Transform compiler-generated region location into the format
           // that the tools more or less standardized on:
           //   "<func>$omp$frame@[file:]<line>[:<col>]"
           kmp_str_loc_t str_loc = __kmp_str_loc_init(loc->psource, 1);
           if (imbalance) {
-            const char *buff_imb = NULL;
+            char *buff_imb = NULL;
             buff_imb = __kmp_str_format("%s$omp$barrier-imbalance:%d@%s:%d",
                                         str_loc.func, team_size, str_loc.file,
                                         str_loc.col);
             __itt_suppress_push(__itt_suppress_memory_errors);
             __kmp_itt_imbalance_domains[frm] = __itt_domain_create(buff_imb);
             __itt_suppress_pop();
             __itt_frame_submit_v3(__kmp_itt_imbalance_domains[frm], NULL, begin,
                                   end);
             __kmp_str_free(&buff_imb);
           } else {
-            const char *buff = NULL;
+            char *buff = NULL;
             buff = __kmp_str_format("%s$omp$barrier@%s:%d", str_loc.func,
                                     str_loc.file, str_loc.col);
             __itt_suppress_push(__itt_suppress_memory_errors);
             __kmp_itt_barrier_domains[frm] = __itt_domain_create(buff);
             __itt_suppress_pop();
             __itt_frame_submit_v3(__kmp_itt_barrier_domains[frm], NULL, begin,
                                   end);
             __kmp_str_free(&buff);

openmp/trunk/runtime/src/kmp_sched.cpp

if (ompt_enabled.enabled) {
     }
   }
 #endif
 
   KMP_DEBUG_ASSERT(plastiter && plower && pupper && pstride);
   KE_TRACE(10, ("__kmpc_for_static_init called (%d)\n", global_tid));
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format(
         "__kmpc_for_static_init: T#%%d sched=%%d liter=%%d iter=(%%%s,"
         " %%%s, %%%s) incr=%%%s chunk=%%%s signed?<%s>\n",
         traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec,
         traits_t<ST>::spec, traits_t<ST>::spec, traits_t<T>::spec);
     KD_TRACE(100, (buff, global_tid, schedtype, *plastiter, *plower, *pupper,
                    *pstride, incr, chunk));
if (incr > 0 ? (*pupper < *plower) : (*plower < *pupper)) {
     /* leave pupper and plower set to entire iteration space */
     *pstride = incr; /* value should never be used */
 // *plower = *pupper - incr;
 // let compiler bypass the illegal loop (like for(i=1;i<10;i--))
 // THE LINE COMMENTED ABOVE CAUSED shape2F/h_tests_1.f TO HAVE A FAILURE
 // ON A ZERO-TRIP LOOP (lower=1, upper=0,stride=1) - JPH June 23, 2009.
 #ifdef KMP_DEBUG
     {
-      const char *buff;
+      char *buff;
       // create format specifiers before the debug output
       buff = __kmp_str_format("__kmpc_for_static_init:(ZERO TRIP) liter=%%d "
                               "lower=%%%s upper=%%%s stride = %%%s "
                               "signed?<%s>, loc = %%s\n",
                               traits_t<T>::spec, traits_t<T>::spec,
                               traits_t<ST>::spec, traits_t<T>::spec);
       KD_TRACE(100,
                (buff, *plastiter, *plower, *pupper, *pstride, loc->psource));
if (team->t.t_serialized) {
     if (plastiter != NULL)
       *plastiter = TRUE;
     /* leave pupper and plower set to entire iteration space */
     *pstride =
         (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
 
 #ifdef KMP_DEBUG
     {
-      const char *buff;
+      char *buff;
       // create format specifiers before the debug output
       buff = __kmp_str_format("__kmpc_for_static_init: (serial) liter=%%d "
                               "lower=%%%s upper=%%%s stride = %%%s\n",
                               traits_t<T>::spec, traits_t<T>::spec,
                               traits_t<ST>::spec);
       KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
       __kmp_str_free(&buff);
     }
#endif
   nth = team->t.t_nproc;
   if (nth == 1) {
     if (plastiter != NULL)
       *plastiter = TRUE;
     *pstride =
         (incr > 0) ? (*pupper - *plower + 1) : (-(*plower - *pupper + 1));
 #ifdef KMP_DEBUG
     {
-      const char *buff;
+      char *buff;
       // create format specifiers before the debug output
       buff = __kmp_str_format("__kmpc_for_static_init: (serial) liter=%%d "
                               "lower=%%%s upper=%%%s stride = %%%s\n",
                               traits_t<T>::spec, traits_t<T>::spec,
                               traits_t<ST>::spec);
       KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
       __kmp_str_free(&buff);
     }
if (schedtype == kmp_sch_static) {
       cur_chunk = trip_count / nth + ((trip_count % nth) ? 1 : 0);
     }
     // 0 - "static" schedule
     __kmp_itt_metadata_loop(loc, 0, trip_count, cur_chunk);
   }
 #endif
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmpc_for_static_init: liter=%%d lower=%%%s "
                             "upper=%%%s stride = %%%s signed?<%s>\n",
                             traits_t<T>::spec, traits_t<T>::spec,
                             traits_t<ST>::spec, traits_t<T>::spec);
     KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pstride));
     __kmp_str_free(&buff);
   }
static void __kmp_dist_for_static_init(ident_t *loc, kmp_int32 gtid,
   UT trip_count;
   kmp_team_t *team;
   kmp_info_t *th;
 
   KMP_DEBUG_ASSERT(plastiter && plower && pupper && pupperDist && pstride);
   KE_TRACE(10, ("__kmpc_dist_for_static_init called (%d)\n", gtid));
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format(
         "__kmpc_dist_for_static_init: T#%%d schedLoop=%%d liter=%%d "
         "iter=(%%%s, %%%s, %%%s) chunk=%%%s signed?<%s>\n",
         traits_t<T>::spec, traits_t<T>::spec, traits_t<ST>::spec,
         traits_t<ST>::spec, traits_t<T>::spec);
     KD_TRACE(100,
              (buff, gtid, schedule, *plastiter, *plower, *pupper, incr, chunk));
default:
       KMP_ASSERT2(0,
                   "__kmpc_dist_for_static_init: unknown loop scheduling type");
       break;
     }
   }
 end:;
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format(
         "__kmpc_dist_for_static_init: last=%%d lo=%%%s up=%%%s upDist=%%%s "
         "stride=%%%s signed?<%s>\n",
         traits_t<T>::spec, traits_t<T>::spec, traits_t<T>::spec,
         traits_t<ST>::spec, traits_t<T>::spec);
     KD_TRACE(100, (buff, *plastiter, *plower, *pupper, *pupperDist, *pstride));
     __kmp_str_free(&buff);
static void __kmp_team_static_init(ident_t *loc, kmp_int32 gtid,
   ST span;
   kmp_team_t *team;
   kmp_info_t *th;
 
   KMP_DEBUG_ASSERT(p_last && p_lb && p_ub && p_st);
   KE_TRACE(10, ("__kmp_team_static_init called (%d)\n", gtid));
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmp_team_static_init enter: T#%%d liter=%%d "
                             "iter=(%%%s, %%%s, %%%s) chunk %%%s; signed?<%s>\n",
                             traits_t<T>::spec, traits_t<T>::spec,
                             traits_t<ST>::spec, traits_t<ST>::spec,
                             traits_t<T>::spec);
     KD_TRACE(100, (buff, gtid, *p_last, *p_lb, *p_ub, *p_st, chunk));
     __kmp_str_free(&buff);
#endif
   } else { // incr < 0
     if (*p_ub > *p_lb)
       *p_ub = traits_t<T>::min_value;
     if (*p_ub < upper)
       *p_ub = upper; // tracker C73258
   }
 #ifdef KMP_DEBUG
   {
-    const char *buff;
+    char *buff;
     // create format specifiers before the debug output
     buff =
         __kmp_str_format("__kmp_team_static_init exit: T#%%d team%%u liter=%%d "
                          "iter=(%%%s, %%%s, %%%s) chunk %%%s\n",
                          traits_t<T>::spec, traits_t<T>::spec,
                          traits_t<ST>::spec, traits_t<ST>::spec);
     KD_TRACE(100, (buff, gtid, team_id, *p_last, *p_lb, *p_ub, *p_st, chunk));
     __kmp_str_free(&buff);

openmp/trunk/runtime/src/kmp_settings.cpp

if (msg != NULL) {
       KMP_WARNING(ParseSizeIntWarn, name, value, msg);
       KMP_INFORM(Using_str_Value, name, buf.str);
       __kmp_str_buf_free(&buf);
     }
   }
 } // __kmp_stg_parse_size
 
 static void __kmp_stg_parse_str(char const *name, char const *value,
-                                char const **out) {
+                                char **out) {
   __kmp_str_free(out);
   *out = __kmp_str_format("%s", value);
 } // __kmp_stg_parse_str
 
 static void __kmp_stg_parse_int(
     char const
         *name, // I: Name of environment variable (used in warning messages).
     char const *value, // I: Value of environment variable to parse.

 #undef EMIT_WARN
 #undef _set_param
 #undef set_type
 #undef set_verbose
 #undef set_warnings
 #undef set_respect
 #undef set_granularity
 
-  __kmp_str_free(CCAST(const char **, &buffer));
+  __kmp_str_free(&buffer);
 
   if (proclist) {
     if (!type) {
       KMP_WARNING(AffProcListNoType, name);
       *out_type = affinity_explicit;
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
static void __kmp_stg_print_omp_cancellation(kmp_str_buf_t *buffer,
                                              char const *name, void *data) {
   __kmp_stg_print_bool(buffer, name, __kmp_omp_cancellation);
 } // __kmp_stg_print_omp_cancellation
 
 #endif
 
 #if OMP_50_ENABLED && OMPT_SUPPORT
 
+static char *__kmp_tool_libraries = NULL;
+
 static void __kmp_stg_parse_omp_tool_libraries(char const *name,
                                                char const *value, void *data) {
   __kmp_stg_parse_str(name, value, &__kmp_tool_libraries);
 } // __kmp_stg_parse_omp_tool_libraries
 
 static void __kmp_stg_print_omp_tool_libraries(kmp_str_buf_t *buffer,
                                                char const *name, void *data) {
   if (__kmp_tool_libraries)

openmp/trunk/runtime/src/kmp_str.h

struct kmp_str_loc {
   int col;
 }; // struct kmp_str_loc
 typedef struct kmp_str_loc kmp_str_loc_t;
 kmp_str_loc_t __kmp_str_loc_init(char const *psource, int init_fname);
 void __kmp_str_loc_free(kmp_str_loc_t *loc);
 
 int __kmp_str_eqf(char const *lhs, char const *rhs);
 char *__kmp_str_format(char const *format, ...);
-void __kmp_str_free(char const **str);
+void __kmp_str_free(char **str);
 int __kmp_str_match(char const *target, int len, char const *data);
 int __kmp_str_match_false(char const *data);
 int __kmp_str_match_true(char const *data);
 void __kmp_str_replace(char *str, char search_for, char replace_with);
 void __kmp_str_split(char *str, char delim, char **head, char **tail);
 char *__kmp_str_token(char *str, char const *delim, char **buf);
 int __kmp_str_to_int(char const *str, char sentinel);
 

openmp/trunk/runtime/src/kmp_str.cpp

if (path != NULL) {
     base = (slash == NULL ? fname->dir : slash + 1);
     fname->base = __kmp_str_format("%s", base); // Copy basename
     *base = 0; // and truncate dir.
   }
 
 } // kmp_str_fname_init
 
 void __kmp_str_fname_free(kmp_str_fname_t *fname) {
-  __kmp_str_free(CCAST(char const **, &fname->path));
-  __kmp_str_free(CCAST(char const **, &fname->dir));
-  __kmp_str_free(CCAST(char const **, &fname->base));
+  __kmp_str_free(&fname->path);
+  __kmp_str_free(&fname->dir);
+  __kmp_str_free(&fname->base);
 } // kmp_str_fname_free
 
 int __kmp_str_fname_match(kmp_str_fname_t const *fname, char const *pattern) {
   int dir_match = 1;
   int base_match = 1;
 
   if (pattern != NULL) {
     kmp_str_fname_t ptrn;
kmp_str_loc_t __kmp_str_loc_init(char const *psource, int init_fname) {
 
   __kmp_str_fname_init(&loc.fname, init_fname ? loc.file : NULL);
 
   return loc;
 } // kmp_str_loc_init
 
 void __kmp_str_loc_free(kmp_str_loc_t *loc) {
   __kmp_str_fname_free(&loc->fname);
-  __kmp_str_free(CCAST(const char **, &(loc->_bulk)));
+  __kmp_str_free(&(loc->_bulk));
   loc->file = NULL;
   loc->func = NULL;
 } // kmp_str_loc_free
 
 /* This function is intended to compare file names. On Windows* OS file names
    are case-insensitive, so functions performs case-insensitive comparison. On
    Linux* OS it performs case-sensitive comparison. Note: The function returns
    *true* if strings are *equal*. */
for (;;) {
     if (buffer == NULL) {
       KMP_FATAL(MemoryAllocFailed);
     }
   }
 
   return buffer;
 } // func __kmp_str_format
 
-void __kmp_str_free(char const **str) {
+void __kmp_str_free(char **str) {
   KMP_DEBUG_ASSERT(str != NULL);
-  KMP_INTERNAL_FREE(CCAST(char *, *str));
+  KMP_INTERNAL_FREE(*str);
   *str = NULL;
 } // func __kmp_str_free
 
 /* If len is zero, returns true iff target and data have exact case-insensitive
    match. If len is negative, returns true iff target is a case-insensitive
    substring of data. If len is positive, returns true iff target is a
    case-insensitive substring of data or vice versa, and neither is shorter than
    len. */

openmp/trunk/runtime/src/ompt-general.cpp

#endif
 
   // Try in the current address space
   if ((ret = ompt_start_tool(omp_version, runtime_version)))
     return ret;
 
   // Try tool-libraries-var ICV
   const char *tool_libs = getenv("OMP_TOOL_LIBRARIES");
   if (tool_libs) {
-    const char *libs = __kmp_str_format("%s", tool_libs);
+    char *libs = __kmp_str_format("%s", tool_libs);
     char *buf;
-    char *fname = __kmp_str_token(CCAST(char *, libs), sep, &buf);
+    char *fname = __kmp_str_token(libs, sep, &buf);
     while (fname) {
 #if KMP_OS_UNIX
       void *h = dlopen(fname, RTLD_LAZY);
       if (h) {
         start_tool = (ompt_start_tool_t)dlsym(h, "ompt_start_tool");
 #elif KMP_OS_WINDOWS
       HMODULE h = LoadLibrary(fname);
       if (h) {