OSDN Git Service

gcc/
[pf3gnuchains/gcc-fork.git] / gcc / fortran / gfortranspec.c
1 /* Specific flags and argument handling of the Fortran front-end.
2    Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3    2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /* This file is copied more or less verbatim from g77.  */
23 /* This file contains a filter for the main `gcc' driver, which is
24    replicated for the `gfortran' driver by adding this filter.  The purpose
25    of this filter is to be basically identical to gcc (in that
26    it faithfully passes all of the original arguments to gcc) but,
27    unless explicitly overridden by the user in certain ways, ensure
28    that the needs of the language supported by this wrapper are met.
29
30    For GNU Fortran 95(gfortran), we do the following to the argument list
31    before passing it to `gcc':
32
33    1.  Make sure `-lgfortran -lm' is at the end of the list.
34
35    2.  Make sure each time `-lgfortran' or `-lm' is seen, it forms
36        part of the series `-lgfortran -lm'.
37
38    #1 and #2 are not done if `-nostdlib' or any option that disables
39    the linking phase is present, or if `-xfoo' is in effect.  Note that
40    a lack of source files or -l options disables linking.
41
42    This program was originally made out of gcc/cp/g++spec.c, but the
43    way it builds the new argument list was rewritten so it is much
44    easier to maintain, improve the way it decides to add or not add
45    extra arguments, etc.  And several improvements were made in the
46    handling of arguments, primarily to make it more consistent with
47    `gcc' itself.  */
48
49 #include "config.h"
50 #include "system.h"
51 #include "gcc.h"
52
53 #include "coretypes.h"
54 #include "tm.h"
55 #include "intl.h"
56
57 #ifndef MATH_LIBRARY
58 #define MATH_LIBRARY "-lm"
59 #endif
60
61 #ifndef FORTRAN_LIBRARY
62 #define FORTRAN_LIBRARY "-lgfortran"
63 #endif
64
65 #ifdef HAVE_LD_STATIC_DYNAMIC
66 #define ADD_ARG_LIBGFORTRAN(arg) \
67   { \
68     if (static_lib && !static_linking) \
69       append_arg ("-Wl,-Bstatic"); \
70     append_arg (arg); \
71     if (static_lib && !static_linking) \
72       append_arg ("-Wl,-Bdynamic"); \
73   }
74 #else
75 #define ADD_ARG_LIBGFORTRAN(arg) append_arg (arg);
76 #endif
77
78
79 /* Options this driver needs to recognize, not just know how to
80    skip over.  */
81 typedef enum
82 {
83   OPTION_b,                     /* Aka --prefix.  */
84   OPTION_B,                     /* Aka --target.  */
85   OPTION_c,                     /* Aka --compile.  */
86   OPTION_E,                     /* Aka --preprocess.  */
87   OPTION_help,                  /* --help.  */
88   OPTION_i,                     /* -imacros, -include, -include-*.  */
89   OPTION_l,
90   OPTION_L,                     /* Aka --library-directory.  */
91   OPTION_nostdlib,              /* Aka --no-standard-libraries, or
92                                    -nodefaultlibs.  */
93   OPTION_o,                     /* Aka --output.  */
94   OPTION_S,                     /* Aka --assemble.  */
95   OPTION_static,                /* -static.  */
96   OPTION_static_libgfortran,    /* -static-libgfortran.  */
97   OPTION_syntax_only,           /* -fsyntax-only.  */
98   OPTION_v,                     /* Aka --verbose.  */
99   OPTION_version,               /* --version.  */
100   OPTION_V,                     /* Aka --use-version.  */
101   OPTION_x,                     /* Aka --language.  */
102   OPTION_                       /* Unrecognized or unimportant.  */
103 }
104 Option;
105
106 /* The original argument list and related info is copied here.  */
107 static int g77_xargc;
108 static const char *const *g77_xargv;
109 static void lookup_option (Option *, int *, const char **, const char *);
110 static void append_arg (const char *);
111
112 /* The new argument list will be built here.  */
113 static int g77_newargc;
114 static const char **g77_newargv;
115
116 /* --- This comes from gcc.c (2.8.1) verbatim: */
117
118 /* This defines which switch letters take arguments.  */
119
120 #ifndef SWITCH_TAKES_ARG
121 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
122 #endif
123
124 /* This defines which multi-letter switches take arguments.  */
125
126 #ifndef WORD_SWITCH_TAKES_ARG
127 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
128 #endif
129
130 /* --- End of verbatim.  */
131
132 /* Assumes text[0] == '-'.  Returns number of argv items that belong to
133    (and follow) this one, an option id for options important to the
134    caller, and a pointer to the first char of the arg, if embedded (else
135    returns NULL, meaning no arg or it's the next argv).
136
137    Note that this also assumes gcc.c's pass converting long options
138    to short ones, where available, has already been run.  */
139
140 static void
141 lookup_option (Option *xopt, int *xskip, const char **xarg, const char *text)
142 {
143   Option opt = OPTION_;
144   int skip;
145   const char *arg = NULL;
146
147   if ((skip = SWITCH_TAKES_ARG (text[1])))
148     skip -= (text[2] != '\0');  /* See gcc.c.  */
149
150   if (text[1] == 'B')
151     opt = OPTION_B, skip = (text[2] == '\0'), arg = text + 2;
152   else if (text[1] == 'b')
153     opt = OPTION_b, skip = (text[2] == '\0'), arg = text + 2;
154   else if ((text[1] == 'c') && (text[2] == '\0'))
155     opt = OPTION_c, skip = 0;
156   else if ((text[1] == 'E') && (text[2] == '\0'))
157     opt = OPTION_E, skip = 0;
158   else if (text[1] == 'i')
159     opt = OPTION_i, skip = 0;
160   else if (text[1] == 'l')
161     opt = OPTION_l;
162   else if (text[1] == 'L')
163     opt = OPTION_L, arg = text + 2;
164   else if (text[1] == 'o')
165     opt = OPTION_o;
166   else if ((text[1] == 'S') && (text[2] == '\0'))
167     opt = OPTION_S, skip = 0;
168   else if (text[1] == 'V')
169     opt = OPTION_V, skip = (text[2] == '\0');
170   else if ((text[1] == 'v') && (text[2] == '\0'))
171     opt = OPTION_v, skip = 0;
172   else if (text[1] == 'x')
173     opt = OPTION_x, arg = text + 2;
174   else if (text[1] == 'J')
175     ;
176   else
177     {
178       if ((skip = WORD_SWITCH_TAKES_ARG (text + 1)) != 0)  /* See gcc.c.  */
179         ;
180       else if (!strcmp (text, "-fhelp"))        /* Really --help!! */
181         opt = OPTION_help;
182       else if (!strcmp (text, "-nostdlib")
183                || !strcmp (text, "-nodefaultlibs"))
184         opt = OPTION_nostdlib;
185       else if (!strcmp (text, "-fsyntax-only"))
186         opt = OPTION_syntax_only;
187       else if (!strcmp (text, "-static-libgfortran"))
188         opt = OPTION_static_libgfortran;
189       else if (!strcmp (text, "-static"))
190         opt = OPTION_static;
191       else if (!strcmp (text, "-fversion"))     /* Really --version!! */
192         opt = OPTION_version;
193       else if (!strcmp (text, "-Xlinker") || !strcmp (text, "-specs"))
194         skip = 1;
195       else
196         skip = 0;
197     }
198
199   if (xopt != NULL)
200     *xopt = opt;
201   if (xskip != NULL)
202     *xskip = skip;
203   if (xarg != NULL)
204     {
205       if ((arg != NULL) && (arg[0] == '\0'))
206         *xarg = NULL;
207       else
208         *xarg = arg;
209     }
210 }
211
212 /* Append another argument to the list being built.  As long as it is
213    identical to the corresponding arg in the original list, just increment
214    the new arg count.  Otherwise allocate a new list, etc.  */
215
216 static void
217 append_arg (const char *arg)
218 {
219   static int newargsize;
220
221 #if 0
222   fprintf (stderr, "`%s'\n", arg);
223 #endif
224
225   if (g77_newargv == g77_xargv
226       && g77_newargc < g77_xargc
227       && (arg == g77_xargv[g77_newargc]
228           || !strcmp (arg, g77_xargv[g77_newargc])))
229     {
230       ++g77_newargc;
231       return;                   /* Nothing new here.  */
232     }
233
234   if (g77_newargv == g77_xargv)
235     {                           /* Make new arglist.  */
236       int i;
237
238       newargsize = (g77_xargc << 2) + 20;       /* This should handle all.  */
239       g77_newargv = (const char **) xmalloc (newargsize * sizeof (char *));
240
241       /* Copy what has been done so far.  */
242       for (i = 0; i < g77_newargc; ++i)
243         g77_newargv[i] = g77_xargv[i];
244     }
245
246   if (g77_newargc == newargsize)
247     fatal ("overflowed output arg list for '%s'", arg);
248
249   g77_newargv[g77_newargc++] = arg;
250 }
251
252 void
253 lang_specific_driver (int *in_argc, const char *const **in_argv,
254                       int *in_added_libraries ATTRIBUTE_UNUSED)
255 {
256   int argc = *in_argc;
257   const char *const *argv = *in_argv;
258   int i;
259   int verbose = 0;
260   Option opt;
261   int skip;
262   const char *arg;
263
264   /* This will be NULL if we encounter a situation where we should not
265      link in libf2c.  */
266   const char *library = FORTRAN_LIBRARY;
267
268   /* 0 => -xnone in effect.
269      1 => -xfoo in effect.  */
270   int saw_speclang = 0;
271
272   /* 0 => initial/reset state
273      1 => last arg was -l<library>
274      2 => last two args were -l<library> -lm.  */
275   int saw_library = 0;
276
277   /* By default, we throw on the math library if we have one.  */
278   int need_math = (MATH_LIBRARY[0] != '\0');
279
280 #ifdef HAVE_LD_STATIC_DYNAMIC
281   /* Whether we should link a static libgfortran. */
282   int static_lib = 0; 
283
284   /* Whether we need to link statically.  */
285   int static_linking = 0;
286 #endif
287
288   /* The number of input and output files in the incoming arg list.  */
289   int n_infiles = 0;
290   int n_outfiles = 0;
291
292 #if 0
293   fprintf (stderr, "Incoming:");
294   for (i = 0; i < argc; i++)
295     fprintf (stderr, " %s", argv[i]);
296   fprintf (stderr, "\n");
297 #endif
298
299   g77_xargc = argc;
300   g77_xargv = argv;
301   g77_newargc = 0;
302   g77_newargv = CONST_CAST2 (const char **, const char *const *, argv);
303
304   /* First pass through arglist.
305
306      If -nostdlib or a "turn-off-linking" option is anywhere in the
307      command line, don't do any library-option processing (except
308      relating to -x).  Also, if -v is specified, but no other options
309      that do anything special (allowing -V version, etc.), remember
310      to add special stuff to make gcc command actually invoke all
311      the different phases of the compilation process so all the version
312      numbers can be seen.
313
314      Also, here is where all problems with missing arguments to options
315      are caught.  If this loop is exited normally, it means all options
316      have the appropriate number of arguments as far as the rest of this
317      program is concerned.  */
318
319   for (i = 1; i < argc; ++i)
320     {
321       if ((argv[i][0] == '+') && (argv[i][1] == 'e'))
322         {
323           continue;
324         }
325
326       if ((argv[i][0] != '-') || (argv[i][1] == '\0'))
327         {
328           ++n_infiles;
329           continue;
330         }
331
332       lookup_option (&opt, &skip, NULL, argv[i]);
333
334       switch (opt)
335         {
336         case OPTION_nostdlib:
337         case OPTION_c:
338         case OPTION_S:
339         case OPTION_syntax_only:
340         case OPTION_E:
341           /* These options disable linking entirely or linking of the
342              standard libraries.  */
343           library = 0;
344           break;
345
346         case OPTION_static_libgfortran:
347 #ifdef HAVE_LD_STATIC_DYNAMIC
348           static_lib = 1;
349 #endif
350           break;
351
352         case OPTION_static:
353 #ifdef HAVE_LD_STATIC_DYNAMIC
354           static_linking = 1;
355 #endif
356           /* Fall through, count OPTION_static as an item included in
357              the rewritten command line. */
358
359         case OPTION_l:
360           ++n_infiles;
361           break;
362
363         case OPTION_o:
364           ++n_outfiles;
365           break;
366
367         case OPTION_v:
368           verbose = 1;
369           break;
370
371         case OPTION_b:
372         case OPTION_B:
373         case OPTION_L:
374         case OPTION_i:
375         case OPTION_V:
376           /* These options are useful in conjunction with -v to get
377              appropriate version info.  */
378           break;
379
380         case OPTION_version:
381           printf ("GNU Fortran %s%s\n", pkgversion_string, version_string);
382           printf ("Copyright %s 2010 Free Software Foundation, Inc.\n\n",
383                   _("(C)"));
384           printf (_("GNU Fortran comes with NO WARRANTY, to the extent permitted by law.\n\
385 You may redistribute copies of GNU Fortran\n\
386 under the terms of the GNU General Public License.\n\
387 For more information about these matters, see the file named COPYING\n\n"));
388           exit (0);
389           break;
390
391         case OPTION_help:
392           /* Let gcc.c handle this, as it has a really
393              cool facility for handling --help and --verbose --help.  */
394           return;
395
396         default:
397           break;
398         }
399
400       /* This is the one place we check for missing arguments in the
401          program.  */
402
403       if (i + skip < argc)
404         i += skip;
405       else
406         fatal ("argument to '%s' missing", argv[i]);
407     }
408
409   if ((n_outfiles != 0) && (n_infiles == 0))
410     fatal ("no input files; unwilling to write output files");
411
412   /* If there are no input files, no need for the library.  */
413   if (n_infiles == 0)
414     library = 0;
415
416   /* Second pass through arglist, transforming arguments as appropriate.  */
417
418   append_arg (argv[0]);         /* Start with command name, of course.  */
419
420   for (i = 1; i < argc; ++i)
421     {
422       if (argv[i][0] == '\0')
423         {
424           append_arg (argv[i]); /* Interesting.  Just append as is.  */
425           continue;
426         }
427
428       if ((argv[i][0] == '-') && (argv[i][1] == 'M'))
429         {
430           char *p;
431
432           fprintf (stderr, _("Warning: Using -M <directory> is deprecated, "
433                    "use -J instead\n"));
434           if (argv[i][2] == '\0')
435             {
436               if (i+1 < argc)
437                 {
438                   p = XNEWVEC (char, strlen (argv[i + 1]) + 3);
439                   p[0] = '-';
440                   p[1] = 'J';
441                   strcpy (&p[2], argv[i + 1]);
442                   i++;
443                 }
444               else
445                 fatal ("argument to '%s' missing", argv[i]);
446             }
447           else
448             {
449               p = XNEWVEC (char, strlen (argv[i]) + 1);
450               p[0] = '-';
451               p[1] = 'J';
452               strcpy (&p[2], argv[i] + 2);
453             }
454           append_arg (p);
455           continue;
456         }
457
458       if ((argv[i][0] == '-') && (argv[i][1] != 'l'))
459         {
460           /* Not a filename or library.  */
461
462           if (saw_library == 1 && need_math)    /* -l<library>.  */
463             append_arg (MATH_LIBRARY);
464
465           saw_library = 0;
466
467           lookup_option (&opt, &skip, &arg, argv[i]);
468
469           if (argv[i][1] == '\0')
470             {
471               append_arg (argv[i]);     /* "-" == Standard input.  */
472               continue;
473             }
474
475           if (opt == OPTION_x)
476             {
477               /* Track input language.  */
478               const char *lang;
479
480               if (arg == NULL)
481                 lang = argv[i + 1];
482               else
483                 lang = arg;
484
485               saw_speclang = (strcmp (lang, "none") != 0);
486             }
487
488           append_arg (argv[i]);
489
490           for (; skip != 0; --skip)
491             append_arg (argv[++i]);
492
493           continue;
494         }
495
496       /* A filename/library, not an option.  */
497
498       if (saw_speclang)
499         saw_library = 0;        /* -xfoo currently active.  */
500       else
501         {                       /* -lfoo or filename.  */
502           if (strcmp (argv[i], MATH_LIBRARY) == 0)
503             {
504               if (saw_library == 1)
505                 saw_library = 2;        /* -l<library> -lm.  */
506               else
507                 {
508                   ADD_ARG_LIBGFORTRAN (FORTRAN_LIBRARY);
509                 }
510             }
511           else if (strcmp (argv[i], FORTRAN_LIBRARY) == 0)
512             {
513               saw_library = 1;  /* -l<library>.  */
514               ADD_ARG_LIBGFORTRAN (argv[i]);
515               continue;
516             }
517           else
518             {                   /* Other library, or filename.  */
519               if (saw_library == 1 && need_math)
520                 append_arg (MATH_LIBRARY);
521               saw_library = 0;
522             }
523         }
524       append_arg (argv[i]);
525     }
526
527   /* Append `-lg2c -lm' as necessary.  */
528
529   if (library)
530     {                           /* Doing a link and no -nostdlib.  */
531       if (saw_speclang)
532         append_arg ("-xnone");
533
534       switch (saw_library)
535         {
536         case 0:
537           ADD_ARG_LIBGFORTRAN (library);
538           /* Fall through.  */
539
540         case 1:
541           if (need_math)
542             append_arg (MATH_LIBRARY);
543         default:
544           break;
545         }
546     }
547
548 #ifdef ENABLE_SHARED_LIBGCC
549   if (library)
550     {
551       int i;
552
553       for (i = 1; i < g77_newargc; i++)
554         if (g77_newargv[i][0] == '-')
555           if (strcmp (g77_newargv[i], "-static-libgcc") == 0
556               || strcmp (g77_newargv[i], "-static") == 0)
557             break;
558
559       if (i == g77_newargc)
560         append_arg ("-shared-libgcc");
561     }
562
563 #endif
564
565   if (verbose && g77_newargv != g77_xargv)
566     {
567       fprintf (stderr, _("Driving:"));
568       for (i = 0; i < g77_newargc; i++)
569         fprintf (stderr, " %s", g77_newargv[i]);
570       fprintf (stderr, "\n");
571     }
572
573   *in_argc = g77_newargc;
574   *in_argv = g77_newargv;
575 }
576
577
578 /* Called before linking.  Returns 0 on success and -1 on failure.  */
579 int
580 lang_specific_pre_link (void)   /* Not used for F77.  */
581 {
582   return 0;
583 }
584
585 /* Number of extra output files that lang_specific_pre_link may generate.  */
586 int lang_specific_extra_outfiles = 0;   /* Not used for F77.  */