Replace __gconv_alias_db, __gconv_modules_db, and __gconv_cache with
[kopensolaris-gnu/glibc.git] / iconv / gconv_db.c
1 /* Provide access to the collection of available transformation modules.
2    Copyright (C) 1997,98,99,2000,2001 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <limits.h>
22 #include <search.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/param.h>
26 #include <bits/libc-lock.h>
27
28 #include <dlfcn.h>
29 #include <gconv_int.h>
30 #include <gconv_charset.h>
31
32
33 /* Simple data structure for alias mapping.  We have two names, `from'
34    and `to'.  */
35 void *__gconv_alias_db;
36
37 /* Array with available modules.  */
38 struct gconv_module *__gconv_modules_db;
39
40 /* We modify global data.   */
41 __libc_lock_define_initialized (static, lock)
42
43
44 /* Function for searching alias.  */
45 int
46 __gconv_alias_compare (const void *p1, const void *p2)
47 {
48   const struct gconv_alias *s1 = (const struct gconv_alias *) p1;
49   const struct gconv_alias *s2 = (const struct gconv_alias *) p2;
50   return strcmp (s1->fromname, s2->fromname);
51 }
52
53
54 /* To search for a derivation we create a list of intermediate steps.
55    Each element contains a pointer to the element which precedes it
56    in the derivation order.  */
57 struct derivation_step
58 {
59   const char *result_set;
60   size_t result_set_len;
61   int cost_lo;
62   int cost_hi;
63   struct gconv_module *code;
64   struct derivation_step *last;
65   struct derivation_step *next;
66 };
67
68 #define NEW_STEP(result, hi, lo, module, last_mod) \
69   ({ struct derivation_step *newp = alloca (sizeof (struct derivation_step)); \
70      newp->result_set = result;                                               \
71      newp->result_set_len = strlen (result);                                  \
72      newp->cost_hi = hi;                                                      \
73      newp->cost_lo = lo;                                                      \
74      newp->code = module;                                                     \
75      newp->last = last_mod;                                                   \
76      newp->next = NULL;                                                       \
77      newp; })
78
79
80 /* If a specific transformation is used more than once we should not need
81    to start looking for it again.  Instead cache each successful result.  */
82 struct known_derivation
83 {
84   const char *from;
85   const char *to;
86   struct __gconv_step *steps;
87   size_t nsteps;
88 };
89
90 /* Compare function for database of found derivations.  */
91 static int
92 derivation_compare (const void *p1, const void *p2)
93 {
94   const struct known_derivation *s1 = (const struct known_derivation *) p1;
95   const struct known_derivation *s2 = (const struct known_derivation *) p2;
96   int result;
97
98   result = strcmp (s1->from, s2->from);
99   if (result == 0)
100     result = strcmp (s1->to, s2->to);
101   return result;
102 }
103
104 /* The search tree for known derivations.  */
105 static void *known_derivations;
106
107 /* Look up whether given transformation was already requested before.  */
108 static int
109 internal_function
110 derivation_lookup (const char *fromset, const char *toset,
111                    struct __gconv_step **handle, size_t *nsteps)
112 {
113   struct known_derivation key = { fromset, toset, NULL, 0 };
114   struct known_derivation **result;
115
116   result = __tfind (&key, &known_derivations, derivation_compare);
117
118   if (result == NULL)
119     return __GCONV_NOCONV;
120
121   *handle = (*result)->steps;
122   *nsteps = (*result)->nsteps;
123
124   /* Please note that we return GCONV_OK even if the last search for
125      this transformation was unsuccessful.  */
126   return __GCONV_OK;
127 }
128
129 /* Add new derivation to list of known ones.  */
130 static void
131 internal_function
132 add_derivation (const char *fromset, const char *toset,
133                 struct __gconv_step *handle, size_t nsteps)
134 {
135   struct known_derivation *new_deriv;
136   size_t fromset_len = strlen (fromset) + 1;
137   size_t toset_len = strlen (toset) + 1;
138
139   new_deriv = (struct known_derivation *)
140     malloc (sizeof (struct known_derivation) + fromset_len + toset_len);
141   if (new_deriv != NULL)
142     {
143       new_deriv->from = (char *) (new_deriv + 1);
144       new_deriv->to = memcpy (__mempcpy (new_deriv + 1, fromset, fromset_len),
145                               toset, toset_len);
146
147       new_deriv->steps = handle;
148       new_deriv->nsteps = nsteps;
149
150       if (__tsearch (new_deriv, &known_derivations, derivation_compare)
151           == NULL)
152         /* There is some kind of memory allocation problem.  */
153         free (new_deriv);
154     }
155   /* Please note that we don't complain if the allocation failed.  This
156      is not tragically but in case we use the memory debugging facilities
157      not all memory will be freed.  */
158 }
159
160 static void
161 free_derivation (void *p)
162 {
163   struct known_derivation *deriv = (struct known_derivation *) p;
164   size_t cnt;
165
166   for (cnt = 0; cnt < deriv->nsteps; ++cnt)
167     if (deriv->steps[cnt].__counter > 0
168         && deriv->steps[cnt].__end_fct != NULL)
169       DL_CALL_FCT (deriv->steps[cnt].__end_fct, (&deriv->steps[cnt]));
170
171   /* Free the name strings.  */
172   free ((char *) deriv->steps[0].__from_name);
173   free ((char *) deriv->steps[deriv->nsteps - 1].__to_name);
174
175   free ((struct __gconv_step *) deriv->steps);
176   free (deriv);
177 }
178
179
180 /* Decrement the reference count for a single step in a steps array.  */
181 void
182 internal_function
183 __gconv_release_step (struct __gconv_step *step)
184 {
185   if (--step->__counter == 0)
186     {
187       /* Call the destructor.  */
188       if (step->__end_fct != NULL)
189         DL_CALL_FCT (step->__end_fct, (step));
190
191 #ifndef STATIC_GCONV
192       /* Skip builtin modules; they are not reference counted.  */
193       if (step->__shlib_handle != NULL)
194         {
195           /* Release the loaded module.  */
196           __gconv_release_shlib (step->__shlib_handle);
197           step->__shlib_handle = NULL;
198         }
199 #endif
200     }
201 }
202
203 static int
204 internal_function
205 gen_steps (struct derivation_step *best, const char *toset,
206            const char *fromset, struct __gconv_step **handle, size_t *nsteps)
207 {
208   size_t step_cnt = 0;
209   struct __gconv_step *result;
210   struct derivation_step *current;
211   int status = __GCONV_NOMEM;
212
213   /* First determine number of steps.  */
214   for (current = best; current->last != NULL; current = current->last)
215     ++step_cnt;
216
217   result = (struct __gconv_step *) malloc (sizeof (struct __gconv_step)
218                                            * step_cnt);
219   if (result != NULL)
220     {
221       int failed = 0;
222
223       status = __GCONV_OK;
224       *nsteps = step_cnt;
225       current = best;
226       while (step_cnt-- > 0)
227         {
228           result[step_cnt].__from_name = (step_cnt == 0
229                                           ? __strdup (fromset)
230                                           : (char *)current->last->result_set);
231           result[step_cnt].__to_name = (step_cnt + 1 == *nsteps
232                                         ? __strdup (current->result_set)
233                                         : result[step_cnt + 1].__from_name);
234
235           result[step_cnt].__counter = 1;
236           result[step_cnt].__data = NULL;
237
238 #ifndef STATIC_GCONV
239           if (current->code->module_name[0] == '/')
240             {
241               /* Load the module, return handle for it.  */
242               struct __gconv_loaded_object *shlib_handle =
243                 __gconv_find_shlib (current->code->module_name);
244
245               if (shlib_handle == NULL)
246                 {
247                   failed = 1;
248                   break;
249                 }
250
251               result[step_cnt].__shlib_handle = shlib_handle;
252               result[step_cnt].__modname = shlib_handle->name;
253               result[step_cnt].__fct = shlib_handle->fct;
254               result[step_cnt].__init_fct = shlib_handle->init_fct;
255               result[step_cnt].__end_fct = shlib_handle->end_fct;
256
257               /* Call the init function.  */
258               if (result[step_cnt].__init_fct != NULL)
259                 {
260                   status = DL_CALL_FCT (result[step_cnt].__init_fct,
261                                         (&result[step_cnt]));
262
263                   if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
264                     {
265                       failed = 1;
266                       /* Make sure we unload this modules.  */
267                       --step_cnt;
268                       result[step_cnt].__end_fct = NULL;
269                       break;
270                     }
271                 }
272             }
273           else
274 #endif
275             /* It's a builtin transformation.  */
276             __gconv_get_builtin_trans (current->code->module_name,
277                                        &result[step_cnt]);
278
279           current = current->last;
280         }
281
282       if (__builtin_expect (failed, 0) != 0)
283         {
284           /* Something went wrong while initializing the modules.  */
285           while (++step_cnt < *nsteps)
286             __gconv_release_step (&result[step_cnt]);
287           free (result);
288           *nsteps = 0;
289           *handle = NULL;
290           if (status == __GCONV_OK)
291             status = __GCONV_NOCONV;
292         }
293       else
294         *handle = result;
295     }
296   else
297     {
298       *nsteps = 0;
299       *handle = NULL;
300     }
301
302   return status;
303 }
304
305
306 #ifndef STATIC_GCONV
307 static int
308 internal_function
309 increment_counter (struct __gconv_step *steps, size_t nsteps)
310 {
311   /* Increment the user counter.  */
312   size_t cnt = nsteps;
313   int result = __GCONV_OK;
314
315   while (cnt-- > 0)
316     {
317       struct __gconv_step *step = &steps[cnt];
318
319       if (step->__counter++ == 0)
320         {
321           /* Skip builtin modules.  */
322           if (step->__modname != NULL)
323             {
324               /* Reopen a previously used module.  */
325               step->__shlib_handle = __gconv_find_shlib (step->__modname);
326               if (step->__shlib_handle == NULL)
327                 {
328                   /* Oops, this is the second time we use this module
329                      (after unloading) and this time loading failed!?  */
330                   --step->__counter;
331                   while (++cnt < nsteps)
332                     __gconv_release_step (&steps[cnt]);
333                   result = __GCONV_NOCONV;
334                   break;
335                 }
336
337               /* The function addresses defined by the module may
338                  have changed.  */
339               step->__fct = step->__shlib_handle->fct;
340               step->__init_fct = step->__shlib_handle->init_fct;
341               step->__end_fct = step->__shlib_handle->end_fct;
342             }
343
344           if (step->__init_fct != NULL)
345             DL_CALL_FCT (step->__init_fct, (step));
346         }
347     }
348   return result;
349 }
350 #endif
351
352
353 /* The main function: find a possible derivation from the `fromset' (either
354    the given name or the alias) to the `toset' (again with alias).  */
355 static int
356 internal_function
357 find_derivation (const char *toset, const char *toset_expand,
358                  const char *fromset, const char *fromset_expand,
359                  struct __gconv_step **handle, size_t *nsteps)
360 {
361   struct derivation_step *first, *current, **lastp, *solution = NULL;
362   int best_cost_hi = INT_MAX;
363   int best_cost_lo = INT_MAX;
364   int result;
365
366   /* Look whether an earlier call to `find_derivation' has already
367      computed a possible derivation.  If so, return it immediately.  */
368   result = derivation_lookup (fromset_expand ?: fromset, toset_expand ?: toset,
369                               handle, nsteps);
370   if (result == __GCONV_OK)
371     {
372 #ifndef STATIC_GCONV
373       result = increment_counter (*handle, *nsteps);
374 #endif
375       return result;
376     }
377
378   /* The task is to find a sequence of transformations, backed by the
379      existing modules - whether builtin or dynamically loadable -,
380      starting at `fromset' (or `fromset_expand') and ending at `toset'
381      (or `toset_expand'), and with minimal cost.
382
383      For computer scientists, this is a shortest path search in the
384      graph where the nodes are all possible charsets and the edges are
385      the transformations listed in __gconv_modules_db.
386
387      For now we use a simple algorithm with quadratic runtime behaviour.
388      A breadth-first search, starting at `fromset' and `fromset_expand'.
389      The list starting at `first' contains all nodes that have been
390      visited up to now, in the order in which they have been visited --
391      excluding the goal nodes `toset' and `toset_expand' which get
392      managed in the list starting at `solution'.
393      `current' walks through the list starting at `first' and looks
394      which nodes are reachable from the current node, adding them to
395      the end of the list [`first' or `solution' respectively] (if
396      they are visited the first time) or updating them in place (if
397      they have have already been visited).
398      In each node of either list, cost_lo and cost_hi contain the
399      minimum cost over any paths found up to now, starting at `fromset'
400      or `fromset_expand', ending at that node.  best_cost_lo and
401      best_cost_hi represent the minimum over the elements of the
402      `solution' list.  */
403
404   if (fromset_expand != NULL)
405     {
406       first = NEW_STEP (fromset_expand, 0, 0, NULL, NULL);
407       first->next = NEW_STEP (fromset, 0, 0, NULL, NULL);
408       lastp = &first->next->next;
409     }
410   else
411     {
412       first = NEW_STEP (fromset, 0, 0, NULL, NULL);
413       lastp = &first->next;
414     }
415
416   for (current = first; current != NULL; current = current->next)
417     {
418       /* Now match all the available module specifications against the
419          current charset name.  If any of them matches check whether
420          we already have a derivation for this charset.  If yes, use the
421          one with the lower costs.  Otherwise add the new charset at the
422          end.
423
424          The module database is organized in a tree form which allows
425          searching for prefixes.  So we search for the first entry with a
426          matching prefix and any other matching entry can be found from
427          this place.  */
428       struct gconv_module *node;
429
430       /* Maybe it is not necessary anymore to look for a solution for
431          this entry since the cost is already as high (or higher) as
432          the cost for the best solution so far.  */
433       if (current->cost_hi > best_cost_hi
434           || (current->cost_hi == best_cost_hi
435               && current->cost_lo >= best_cost_lo))
436         continue;
437
438       node = __gconv_modules_db;
439       while (node != NULL)
440         {
441           int cmpres = strcmp (current->result_set, node->from_string);
442           if (cmpres == 0)
443             {
444               /* Walk through the list of modules with this prefix and
445                  try to match the name.  */
446               struct gconv_module *runp;
447
448               /* Check all the modules with this prefix.  */
449               runp = node;
450               do
451                 {
452                   const char *result_set = (strcmp (runp->to_string, "-") == 0
453                                             ? (toset_expand ?: toset)
454                                             : runp->to_string);
455                   int cost_hi = runp->cost_hi + current->cost_hi;
456                   int cost_lo = runp->cost_lo + current->cost_lo;
457                   struct derivation_step *step;
458
459                   /* We managed to find a derivation.  First see whether
460                      we have reached one of the goal nodes.  */
461                   if (strcmp (result_set, toset) == 0
462                       || (toset_expand != NULL
463                           && strcmp (result_set, toset_expand) == 0))
464                     {
465                       /* Append to the `solution' list if there
466                          is no entry with this name.  */
467                       for (step = solution; step != NULL; step = step->next)
468                         if (strcmp (result_set, step->result_set) == 0)
469                           break;
470
471                       if (step == NULL)
472                         {
473                           step = NEW_STEP (result_set,
474                                            cost_hi, cost_lo,
475                                            runp, current);
476                           step->next = solution;
477                           solution = step;
478                         }
479                       else if (step->cost_hi > cost_hi
480                                || (step->cost_hi == cost_hi
481                                    && step->cost_lo > cost_lo))
482                         {
483                           /* A better path was found for the node,
484                              on the `solution' list.  */
485                           step->code = runp;
486                           step->last = current;
487                           step->cost_hi = cost_hi;
488                           step->cost_lo = cost_lo;
489                         }
490
491                       /* Update best_cost accordingly.  */
492                       if (cost_hi < best_cost_hi
493                           || (cost_hi == best_cost_hi
494                               && cost_lo < best_cost_lo))
495                         {
496                           best_cost_hi = cost_hi;
497                           best_cost_lo = cost_lo;
498                         }
499                     }
500                   else if (cost_hi < best_cost_hi
501                            || (cost_hi == best_cost_hi
502                                && cost_lo < best_cost_lo))
503                     {
504                       /* Append at the end of the `first' list if there
505                          is no entry with this name.  */
506                       for (step = first; step != NULL; step = step->next)
507                         if (strcmp (result_set, step->result_set) == 0)
508                           break;
509
510                       if (step == NULL)
511                         {
512                           *lastp = NEW_STEP (result_set,
513                                              cost_hi, cost_lo,
514                                              runp, current);
515                           lastp = &(*lastp)->next;
516                         }
517                       else if (step->cost_hi > cost_hi
518                                || (step->cost_hi == cost_hi
519                                    && step->cost_lo > cost_lo))
520                         {
521                           /* A better path was found for the node,
522                              on the `first' list.  */
523                           step->code = runp;
524                           step->last = current;
525
526                           /* Update the cost for all steps.  */
527                           for (step = first; step != NULL;
528                                step = step->next)
529                             /* But don't update the start nodes.  */
530                             if (step->code != NULL)
531                               {
532                                 struct derivation_step *back;
533                                 int hi, lo;
534
535                                 hi = step->code->cost_hi;
536                                 lo = step->code->cost_lo;
537
538                                 for (back = step->last; back->code != NULL;
539                                      back = back->last)
540                                   {
541                                     hi += back->code->cost_hi;
542                                     lo += back->code->cost_lo;
543                                   }
544
545                                 step->cost_hi = hi;
546                                 step->cost_lo = lo;
547                               }
548
549                           /* Likewise for the nodes on the solution list.
550                              Also update best_cost accordingly.  */
551                           for (step = solution; step != NULL;
552                                step = step->next)
553                             {
554                               step->cost_hi = (step->code->cost_hi
555                                                + step->last->cost_hi);
556                               step->cost_lo = (step->code->cost_lo
557                                                + step->last->cost_lo);
558
559                               if (step->cost_hi < best_cost_hi
560                                   || (step->cost_hi == best_cost_hi
561                                       && step->cost_lo < best_cost_lo))
562                                 {
563                                   best_cost_hi = step->cost_hi;
564                                   best_cost_lo = step->cost_lo;
565                                 }
566                             }
567                         }
568                     }
569
570                   runp = runp->same;
571                 }
572               while (runp != NULL);
573
574               break;
575             }
576           else if (cmpres < 0)
577             node = node->left;
578           else
579             node = node->right;
580         }
581     }
582
583   if (solution != NULL)
584     {
585       /* We really found a way to do the transformation.  */
586
587       /* Choose the best solution.  This is easy because we know that
588          the solution list has at most length 2 (one for every possible
589          goal node).  */
590       if (solution->next != NULL)
591         {
592           struct derivation_step *solution2 = solution->next;
593
594           if (solution2->cost_hi < solution->cost_hi
595               || (solution2->cost_hi == solution->cost_hi
596                   && solution2->cost_lo < solution->cost_lo))
597             solution = solution2;
598         }
599
600       /* Now build a data structure describing the transformation steps.  */
601       result = gen_steps (solution, toset_expand ?: toset,
602                           fromset_expand ?: fromset, handle, nsteps);
603     }
604   else
605     {
606       /* We haven't found a transformation.  Clear the result values.  */
607       *handle = NULL;
608       *nsteps = 0;
609     }
610
611   /* Add result in any case to list of known derivations.  */
612   add_derivation (fromset_expand ?: fromset, toset_expand ?: toset,
613                   *handle, *nsteps);
614
615   return result;
616 }
617
618
619 /* Control of initialization.  */
620 __libc_once_define (static, once);
621
622
623 static const char *
624 do_lookup_alias (const char *name)
625 {
626   struct gconv_alias key;
627   struct gconv_alias **found;
628
629   key.fromname = (char *) name;
630   found = __tfind (&key, &__gconv_alias_db, __gconv_alias_compare);
631   return found != NULL ? (*found)->toname : NULL;
632 }
633
634
635 int
636 internal_function
637 __gconv_compare_alias (const char *name1, const char *name2)
638 {
639   int result;
640
641   /* Ensure that the configuration data is read.  */
642   __libc_once (once, __gconv_read_conf);
643
644   if (__gconv_compare_alias_cache (name1, name2, &result) != 0)
645     result = strcmp (do_lookup_alias (name1) ?: name1,
646                      do_lookup_alias (name2) ?: name2);
647
648   return result;
649 }
650
651
652 int
653 internal_function
654 __gconv_find_transform (const char *toset, const char *fromset,
655                         struct __gconv_step **handle, size_t *nsteps,
656                         int flags)
657 {
658   const char *fromset_expand;
659   const char *toset_expand;
660   int result;
661
662   /* Ensure that the configuration data is read.  */
663   __libc_once (once, __gconv_read_conf);
664
665   /* Acquire the lock.  */
666   __libc_lock_lock (lock);
667
668   result = __gconv_lookup_cache (toset, fromset, handle, nsteps, flags);
669   if (result != __GCONV_NODB)
670     {
671       /* We have a cache and could resolve the request, successful or not.  */
672       __libc_lock_unlock (lock);
673       return result;
674     }
675
676   /* If we don't have a module database return with an error.  */
677   if (__gconv_modules_db == NULL)
678     {
679       __libc_lock_unlock (lock);
680       return __GCONV_NOCONV;
681     }
682
683   /* See whether the names are aliases.  */
684   fromset_expand = do_lookup_alias (fromset);
685   toset_expand = do_lookup_alias (toset);
686
687   if (__builtin_expect (flags & GCONV_AVOID_NOCONV, 0)
688       /* We are not supposed to create a pseudo transformation (means
689          copying) when the input and output character set are the same.  */
690       && (strcmp (toset, fromset) == 0
691           || (toset_expand != NULL && strcmp (toset_expand, fromset) == 0)
692           || (fromset_expand != NULL
693               && (strcmp (toset, fromset_expand) == 0
694                   || (toset_expand != NULL
695                       && strcmp (toset_expand, fromset_expand) == 0)))))
696     {
697       /* Both character sets are the same.  */
698       __libc_lock_unlock (lock);
699       return __GCONV_NOCONV;
700     }
701
702   result = find_derivation (toset, toset_expand, fromset, fromset_expand,
703                             handle, nsteps);
704
705   /* Release the lock.  */
706   __libc_lock_unlock (lock);
707
708   /* The following code is necessary since `find_derivation' will return
709      GCONV_OK even when no derivation was found but the same request
710      was processed before.  I.e., negative results will also be cached.  */
711   return (result == __GCONV_OK
712           ? (*handle == NULL ? __GCONV_NOCONV : __GCONV_OK)
713           : result);
714 }
715
716
717 /* Release the entries of the modules list.  */
718 int
719 internal_function
720 __gconv_close_transform (struct __gconv_step *steps, size_t nsteps)
721 {
722   int result = __GCONV_OK;
723   size_t cnt;
724
725   /* Acquire the lock.  */
726   __libc_lock_lock (lock);
727
728 #ifndef STATIC_GCONV
729   cnt = nsteps;
730   while (cnt-- > 0)
731     __gconv_release_step (&steps[cnt]);
732 #endif
733
734   /* If we use the cache we free a bit more since we don't keep any
735      transformation records around, they are cheap enough to
736      recreate.  */
737   __gconv_release_cache (steps, nsteps);
738
739   /* Release the lock.  */
740   __libc_lock_unlock (lock);
741
742   return result;
743 }
744
745
746 /* Free the modules mentioned.  */
747 static void
748 internal_function
749 free_modules_db (struct gconv_module *node)
750 {
751   if (node->left != NULL)
752     free_modules_db (node->left);
753   if (node->right != NULL)
754     free_modules_db (node->right);
755   do
756     {
757       struct gconv_module *act = node;
758       node = node->same;
759       if (act->module_name[0] == '/')
760         free (act);
761     }
762   while (node != NULL);
763 }
764
765
766 /* Free all resources if necessary.  */
767 static void __attribute__ ((unused))
768 free_mem (void)
769 {
770   if (__gconv_alias_db != NULL)
771     __tdestroy (__gconv_alias_db, free);
772
773   if (__gconv_modules_db != NULL)
774     free_modules_db (__gconv_modules_db);
775
776   if (known_derivations != NULL)
777     __tdestroy (known_derivations, free_derivation);
778 }
779
780 text_set_element (__libc_subfreeres, free_mem);