1 /* go-lang.c -- Go frontend gcc interface.
2 Copyright (C) 2009, 2010 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
33 #include "diagnostic.h"
34 #include "langhooks.h"
35 #include "langhooks-def.h"
43 /* Language-dependent contents of a type. */
45 struct GTY(()) lang_type
50 /* Language-dependent contents of a decl. */
52 struct GTY(()) lang_decl
57 /* Language-dependent contents of an identifier. This must include a
60 struct GTY(()) lang_identifier
62 struct tree_identifier common
;
65 /* The resulting tree type. */
67 union GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
68 chain_next ("(union lang_tree_node *) TREE_CHAIN (&%h.generic)")))
71 union tree_node
GTY((tag ("0"),
72 desc ("tree_node_structure (&%h)"))) generic
;
73 struct lang_identifier
GTY((tag ("1"))) identifier
;
76 /* We don't use language_function. */
78 struct GTY(()) language_function
86 go_langhook_init (void)
88 build_common_tree_nodes (false);
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
;
96 size_type_node
= long_unsigned_type_node
;
97 set_sizetype (size_type_node
);
99 build_common_tree_nodes_2 (0);
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
);
108 build_common_builtin_nodes ();
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
);
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);
118 /* Go uses exceptions. */
119 using_eh_for_cleanups ();
124 /* The option mask. */
127 go_langhook_option_lang_mask (void)
132 /* Initialize the options structure. */
135 go_langhook_init_options_struct (struct gcc_options
*opts
)
137 /* Go says that signed overflow is precisely defined. */
138 opts
->x_flag_wrapv
= 1;
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
144 opts
->x_flag_strict_aliasing
= 1;
146 /* Default to avoiding range issues for complex multiply and
148 opts
->x_flag_complex_method
= 2;
150 /* The builtin math functions should not set errno. */
151 opts
->x_flag_errno_math
= 0;
153 /* By default assume that floating point math does not trap. */
154 opts
->x_flag_trapping_math
= 0;
156 /* We turn on stack splitting if we can. */
157 if (targetm
.supports_split_stack (false, opts
))
158 opts
->x_flag_split_stack
= 1;
160 /* Exceptions are used to handle recovering from panics. */
161 opts
->x_flag_exceptions
= 1;
162 opts
->x_flag_non_call_exceptions
= 1;
165 /* Handle Go specific options. Return 0 if we didn't do anything. */
168 go_langhook_handle_option (
171 int value ATTRIBUTE_UNUSED
,
172 int kind ATTRIBUTE_UNUSED
,
173 location_t loc ATTRIBUTE_UNUSED
,
174 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
)
176 enum opt_code code
= (enum opt_code
) scode
;
183 /* For the compiler, we currently handle -I and -L exactly the
184 same way: they give us a directory to search for import
186 go_add_search_path (arg
);
190 ret
= go_enable_dump (arg
) ? true : false;
193 case OPT_fgo_prefix_
:
198 /* Just return 1 to indicate that the option is valid. */
205 /* Run after parsing options. */
208 go_langhook_post_options (const char **pfilename ATTRIBUTE_UNUSED
)
210 gcc_assert (num_in_fnames
> 0);
212 if (flag_excess_precision_cmdline
== EXCESS_PRECISION_DEFAULT
)
213 flag_excess_precision_cmdline
= EXCESS_PRECISION_STANDARD
;
215 /* Returning false means that the backend should be used. */
220 go_langhook_parse_file (void)
222 go_parse_input_files (in_fnames
, num_in_fnames
, flag_syntax_only
,
223 go_require_return_statement
);
227 go_langhook_type_for_size (unsigned int bits
, int unsignedp
)
229 return go_type_for_size (bits
, unsignedp
);
233 go_langhook_type_for_mode (enum machine_mode mode
, int unsignedp
)
235 return go_type_for_mode (mode
, unsignedp
);
238 /* Record a builtin function. We just ignore builtin functions. */
241 go_langhook_builtin_function (tree decl
)
247 go_langhook_global_bindings_p (void)
249 return current_function_decl
== NULL
? 1 : 0;
252 /* Push a declaration into the current binding level. We can't
253 usefully implement this since we don't want to convert from tree
254 back to one of our internal data structures. I think the only way
255 this is used is to record a decl which is to be returned by
256 getdecls, and we could implement it for that purpose if
260 go_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED
)
265 /* This hook is used to get the current list of declarations as trees.
266 We don't support that; instead we use the write_globals hook. This
267 can't simply crash because it is called by -gstabs. */
270 go_langhook_getdecls (void)
275 /* Write out globals. */
278 go_langhook_write_globals (void)
283 /* Go specific gimplification. We need to gimplify
284 CALL_EXPR_STATIC_CHAIN, because the gimplifier doesn't handle
288 go_langhook_gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
290 if (TREE_CODE (*expr_p
) == CALL_EXPR
291 && CALL_EXPR_STATIC_CHAIN (*expr_p
) != NULL_TREE
)
292 gimplify_expr (&CALL_EXPR_STATIC_CHAIN (*expr_p
), pre_p
, post_p
,
293 is_gimple_val
, fb_rvalue
);
297 /* Return a decl for the exception personality function. The function
298 itself is implemented in libgo/runtime/go-unwind.c. */
301 go_langhook_eh_personality (void)
303 static tree personality_decl
;
304 if (personality_decl
== NULL_TREE
)
306 personality_decl
= build_personality_function ("gccgo");
307 go_preserve_from_gc (personality_decl
);
309 return personality_decl
;
312 /* Functions called directly by the generic backend. */
315 convert (tree type
, tree expr
)
317 if (type
== error_mark_node
318 || expr
== error_mark_node
319 || TREE_TYPE (expr
) == error_mark_node
)
320 return error_mark_node
;
322 if (type
== TREE_TYPE (expr
))
325 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (expr
)))
326 return fold_convert (type
, expr
);
328 switch (TREE_CODE (type
))
332 return fold_convert (type
, expr
);
334 return fold (convert_to_integer (type
, expr
));
336 return fold (convert_to_pointer (type
, expr
));
338 return fold (convert_to_real (type
, expr
));
340 return fold (convert_to_complex (type
, expr
));
348 /* FIXME: This is a hack to preserve trees that we create from the
349 garbage collector. */
351 static GTY(()) tree go_gc_root
;
354 go_preserve_from_gc (tree t
)
356 go_gc_root
= tree_cons (NULL_TREE
, t
, go_gc_root
);
359 /* Convert an identifier for use in an error message. */
362 go_localize_identifier (const char *ident
)
364 return identifier_to_locale (ident
);
367 #undef LANG_HOOKS_NAME
368 #undef LANG_HOOKS_INIT
369 #undef LANG_HOOKS_OPTION_LANG_MASK
370 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
371 #undef LANG_HOOKS_HANDLE_OPTION
372 #undef LANG_HOOKS_POST_OPTIONS
373 #undef LANG_HOOKS_PARSE_FILE
374 #undef LANG_HOOKS_TYPE_FOR_MODE
375 #undef LANG_HOOKS_TYPE_FOR_SIZE
376 #undef LANG_HOOKS_BUILTIN_FUNCTION
377 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
378 #undef LANG_HOOKS_PUSHDECL
379 #undef LANG_HOOKS_GETDECLS
380 #undef LANG_HOOKS_WRITE_GLOBALS
381 #undef LANG_HOOKS_GIMPLIFY_EXPR
382 #undef LANG_HOOKS_EH_PERSONALITY
384 #define LANG_HOOKS_NAME "GNU Go"
385 #define LANG_HOOKS_INIT go_langhook_init
386 #define LANG_HOOKS_OPTION_LANG_MASK go_langhook_option_lang_mask
387 #define LANG_HOOKS_INIT_OPTIONS_STRUCT go_langhook_init_options_struct
388 #define LANG_HOOKS_HANDLE_OPTION go_langhook_handle_option
389 #define LANG_HOOKS_POST_OPTIONS go_langhook_post_options
390 #define LANG_HOOKS_PARSE_FILE go_langhook_parse_file
391 #define LANG_HOOKS_TYPE_FOR_MODE go_langhook_type_for_mode
392 #define LANG_HOOKS_TYPE_FOR_SIZE go_langhook_type_for_size
393 #define LANG_HOOKS_BUILTIN_FUNCTION go_langhook_builtin_function
394 #define LANG_HOOKS_GLOBAL_BINDINGS_P go_langhook_global_bindings_p
395 #define LANG_HOOKS_PUSHDECL go_langhook_pushdecl
396 #define LANG_HOOKS_GETDECLS go_langhook_getdecls
397 #define LANG_HOOKS_WRITE_GLOBALS go_langhook_write_globals
398 #define LANG_HOOKS_GIMPLIFY_EXPR go_langhook_gimplify_expr
399 #define LANG_HOOKS_EH_PERSONALITY go_langhook_eh_personality
401 struct lang_hooks lang_hooks
= LANG_HOOKS_INITIALIZER
;
403 #include "gt-go-go-lang.h"
404 #include "gtype-go.h"