/* go-lang.c -- Go frontend gcc interface.
- Copyright (C) 2009-2015 Free Software Foundation, Inc.
+ Copyright (C) 2009-2020 Free Software Foundation, Inc.
This file is part of GCC.
#include <mpfr.h>
#include "go-c.h"
+#include "go-gcc.h"
+
+#ifndef TARGET_AIX
+#define TARGET_AIX 0
+#endif
/* Language-dependent contents of a type. */
static const char *go_pkgpath = NULL;
static const char *go_prefix = NULL;
static const char *go_relative_import_path = NULL;
+static const char *go_c_header = NULL;
/* Language hooks. */
static bool
go_langhook_init (void)
{
- build_common_tree_nodes (false, false);
+ build_common_tree_nodes (false);
/* I don't know why this has to be done explicitly. */
void_list_node = build_tree_list (NULL_TREE, void_type_node);
to, e.g., unsigned_char_type_node) but before calling
build_common_builtin_nodes (because it calls, indirectly,
go_type_for_size). */
- go_create_gogo (INT_TYPE_SIZE, POINTER_SIZE, go_pkgpath, go_prefix,
- go_relative_import_path, go_check_divide_zero,
- go_check_divide_overflow);
+ struct go_create_gogo_args args;
+ args.int_type_size = INT_TYPE_SIZE;
+ args.pointer_size = POINTER_SIZE;
+ args.pkgpath = go_pkgpath;
+ args.prefix = go_prefix;
+ args.relative_import_path = go_relative_import_path;
+ args.c_header = go_c_header;
+ args.check_divide_by_zero = go_check_divide_zero;
+ args.check_divide_overflow = go_check_divide_overflow;
+ args.compiling_runtime = go_compiling_runtime;
+ args.debug_escape_level = go_debug_escape_level;
+ args.debug_escape_hash = go_debug_escape_hash;
+ args.nil_check_size_threshold = TARGET_AIX ? -1 : 4096;
+ args.debug_optimization = go_debug_optimization;
+ args.linemap = go_get_linemap();
+ args.backend = go_get_backend();
+ go_create_gogo (&args);
build_common_builtin_nodes ();
opts->x_flag_exceptions = 1;
opts->x_flag_non_call_exceptions = 1;
+ /* We need to keep pointers live for the garbage collector. */
+ opts->x_flag_keep_gc_roots_live = 1;
+
/* Go programs expect runtime.Callers to work, and that uses
libbacktrace that uses debug info. Set the debug info level to 1
by default. In post_options we will set the debug type if the
go_langhook_handle_option (
size_t scode,
const char *arg,
- int value ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT value,
int kind ATTRIBUTE_UNUSED,
location_t loc ATTRIBUTE_UNUSED,
const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
break;
case OPT_fgo_optimize_:
- ret = go_enable_optimize (arg) ? true : false;
+ ret = go_enable_optimize (arg, value) ? true : false;
break;
case OPT_fgo_pkgpath_:
go_relative_import_path = arg;
break;
+ case OPT_fgo_c_header_:
+ go_c_header = arg;
+ break;
+
default:
/* Just return 1 to indicate that the option is valid. */
break;
go_add_search_path (dir);
go_search_dirs.release ();
- if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
- flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
+ if (flag_excess_precision == EXCESS_PRECISION_DEFAULT)
+ flag_excess_precision = EXCESS_PRECISION_STANDARD;
/* Tail call optimizations can confuse uses of runtime.Callers. */
- if (!global_options_set.x_flag_optimize_sibling_calls)
- global_options.x_flag_optimize_sibling_calls = 0;
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ flag_optimize_sibling_calls, 0);
+
+ /* Partial inlining can confuses uses of runtime.Callers.
+ See https://gcc.gnu.org/PR91663. */
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ flag_partial_inlining, 0);
/* If the debug info level is still 1, as set in init_options, make
sure that some debugging type is selected. */
global_options.x_write_symbols = PREFERRED_DEBUGGING_TYPE;
/* We turn on stack splitting if we can. */
- if (!global_options_set.x_flag_split_stack
- && targetm_common.supports_split_stack (false, &global_options))
- global_options.x_flag_split_stack = 1;
+ if (targetm_common.supports_split_stack (false, &global_options))
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ flag_split_stack, 1);
+
+ /* If stack splitting is turned on, and the user did not explicitly
+ request function partitioning, turn off partitioning, as it
+ confuses the linker when trying to handle partitioned split-stack
+ code that calls a non-split-stack function. */
+ if (global_options.x_flag_split_stack
+ && global_options.x_flag_reorder_blocks_and_partition)
+ SET_OPTION_IF_UNSET (&global_options, &global_options_set,
+ flag_reorder_blocks_and_partition, 0);
/* Returning false means that the backend should be used. */
return false;
make sense for the middle-end to ask the frontend for a type
which the frontend does not support. However, at least for now
it is required. See PR 46805. */
- if (VECTOR_MODE_P (mode))
+ if (GET_MODE_CLASS (mode) == MODE_VECTOR_BOOL
+ && valid_vector_subparts_p (GET_MODE_NUNITS (mode)))
+ {
+ unsigned int elem_bits = vector_element_size (GET_MODE_BITSIZE (mode),
+ GET_MODE_NUNITS (mode));
+ tree bool_type = build_nonstandard_boolean_type (elem_bits);
+ return build_vector_type_for_mode (bool_type, mode);
+ }
+ else if (VECTOR_MODE_P (mode)
+ && valid_vector_subparts_p (GET_MODE_NUNITS (mode)))
{
tree inner;
return NULL_TREE;
}
- // FIXME: This static_cast should be in machmode.h.
- enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
- if (mc == MODE_INT)
- return go_langhook_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
- else if (mc == MODE_FLOAT)
+ scalar_int_mode imode;
+ scalar_float_mode fmode;
+ complex_mode cmode;
+ if (is_int_mode (mode, &imode))
+ return go_langhook_type_for_size (GET_MODE_BITSIZE (imode), unsignedp);
+ else if (is_float_mode (mode, &fmode))
{
- switch (GET_MODE_BITSIZE (mode))
+ switch (GET_MODE_BITSIZE (fmode))
{
case 32:
return float_type_node;
default:
// We have to check for long double in order to support
// i386 excess precision.
- if (mode == TYPE_MODE(long_double_type_node))
+ if (fmode == TYPE_MODE(long_double_type_node))
return long_double_type_node;
}
}
- else if (mc == MODE_COMPLEX_FLOAT)
+ else if (is_complex_float_mode (mode, &cmode))
{
- switch (GET_MODE_BITSIZE (mode))
+ switch (GET_MODE_BITSIZE (cmode))
{
case 64:
return complex_float_type_node;
default:
// We have to check for long double in order to support
// i386 excess precision.
- if (mode == TYPE_MODE(complex_long_double_type_node))
+ if (cmode == TYPE_MODE(complex_long_double_type_node))
return complex_long_double_type_node;
}
}
projects / thirdparty / gcc.git / blobdiff