OSDN Git Service

PR other/46789
[pf3gnuchains/gcc-fork.git] / gcc / go / go-lang.c
1 /* go-lang.c -- Go frontend gcc interface.
2    Copyright (C) 2009, 2010 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19
20 #include "config.h"
21 #include "system.h"
22 #include "ansidecl.h"
23 #include "coretypes.h"
24 #include "opts.h"
25 #include "tree.h"
26 #include "gimple.h"
27 #include "ggc.h"
28 #include "toplev.h"
29 #include "debug.h"
30 #include "options.h"
31 #include "flags.h"
32 #include "convert.h"
33 #include "diagnostic.h"
34 #include "langhooks.h"
35 #include "langhooks-def.h"
36 #include "except.h"
37 #include "target.h"
38
39 #include <mpfr.h>
40
41 #include "go-c.h"
42
43 /* Language-dependent contents of a type.  */
44
45 struct GTY(()) lang_type
46 {
47   char dummy;
48 };
49
50 /* Language-dependent contents of a decl.  */
51
52 struct GTY(()) lang_decl
53 {
54   char dummy;
55 };
56
57 /* Language-dependent contents of an identifier.  This must include a
58    tree_identifier.  */
59
60 struct GTY(()) lang_identifier
61 {
62   struct tree_identifier common;
63 };
64
65 /* The resulting tree type.  */
66
67 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
68            chain_next ("(union lang_tree_node *) TREE_CHAIN (&%h.generic)")))
69 lang_tree_node
70 {
71   union tree_node GTY((tag ("0"),
72                        desc ("tree_node_structure (&%h)"))) generic;
73   struct lang_identifier GTY((tag ("1"))) identifier;
74 };
75
76 /* We don't use language_function.  */
77
78 struct GTY(()) language_function
79 {
80   int dummy;
81 };
82
83 /* Language hooks.  */
84
85 static bool
86 go_langhook_init (void)
87 {
88   build_common_tree_nodes (false);
89
90   /* The sizetype may be "unsigned long" or "unsigned long long".  */
91   if (TYPE_MODE (long_unsigned_type_node) == ptr_mode)
92     size_type_node = long_unsigned_type_node;
93   else if (TYPE_MODE (long_long_unsigned_type_node) == ptr_mode)
94     size_type_node = long_long_unsigned_type_node;
95   else
96     size_type_node = long_unsigned_type_node;
97   set_sizetype (size_type_node);
98
99   build_common_tree_nodes_2 (0);
100
101   /* We must create the gogo IR after calling build_common_tree_nodes
102      (because Gogo::define_builtin_function_trees refers indirectly
103      to, e.g., unsigned_char_type_node) but before calling
104      build_common_builtin_nodes (because it calls, indirectly,
105      go_type_for_size).  */
106   go_create_gogo (INT_TYPE_SIZE, FLOAT_TYPE_SIZE, POINTER_SIZE);
107
108   build_common_builtin_nodes ();
109
110   /* I don't know why this is not done by any of the above.  */
111   void_list_node = build_tree_list (NULL_TREE, void_type_node);
112
113   /* The default precision for floating point numbers.  This is used
114      for floating point constants with abstract type.  This may
115      eventually be controllable by a command line option.  */
116   mpfr_set_default_prec (128);
117
118   /* Go uses exceptions.  */
119   using_eh_for_cleanups ();
120
121   return true;
122 }
123
124 /* The option mask.  */
125
126 static unsigned int
127 go_langhook_option_lang_mask (void)
128 {
129   return CL_Go;
130 }
131
132 /* Initialize the options structure.  */
133
134 static void
135 go_langhook_init_options_struct (struct gcc_options *opts)
136 {
137   /* Go says that signed overflow is precisely defined.  */
138   opts->x_flag_wrapv = 1;
139
140   /* We default to using strict aliasing, since Go pointers are safe.
141      This is turned off for code that imports the "unsafe" package,
142      because using unsafe.pointer violates C style aliasing
143      requirements.  */
144   opts->x_flag_strict_aliasing = 1;
145
146   /* Default to avoiding range issues for complex multiply and
147      divide.  */
148   opts->x_flag_complex_method = 2;
149
150   /* The builtin math functions should not set errno.  */
151   opts->x_flag_errno_math = 0;
152
153   /* By default assume that floating point math does not trap.  */
154   opts->x_flag_trapping_math = 0;
155
156   /* We turn on stack splitting if we can.  */
157   if (targetm.supports_split_stack (false, opts))
158     opts->x_flag_split_stack = 1;
159
160   /* Exceptions are used to handle recovering from panics.  */
161   opts->x_flag_exceptions = 1;
162   opts->x_flag_non_call_exceptions = 1;
163 }
164
165 /* Infrastructure for a VEC of char * pointers.  */
166
167 typedef const char *go_char_p;
168 DEF_VEC_P(go_char_p);
169 DEF_VEC_ALLOC_P(go_char_p, heap);
170
171 /* The list of directories to search after all the Go specific
172    directories have been searched.  */
173
174 static VEC(go_char_p, heap) *go_search_dirs;
175
176 /* Handle Go specific options.  Return 0 if we didn't do anything.  */
177
178 static bool
179 go_langhook_handle_option (
180     size_t scode,
181     const char *arg,
182     int value ATTRIBUTE_UNUSED,
183     int kind ATTRIBUTE_UNUSED,
184     location_t loc ATTRIBUTE_UNUSED,
185     const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
186 {
187   enum opt_code code = (enum opt_code) scode;
188   bool ret = true;
189
190   switch (code)
191     {
192     case OPT_I:
193       go_add_search_path (arg);
194       break;
195
196     case OPT_L:
197       /* A -L option is assumed to come from the compiler driver.
198          This is a system directory.  We search the following
199          directories, if they exist, before this one:
200            dir/go/VERSION
201            dir/go/VERSION/MACHINE
202          This is like include/c++.  */
203       {
204         static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
205         size_t len;
206         char *p;
207         struct stat st;
208
209         len = strlen (arg);
210         p = XALLOCAVEC (char,
211                         (len + sizeof "go" + sizeof DEFAULT_TARGET_VERSION
212                          + sizeof DEFAULT_TARGET_MACHINE + 3));
213         strcpy (p, arg);
214         if (len > 0 && !IS_DIR_SEPARATOR (p[len - 1]))
215           strcat (p, dir_separator_str);
216         strcat (p, "go");
217         strcat (p, dir_separator_str);
218         strcat (p, DEFAULT_TARGET_VERSION);
219         if (stat (p, &st) == 0 && S_ISDIR (st.st_mode))
220           {
221             go_add_search_path (p);
222             strcat (p, dir_separator_str);
223             strcat (p, DEFAULT_TARGET_MACHINE);
224             if (stat (p, &st) == 0 && S_ISDIR (st.st_mode))
225               go_add_search_path (p);
226           }
227
228         /* Search ARG too, but only after we've searched to Go
229            specific directories for all -L arguments.  */
230         VEC_safe_push (go_char_p, heap, go_search_dirs, arg);
231       }
232       break;
233
234     case OPT_fgo_dump_:
235       ret = go_enable_dump (arg) ? true : false;
236       break;
237
238     case OPT_fgo_prefix_:
239       go_set_prefix (arg);
240       break;
241
242     default:
243       /* Just return 1 to indicate that the option is valid.  */
244       break;
245     }
246
247   return ret;
248 }
249
250 /* Run after parsing options.  */
251
252 static bool
253 go_langhook_post_options (const char **pfilename ATTRIBUTE_UNUSED)
254 {
255   unsigned int ix;
256   const char *dir;
257
258   gcc_assert (num_in_fnames > 0);
259
260   FOR_EACH_VEC_ELT (go_char_p, go_search_dirs, ix, dir)
261     go_add_search_path (dir);
262   VEC_free (go_char_p, heap, go_search_dirs);
263   go_search_dirs = NULL;
264
265   if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
266     flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
267
268   /* Returning false means that the backend should be used.  */
269   return false;
270 }
271
272 static void
273 go_langhook_parse_file (void)
274 {
275   go_parse_input_files (in_fnames, num_in_fnames, flag_syntax_only,
276                         go_require_return_statement);
277 }
278
279 static tree
280 go_langhook_type_for_size (unsigned int bits, int unsignedp)
281 {
282   return go_type_for_size (bits, unsignedp);
283 }
284
285 static tree
286 go_langhook_type_for_mode (enum machine_mode mode, int unsignedp)
287 {
288   return go_type_for_mode (mode, unsignedp);
289 }
290
291 /* Record a builtin function.  We just ignore builtin functions.  */
292
293 static tree
294 go_langhook_builtin_function (tree decl)
295 {
296   return decl;
297 }
298
299 static int
300 go_langhook_global_bindings_p (void)
301 {
302   return current_function_decl == NULL ? 1 : 0;
303 }
304
305 /* Push a declaration into the current binding level.  We can't
306    usefully implement this since we don't want to convert from tree
307    back to one of our internal data structures.  I think the only way
308    this is used is to record a decl which is to be returned by
309    getdecls, and we could implement it for that purpose if
310    necessary.  */
311
312 static tree
313 go_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED)
314 {
315   gcc_unreachable ();
316 }
317
318 /* This hook is used to get the current list of declarations as trees.
319    We don't support that; instead we use the write_globals hook.  This
320    can't simply crash because it is called by -gstabs.  */
321
322 static tree
323 go_langhook_getdecls (void)
324 {
325   return NULL;
326 }
327
328 /* Write out globals.  */
329
330 static void
331 go_langhook_write_globals (void)
332 {
333   go_write_globals ();
334 }
335
336 /* Go specific gimplification.  We need to gimplify
337    CALL_EXPR_STATIC_CHAIN, because the gimplifier doesn't handle
338    it.  */
339
340 static int
341 go_langhook_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
342 {
343   if (TREE_CODE (*expr_p) == CALL_EXPR
344       && CALL_EXPR_STATIC_CHAIN (*expr_p) != NULL_TREE)
345     gimplify_expr (&CALL_EXPR_STATIC_CHAIN (*expr_p), pre_p, post_p,
346                    is_gimple_val, fb_rvalue);
347   return GS_UNHANDLED;
348 }
349
350 /* Return a decl for the exception personality function.  The function
351    itself is implemented in libgo/runtime/go-unwind.c.  */
352
353 static tree
354 go_langhook_eh_personality (void)
355 {
356   static tree personality_decl;
357   if (personality_decl == NULL_TREE)
358     {
359       personality_decl = build_personality_function ("gccgo");
360       go_preserve_from_gc (personality_decl);
361     }
362   return personality_decl;
363 }
364
365 /* Functions called directly by the generic backend.  */
366
367 tree
368 convert (tree type, tree expr)
369 {
370   if (type == error_mark_node
371       || expr == error_mark_node
372       || TREE_TYPE (expr) == error_mark_node)
373     return error_mark_node;
374
375   if (type == TREE_TYPE (expr))
376     return expr;
377
378   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
379     return fold_convert (type, expr);
380
381   switch (TREE_CODE (type))
382     {
383     case VOID_TYPE:
384     case BOOLEAN_TYPE:
385       return fold_convert (type, expr);
386     case INTEGER_TYPE:
387       return fold (convert_to_integer (type, expr));
388     case POINTER_TYPE:
389       return fold (convert_to_pointer (type, expr));
390     case REAL_TYPE:
391       return fold (convert_to_real (type, expr));
392     case COMPLEX_TYPE:
393       return fold (convert_to_complex (type, expr));
394     default:
395       break;
396     }
397
398   gcc_unreachable ();
399 }
400
401 /* FIXME: This is a hack to preserve trees that we create from the
402    garbage collector.  */
403
404 static GTY(()) tree go_gc_root;
405
406 void
407 go_preserve_from_gc (tree t)
408 {
409   go_gc_root = tree_cons (NULL_TREE, t, go_gc_root);
410 }
411
412 /* Convert an identifier for use in an error message.  */
413
414 const char *
415 go_localize_identifier (const char *ident)
416 {
417   return identifier_to_locale (ident);
418 }
419
420 #undef LANG_HOOKS_NAME
421 #undef LANG_HOOKS_INIT
422 #undef LANG_HOOKS_OPTION_LANG_MASK
423 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
424 #undef LANG_HOOKS_HANDLE_OPTION
425 #undef LANG_HOOKS_POST_OPTIONS
426 #undef LANG_HOOKS_PARSE_FILE
427 #undef LANG_HOOKS_TYPE_FOR_MODE
428 #undef LANG_HOOKS_TYPE_FOR_SIZE
429 #undef LANG_HOOKS_BUILTIN_FUNCTION
430 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
431 #undef LANG_HOOKS_PUSHDECL
432 #undef LANG_HOOKS_GETDECLS
433 #undef LANG_HOOKS_WRITE_GLOBALS
434 #undef LANG_HOOKS_GIMPLIFY_EXPR
435 #undef LANG_HOOKS_EH_PERSONALITY
436
437 #define LANG_HOOKS_NAME                 "GNU Go"
438 #define LANG_HOOKS_INIT                 go_langhook_init
439 #define LANG_HOOKS_OPTION_LANG_MASK     go_langhook_option_lang_mask
440 #define LANG_HOOKS_INIT_OPTIONS_STRUCT  go_langhook_init_options_struct
441 #define LANG_HOOKS_HANDLE_OPTION        go_langhook_handle_option
442 #define LANG_HOOKS_POST_OPTIONS         go_langhook_post_options
443 #define LANG_HOOKS_PARSE_FILE           go_langhook_parse_file
444 #define LANG_HOOKS_TYPE_FOR_MODE        go_langhook_type_for_mode
445 #define LANG_HOOKS_TYPE_FOR_SIZE        go_langhook_type_for_size
446 #define LANG_HOOKS_BUILTIN_FUNCTION     go_langhook_builtin_function
447 #define LANG_HOOKS_GLOBAL_BINDINGS_P    go_langhook_global_bindings_p
448 #define LANG_HOOKS_PUSHDECL             go_langhook_pushdecl
449 #define LANG_HOOKS_GETDECLS             go_langhook_getdecls
450 #define LANG_HOOKS_WRITE_GLOBALS        go_langhook_write_globals
451 #define LANG_HOOKS_GIMPLIFY_EXPR        go_langhook_gimplify_expr
452 #define LANG_HOOKS_EH_PERSONALITY       go_langhook_eh_personality
453
454 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
455
456 #include "gt-go-go-lang.h"
457 #include "gtype-go.h"