libgfortran/runtime/main.c

   1 /* Copyright (C) 2002-2014 Free Software Foundation, Inc.
   2    Contributed by Andy Vaught and Paul Brook <paul@nowt.org>
   3
   4 This file is part of the GNU Fortran runtime library (libgfortran).
   5
   6 Libgfortran is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 Libgfortran 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
  14 GNU General Public License for more details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "libgfortran.h"
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <limits.h>
  29 #include <errno.h>
  30
  31
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif
  35
  36 /* Stupid function to be sure the constructor is always linked in, even
  37    in the case of static linking.  See PR libfortran/22298 for details.  */
  38 void
  39 stupid_function_name_for_static_linking (void)
  40 {
  41   return;
  42 }
  43
  44 /* This will be 0 for little-endian
  45    machines and 1 for big-endian machines.  */
  46 int big_endian = 0;
  47
  48
  49 /* Figure out endianness for this machine.  */
  50
  51 static void
  52 determine_endianness (void)
  53 {
  54   union
  55   {
  56     GFC_LOGICAL_8 l8;
  57     GFC_LOGICAL_4 l4[2];
  58   } u;
  59
  60   u.l8 = 1;
  61   if (u.l4[0])
  62     big_endian = 0;
  63   else if (u.l4[1])
  64     big_endian = 1;
  65   else
  66     runtime_error ("Unable to determine machine endianness");
  67 }
  68
  69
  70 static int argc_save;
  71 static char **argv_save;
  72
  73 static const char *exe_path;
  74 static bool please_free_exe_path_when_done;
  75
  76 /* Save the path under which the program was called, for use in the
  77    backtrace routines.  */
  78 void
  79 store_exe_path (const char * argv0)
  80 {
  81 #ifndef DIR_SEPARATOR
  82 #define DIR_SEPARATOR '/'
  83 #endif
  84
  85   char *cwd, *path;
  86
  87   /* This can only happen if store_exe_path is called multiple times.  */
  88   if (please_free_exe_path_when_done)
  89     free ((char *) exe_path);
  90
  91   /* Reading the /proc/self/exe symlink is Linux-specific(?), but if
  92      it works it gives the correct answer.  */
  93 #ifdef HAVE_READLINK
  94   ssize_t len, psize = 256;
  95   while (1)
  96     {
  97       path = xmalloc (psize);
  98       len = readlink ("/proc/self/exe", path, psize);
  99       if (len < 0)
 100         {
 101           free (path);
 102           break;
 103         }
 104       else if (len < psize)
 105         {
 106           path[len] = '\0';
 107           exe_path = strdup (path);
 108           free (path);
 109           please_free_exe_path_when_done = true;
 110           return;
 111         }
 112       /* The remaining option is len == psize.  */
 113       free (path);
 114       psize *= 4;
 115     }
 116 #endif
 117
 118   /* If the path is absolute or on a simulator where argv is not set.  */
 119 #ifdef __MINGW32__
 120   if (argv0 == NULL
 121       || ('A' <= argv0[0] && argv0[0] <= 'Z' && argv0[1] == ':')
 122       || ('a' <= argv0[0] && argv0[0] <= 'z' && argv0[1] == ':')
 123       || (argv0[0] == '/' && argv0[1] == '/')
 124       || (argv0[0] == '\\' && argv0[1] == '\\'))
 125 #else
 126   if (argv0 == NULL || argv0[0] == DIR_SEPARATOR)
 127 #endif
 128     {
 129       exe_path = argv0;
 130       please_free_exe_path_when_done = false;
 131       return;
 132     }
 133
 134 #ifdef HAVE_GETCWD
 135   size_t cwdsize = 256;
 136   while (1)
 137     {
 138       cwd = xmalloc (cwdsize);
 139       if (getcwd (cwd, cwdsize))
 140         break;
 141       else if (errno == ERANGE)
 142         {
 143           free (cwd);
 144           cwdsize *= 4;
 145         }
 146       else
 147         {
 148           free (cwd);
 149           cwd = NULL;
 150           break;
 151         }
 152     }
 153 #else
 154   cwd = NULL;
 155 #endif
 156
 157   if (!cwd)
 158     {
 159       exe_path = argv0;
 160       please_free_exe_path_when_done = false;
 161       return;
 162     }
 163
 164   /* exe_path will be cwd + "/" + argv[0] + "\0".  This will not work
 165      if the executable is not in the cwd, but at this point we're out
 166      of better ideas.  */
 167   size_t pathlen = strlen (cwd) + 1 + strlen (argv0) + 1;
 168   path = xmalloc (pathlen);
 169   snprintf (path, pathlen, "%s%c%s", cwd, DIR_SEPARATOR, argv0);
 170   free (cwd);
 171   exe_path = path;
 172   please_free_exe_path_when_done = true;
 173 }
 174
 175
 176 /* Return the full path of the executable.  */
 177 char *
 178 full_exe_path (void)
 179 {
 180   return (char *) exe_path;
 181 }
 182
 183
 184 char *addr2line_path;
 185
 186 /* Find addr2line and store the path.  */
 187
 188 void
 189 find_addr2line (void)
 190 {
 191 #ifdef HAVE_ACCESS
 192 #define A2L_LEN 10
 193   char *path = secure_getenv ("PATH");
 194   if (!path)
 195     return;
 196   size_t n = strlen (path);
 197   char ap[n + 1 + A2L_LEN];
 198   size_t ai = 0;
 199   for (size_t i = 0; i < n; i++)
 200     {
 201       if (path[i] != ':')
 202         ap[ai++] = path[i];
 203       else
 204         {
 205           ap[ai++] = '/';
 206           memcpy (ap + ai, "addr2line", A2L_LEN);
 207           if (access (ap, R_OK|X_OK) == 0)
 208             {
 209               addr2line_path = strdup (ap);
 210               return;
 211             }
 212           else
 213             ai = 0;
 214         }
 215     }
 216 #endif
 217 }
 218
 219
 220 /* Set the saved values of the command line arguments.  */
 221
 222 void
 223 set_args (int argc, char **argv)
 224 {
 225   argc_save = argc;
 226   argv_save = argv;
 227   store_exe_path (argv[0]);
 228 }
 229 iexport(set_args);
 230
 231
 232 /* Retrieve the saved values of the command line arguments.  */
 233
 234 void
 235 get_args (int *argc, char ***argv)
 236 {
 237   *argc = argc_save;
 238   *argv = argv_save;
 239 }
 240
 241
 242 /* Initialize the runtime library.  */
 243
 244 static void __attribute__((constructor))
 245 init (void)
 246 {
 247   /* Figure out the machine endianness.  */
 248   determine_endianness ();
 249
 250   /* Must be first */
 251   init_variables ();
 252
 253   init_units ();
 254   set_fpu ();
 255   init_compile_options ();
 256
 257 #ifdef DEBUG
 258   /* Check for special command lines.  */
 259
 260   if (argc > 1 && strcmp (argv[1], "--help") == 0)
 261     show_variables ();
 262
 263   /* if (argc > 1 && strcmp(argv[1], "--resume") == 0) resume();  */
 264 #endif
 265
 266   if (options.backtrace == 1)
 267     find_addr2line ();
 268
 269   random_seed_i4 (NULL, NULL, NULL);
 270 }
 271
 272
 273 /* Cleanup the runtime library.  */
 274
 275 static void __attribute__((destructor))
 276 cleanup (void)
 277 {
 278   close_units ();
 279
 280   if (please_free_exe_path_when_done)
 281     free ((char *) exe_path);
 282
 283   free (addr2line_path);
 284 }