OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/gnu-dev/or1k-gcc/gcc
    from Rev 707 to Rev 708
    ↔ Reverse comparison
  •

Rev 707 → Rev 708

/common/common-target.h
0,0 → 1,72
/* Data structure definitions for common hooks.
Copyright (C) 2010, 2011
Free Software Foundation, Inc.
 
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>.
 
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding! */
 
#ifndef GCC_COMMON_TARGET_H
#define GCC_COMMON_TARGET_H
 
#include "input.h"
 
/* Sets of optimization levels at which an option may be enabled by
default_options_optimization. */
enum opt_levels
{
OPT_LEVELS_NONE, /* No levels (mark end of array). */
OPT_LEVELS_ALL, /* All levels (used by targets to disable options
enabled in target-independent code). */
OPT_LEVELS_0_ONLY, /* -O0 only. */
OPT_LEVELS_1_PLUS, /* -O1 and above, including -Os. */
OPT_LEVELS_1_PLUS_SPEED_ONLY, /* -O1 and above, but not -Os. */
OPT_LEVELS_2_PLUS, /* -O2 and above, including -Os. */
OPT_LEVELS_2_PLUS_SPEED_ONLY, /* -O2 and above, but not -Os. */
OPT_LEVELS_3_PLUS, /* -O3 and above. */
OPT_LEVELS_3_PLUS_AND_SIZE, /* -O3 and above and -Os. */
OPT_LEVELS_SIZE, /* -Os only. */
OPT_LEVELS_FAST /* -Ofast only. */
};
 
/* Description of options to enable by default at given levels. */
struct default_options
{
/* The levels at which to enable the option. */
enum opt_levels levels;
 
/* The option index and argument or enabled/disabled sense of the
option, as passed to handle_generated_option. If ARG is NULL and
the option allows a negative form, the option is considered to be
passed in negative form when the optimization level is not one of
those in LEVELS (in order to handle changes to the optimization
level with the "optimize" attribute). */
size_t opt_index;
const char *arg;
int value;
};
 
#define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME;
#define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS;
#define DEFHOOK_UNDOC DEFHOOK
#define HOOKSTRUCT(FRAGMENT) FRAGMENT
 
#include "common-target.def"
 
extern struct gcc_targetm_common targetm_common;
 
#endif /* GCC_C_TARGET_H */
/common/config/arm/arm-common.c
0,0 → 1,76
/* Common hooks for ARM.
Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tm_p.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Set default optimization options. */
static const struct default_options arm_option_optimization_table[] =
{
/* Enable section anchors by default at -O1 or higher. */
{ OPT_LEVELS_1_PLUS, OPT_fsection_anchors, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_EXCEPT_UNWIND_INFO. */
 
enum unwind_info_type
arm_except_unwind_info (struct gcc_options *opts)
{
/* Honor the --enable-sjlj-exceptions configure switch. */
#ifdef CONFIG_SJLJ_EXCEPTIONS
if (CONFIG_SJLJ_EXCEPTIONS)
return UI_SJLJ;
#endif
 
/* If not using ARM EABI unwind tables... */
if (ARM_UNWIND_INFO)
{
/* For simplicity elsewhere in this file, indicate that all unwind
info is disabled if we're not emitting unwind tables. */
if (!opts->x_flag_exceptions && !opts->x_flag_unwind_tables)
return UI_NONE;
else
return UI_TARGET;
}
 
/* ... we use sjlj exceptions for backwards compatibility. */
return UI_SJLJ;
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | MASK_SCHED_PROLOG)
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE arm_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO arm_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/pdp11/pdp11-common.c
0,0 → 1,79
/* Common hooks for pdp11.
Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2004, 2005,
2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
 
static const struct default_options pdp11_option_optimization_table[] =
{
{ OPT_LEVELS_3_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
pdp11_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
 
switch (code)
{
case OPT_m10:
opts->x_target_flags &= ~(MASK_40 | MASK_45);
return true;
 
default:
return true;
}
}
 
/* Implement TARGET_OPTION_INIT_STRUCT. */
 
static void
pdp11_option_init_struct (struct gcc_options *opts)
{
opts->x_flag_finite_math_only = 0;
opts->x_flag_trapping_math = 0;
opts->x_flag_signaling_nans = 0;
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS \
(MASK_FPU | MASK_45 | TARGET_UNIX_ASM_DEFAULT)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION pdp11_handle_option
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE pdp11_option_optimization_table
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT pdp11_option_init_struct
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/alpha/alpha-common.c
0,0 → 1,97
/* Common hooks for DEC Alpha.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options alpha_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
/* Enable redundant extension instructions removal at -O2 and higher. */
{ OPT_LEVELS_2_PLUS, OPT_free, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_OPTION_INIT_STRUCT. */
 
static void
alpha_option_init_struct (struct gcc_options *opts ATTRIBUTE_UNUSED)
{
#if TARGET_ABI_OPEN_VMS
/* Enable section anchors by default. */
opts->x_flag_section_anchors = 1;
#endif
}
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
alpha_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
 
switch (code)
{
case OPT_mfp_regs:
if (value == 0)
opts->x_target_flags |= MASK_SOFT_FP;
break;
 
case OPT_mieee:
case OPT_mieee_with_inexact:
opts->x_target_flags |= MASK_IEEE_CONFORMANT;
break;
 
case OPT_mtls_size_:
if (value != 16 && value != 32 && value != 64)
error_at (loc, "bad value %qs for -mtls-size switch", arg);
break;
}
 
return true;
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS \
(TARGET_DEFAULT | TARGET_CPU_DEFAULT | TARGET_DEFAULT_EXPLICIT_RELOCS)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION alpha_handle_option
 
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT alpha_option_init_struct
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE alpha_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/microblaze/microblaze-common.c
0,0 → 1,43
/* Common hooks for Xilinx MicroBlaze.
Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options microblaze_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE microblaze_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/avr/avr-common.c
0,0 → 1,41
/* Common hooks for ATMEL AVR.
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008,
2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options avr_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE avr_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/xstormy16/xstormy16-common.c
0,0 → 1,38
/* Common hooks for Xstormy16.
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options xstorym16_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE xstorym16_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/frv/frv-common.c
0,0 → 1,55
/* Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007,
2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Allow us to easily change the default for -malloc-cc. */
#ifndef DEFAULT_NO_ALLOC_CC
#define MASK_DEFAULT_ALLOC_CC MASK_ALLOC_CC
#else
#define MASK_DEFAULT_ALLOC_CC 0
#endif
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options frv_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS \
(MASK_DEFAULT_ALLOC_CC \
| MASK_COND_MOVE \
| MASK_SCC \
| MASK_COND_EXEC \
| MASK_VLIW_BRANCH \
| MASK_MULTI_CE \
| MASK_NESTED_CE)
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE frv_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/s390/s390-common.c
0,0 → 1,127
/* Common hooks for IBM S/390 and zSeries.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
EXPORTED_CONST int processor_flags_table[] =
{
/* g5 */ PF_IEEE_FLOAT,
/* g6 */ PF_IEEE_FLOAT,
/* z900 */ PF_IEEE_FLOAT | PF_ZARCH,
/* z990 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT,
/* z9-109 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT
| PF_EXTIMM,
/* z9-ec */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT
| PF_EXTIMM | PF_DFP,
/* z10 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT
| PF_EXTIMM | PF_DFP | PF_Z10,
/* z196 */ PF_IEEE_FLOAT | PF_ZARCH | PF_LONG_DISPLACEMENT
| PF_EXTIMM | PF_DFP | PF_Z10 | PF_Z196
};
 
/* Change optimizations to be performed, depending on the
optimization level. */
 
static const struct default_options s390_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
 
/* ??? There are apparently still problems with -fcaller-saves. */
{ OPT_LEVELS_ALL, OPT_fcaller_saves, NULL, 0 },
 
/* Use MVCLE instructions to decrease code size if requested. */
{ OPT_LEVELS_SIZE, OPT_mmvcle, NULL, 1 },
 
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_OPTION_INIT_STRUCT. */
 
static void
s390_option_init_struct (struct gcc_options *opts)
{
/* By default, always emit DWARF-2 unwind info. This allows debugging
without maintaining a stack frame back-chain. */
opts->x_flag_asynchronous_unwind_tables = 1;
}
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
s390_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
 
switch (code)
{
case OPT_march_:
opts->x_s390_arch_flags = processor_flags_table[value];
opts->x_s390_arch_string = arg;
return true;
 
case OPT_mstack_guard_:
if (exact_log2 (value) == -1)
error_at (loc, "stack guard value must be an exact power of 2");
return true;
 
case OPT_mstack_size_:
if (exact_log2 (value) == -1)
error_at (loc, "stack size must be an exact power of 2");
return true;
 
case OPT_mtune_:
opts->x_s390_tune_flags = processor_flags_table[value];
return true;
 
case OPT_mwarn_framesize_:
return sscanf (arg, HOST_WIDE_INT_PRINT_DEC,
&opts->x_s390_warn_framesize) == 1;
 
default:
return true;
}
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT)
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION s390_handle_option
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE s390_option_optimization_table
 
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT s390_option_init_struct
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/mn10300/mn10300-common.c
0,0 → 1,79
/* Common hooks for Matsushita MN10300 series.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options mn10300_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
mn10300_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
int value = decoded->value;
 
switch (code)
{
case OPT_mam33:
opts->x_mn10300_processor = value ? PROCESSOR_AM33 : PROCESSOR_MN10300;
return true;
 
case OPT_mam33_2:
opts->x_mn10300_processor = (value
? PROCESSOR_AM33_2
: MIN (PROCESSOR_AM33, PROCESSOR_DEFAULT));
return true;
 
case OPT_mam34:
opts->x_mn10300_processor = (value ? PROCESSOR_AM34 : PROCESSOR_DEFAULT);
return true;
 
default:
return true;
}
}
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS MASK_MULT_BUG | MASK_PTR_A0D0 | MASK_ALLOW_LIW | MASK_ALLOW_SETLB
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION mn10300_handle_option
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE mn10300_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/pa/pa-common.c
0,0 → 1,80
/* HPPA common hooks.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options pa_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
pa_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
 
switch (code)
{
case OPT_mnosnake:
case OPT_mpa_risc_1_0:
case OPT_march_1_0:
opts->x_target_flags &= ~(MASK_PA_11 | MASK_PA_20);
return true;
 
case OPT_msnake:
case OPT_mpa_risc_1_1:
case OPT_march_1_1:
opts->x_target_flags &= ~MASK_PA_20;
opts->x_target_flags |= MASK_PA_11;
return true;
 
case OPT_mpa_risc_2_0:
case OPT_march_2_0:
opts->x_target_flags |= MASK_PA_11 | MASK_PA_20;
return true;
 
default:
return true;
}
}
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE pa_option_optimization_table
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | TARGET_CPU_DEFAULT)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION pa_handle_option
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/c6x/c6x-common.c
0,0 → 1,64
/* TI C6X common hooks.
Copyright (C) 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "tm_p.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement overriding of the optimization options. */
static const struct default_options c6x_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_frename_registers, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fmodulo_sched, NULL, 1 },
{ OPT_LEVELS_ALL, OPT_freciprocal_math, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_EXCEPT_UNWIND_INFO. */
 
static enum unwind_info_type
c6x_except_unwind_info (struct gcc_options *opts ATTRIBUTE_UNUSED)
{
/* Honor the --enable-sjlj-exceptions configure switch. */
#ifdef CONFIG_SJLJ_EXCEPTIONS
if (CONFIG_SJLJ_EXCEPTIONS)
return UI_SJLJ;
#endif
 
return UI_TARGET;
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE c6x_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO c6x_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/xtensa/xtensa-common.c
0,0 → 1,47
/* Common hooks for Tensilica's Xtensa architecture.
Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
 
static const struct default_options xtensa_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
/* Reordering blocks for Xtensa is not a good idea unless the
compiler understands the range of conditional branches.
Currently all branch relaxation for Xtensa is handled in the
assembler, so GCC cannot do a good job of reordering blocks.
Do not enable reordering unless it is explicitly requested. */
{ OPT_LEVELS_ALL, OPT_freorder_blocks, NULL, 0 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT)
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE xtensa_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/ia64/ia64-common.c
0,0 → 1,115
/* Common hooks for IA64.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "tm_p.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
#include "params.h"
 
/* Implement overriding of the optimization options. */
static const struct default_options ia64_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
#ifdef SUBTARGET_OPTIMIZATION_OPTIONS
SUBTARGET_OPTIMIZATION_OPTIONS,
#endif
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
ia64_handle_option (struct gcc_options *opts ATTRIBUTE_UNUSED,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
 
switch (code)
{
case OPT_mtls_size_:
if (value != 14 && value != 22 && value != 64)
error_at (loc, "bad value %<%s%> for -mtls-size= switch", arg);
return true;
 
default:
return true;
}
}
 
/* Implement TARGET_EXCEPT_UNWIND_INFO. */
 
enum unwind_info_type
ia64_except_unwind_info (struct gcc_options *opts)
{
/* Honor the --enable-sjlj-exceptions configure switch. */
#ifdef CONFIG_UNWIND_EXCEPTIONS
if (CONFIG_UNWIND_EXCEPTIONS)
return UI_SJLJ;
#endif
 
/* For simplicity elsewhere in this file, indicate that all unwind
info is disabled if we're not emitting unwind tables. */
if (!opts->x_flag_exceptions && !opts->x_flag_unwind_tables)
return UI_NONE;
 
return UI_TARGET;
}
 
/* Implement TARGET_OPTION_DEFAULT_PARAMS. */
 
static void
ia64_option_default_params (void)
{
/* Let the scheduler form additional regions. */
set_default_param_value (PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, 2);
 
/* Set the default values for cache-related parameters. */
set_default_param_value (PARAM_SIMULTANEOUS_PREFETCHES, 6);
set_default_param_value (PARAM_L1_CACHE_LINE_SIZE, 32);
 
set_default_param_value (PARAM_SCHED_MEM_TRUE_DEP_COST, 4);
}
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE ia64_option_optimization_table
#undef TARGET_OPTION_DEFAULT_PARAMS
#define TARGET_OPTION_DEFAULT_PARAMS ia64_option_default_params
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO ia64_except_unwind_info
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | TARGET_CPU_DEFAULT)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION ia64_handle_option
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/spu/spu-common.c
0,0 → 1,57
/* Common hooks for SPU.
Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at your option)
any later version.
 
This file is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
#include "params.h"
 
static void
spu_option_init_struct (struct gcc_options *opts)
{
/* With so many registers this is better on by default. */
opts->x_flag_rename_registers = 1;
}
 
/* Implement TARGET_OPTION_DEFAULT_PARAMS. */
static void
spu_option_default_params (void)
{
/* Override some of the default param values. With so many registers
larger values are better for these params. */
set_default_param_value (PARAM_MAX_PENDING_LIST_LENGTH, 128);
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT)
 
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT spu_option_init_struct
 
#undef TARGET_OPTION_DEFAULT_PARAMS
#define TARGET_OPTION_DEFAULT_PARAMS spu_option_default_params
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/sparc/sparc-common.c
0,0 → 1,42
/* Common hooks for SPARC.
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options sparc_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE sparc_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/mips/mips-common.c
0,0 → 1,74
/* Common hooks for MIPS.
Copyright (C) 1989, 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
mips_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
 
switch (code)
{
case OPT_mno_flush_func:
opts->x_mips_cache_flush_func = NULL;
return true;
 
default:
return true;
}
}
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options mips_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE mips_option_optimization_table
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS \
(TARGET_DEFAULT \
| TARGET_CPU_DEFAULT \
| TARGET_ENDIAN_DEFAULT \
| TARGET_FP_EXCEPTIONS_DEFAULT \
| MASK_CHECK_ZERO_DIV \
| MASK_FUSED_MADD)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION mips_handle_option
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/fr30/fr30-common.c
0,0 → 1,41
/* Common hooks for FR30.
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008, 2009,
2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options fr30_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE fr30_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/lm32/lm32-common.c
0,0 → 1,41
/* Common hooks for Lattice Mico32.
 
Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options lm32_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE lm32_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/epiphany/epiphany-common.c
0,0 → 1,46
/* Common hooks for Adapteva Epiphany
Copyright (C) 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
2004, 2005, 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
Contributed by Embecosm on behalf of Adapteva, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "common/common-target.h"
#include "opts.h"
#include "flags.h"
 
#define TARGET_OPTION_OPTIMIZATION_TABLE epiphany_option_optimization_table
 
#define TARGET_DEFAULT_TARGET_FLAGS \
(MASK_CMOVE | MASK_SOFT_CMPSF | MASK_SPLIT_LOHI | MASK_ROUND_NEAREST \
| MASK_VECT_DOUBLE | MASK_POST_INC | MASK_POST_MODIFY)
 
#define TARGET_HAVE_NAMED_SECTIONS true
 
#include "common/common-target-def.h"
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options epiphany_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/mep/mep-common.c
0,0 → 1,91
/* Common hooks for Toshiba Media Processor.
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
static const struct default_options mep_option_optimization_table[] =
{
/* The first scheduling pass often increases register pressure and
tends to result in more spill code. Only run it when
specifically asked. */
{ OPT_LEVELS_ALL, OPT_fschedule_insns, NULL, 0 },
 
/* Using $fp doesn't gain us much, even when debugging is
important. */
{ OPT_LEVELS_ALL, OPT_fomit_frame_pointer, NULL, 1 },
 
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
static bool
mep_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
 
switch (code)
{
case OPT_mall_opts:
opts->x_target_flags |= MEP_ALL_OPTS;
break;
 
case OPT_mno_opts:
opts->x_target_flags &= ~ MEP_ALL_OPTS;
break;
 
case OPT_mcop64:
opts->x_target_flags |= MASK_COP;
opts->x_target_flags |= MASK_64BIT_CR_REGS;
break;
 
case OPT_mivc2:
opts->x_target_flags |= MASK_COP;
opts->x_target_flags |= MASK_64BIT_CR_REGS;
opts->x_target_flags |= MASK_VLIW;
opts->x_target_flags |= MASK_OPT_VL64;
opts->x_target_flags |= MASK_IVC2;
 
/* Remaining handling of this option deferred. */
break;
 
default:
break;
}
return TRUE;
}
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION mep_handle_option
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE mep_option_optimization_table
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/m32r/m32r-common.c
0,0 → 1,76
/* Common hooks for Renesas M32R.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
static const struct default_options m32r_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fregmove, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
m32r_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
int value = decoded->value;
 
switch (code)
{
case OPT_m32r:
opts->x_target_flags &= ~(MASK_M32R2 | MASK_M32RX);
return true;
 
case OPT_mno_flush_func:
opts->x_m32r_cache_flush_func = NULL;
return true;
 
case OPT_mflush_trap_:
return value <= 15;
 
default:
return true;
}
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_CPU_DEFAULT
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION m32r_handle_option
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE m32r_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/m68k/m68k-common.c
0,0 → 1,76
/* Common hooks for Motorola 68000 family.
Copyright (C) 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
m68k_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
 
switch (code)
{
case OPT_m68020_40:
opts->x_m68k_tune_option = u68020_40;
opts->x_m68k_cpu_option = m68020;
return true;
 
case OPT_m68020_60:
opts->x_m68k_tune_option = u68020_60;
opts->x_m68k_cpu_option = m68020;
return true;
 
case OPT_mshared_library_id_:
if (value > MAX_LIBRARY_ID)
error_at (loc, "-mshared-library-id=%s is not between 0 and %d",
arg, MAX_LIBRARY_ID);
else
{
char *tmp;
asprintf (&tmp, "%d", (value * -4) - 4);
opts->x_m68k_library_id_string = tmp;
}
return true;
 
default:
return true;
}
}
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION m68k_handle_option
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/i386/i386-common.c
0,0 → 1,672
/* IA-32 common hooks.
Copyright (C) 1988, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "tm_p.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Define a set of ISAs which are available when a given ISA is
enabled. MMX and SSE ISAs are handled separately. */
 
#define OPTION_MASK_ISA_MMX_SET OPTION_MASK_ISA_MMX
#define OPTION_MASK_ISA_3DNOW_SET \
(OPTION_MASK_ISA_3DNOW | OPTION_MASK_ISA_MMX_SET)
 
#define OPTION_MASK_ISA_SSE_SET OPTION_MASK_ISA_SSE
#define OPTION_MASK_ISA_SSE2_SET \
(OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE_SET)
#define OPTION_MASK_ISA_SSE3_SET \
(OPTION_MASK_ISA_SSE3 | OPTION_MASK_ISA_SSE2_SET)
#define OPTION_MASK_ISA_SSSE3_SET \
(OPTION_MASK_ISA_SSSE3 | OPTION_MASK_ISA_SSE3_SET)
#define OPTION_MASK_ISA_SSE4_1_SET \
(OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_SSSE3_SET)
#define OPTION_MASK_ISA_SSE4_2_SET \
(OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_SSE4_1_SET)
#define OPTION_MASK_ISA_AVX_SET \
(OPTION_MASK_ISA_AVX | OPTION_MASK_ISA_SSE4_2_SET)
#define OPTION_MASK_ISA_FMA_SET \
(OPTION_MASK_ISA_FMA | OPTION_MASK_ISA_AVX_SET)
#define OPTION_MASK_ISA_AVX2_SET \
(OPTION_MASK_ISA_AVX2 | OPTION_MASK_ISA_AVX_SET)
 
/* SSE4 includes both SSE4.1 and SSE4.2. -msse4 should be the same
as -msse4.2. */
#define OPTION_MASK_ISA_SSE4_SET OPTION_MASK_ISA_SSE4_2_SET
 
#define OPTION_MASK_ISA_SSE4A_SET \
(OPTION_MASK_ISA_SSE4A | OPTION_MASK_ISA_SSE3_SET)
#define OPTION_MASK_ISA_FMA4_SET \
(OPTION_MASK_ISA_FMA4 | OPTION_MASK_ISA_SSE4A_SET \
| OPTION_MASK_ISA_AVX_SET)
#define OPTION_MASK_ISA_XOP_SET \
(OPTION_MASK_ISA_XOP | OPTION_MASK_ISA_FMA4_SET)
#define OPTION_MASK_ISA_LWP_SET \
OPTION_MASK_ISA_LWP
 
/* AES and PCLMUL need SSE2 because they use xmm registers */
#define OPTION_MASK_ISA_AES_SET \
(OPTION_MASK_ISA_AES | OPTION_MASK_ISA_SSE2_SET)
#define OPTION_MASK_ISA_PCLMUL_SET \
(OPTION_MASK_ISA_PCLMUL | OPTION_MASK_ISA_SSE2_SET)
 
#define OPTION_MASK_ISA_ABM_SET \
(OPTION_MASK_ISA_ABM | OPTION_MASK_ISA_POPCNT)
 
#define OPTION_MASK_ISA_BMI_SET OPTION_MASK_ISA_BMI
#define OPTION_MASK_ISA_BMI2_SET OPTION_MASK_ISA_BMI2
#define OPTION_MASK_ISA_TBM_SET OPTION_MASK_ISA_TBM
#define OPTION_MASK_ISA_POPCNT_SET OPTION_MASK_ISA_POPCNT
#define OPTION_MASK_ISA_CX16_SET OPTION_MASK_ISA_CX16
#define OPTION_MASK_ISA_SAHF_SET OPTION_MASK_ISA_SAHF
#define OPTION_MASK_ISA_MOVBE_SET OPTION_MASK_ISA_MOVBE
#define OPTION_MASK_ISA_CRC32_SET OPTION_MASK_ISA_CRC32
 
#define OPTION_MASK_ISA_FSGSBASE_SET OPTION_MASK_ISA_FSGSBASE
#define OPTION_MASK_ISA_RDRND_SET OPTION_MASK_ISA_RDRND
#define OPTION_MASK_ISA_F16C_SET \
(OPTION_MASK_ISA_F16C | OPTION_MASK_ISA_AVX_SET)
 
/* Define a set of ISAs which aren't available when a given ISA is
disabled. MMX and SSE ISAs are handled separately. */
 
#define OPTION_MASK_ISA_MMX_UNSET \
(OPTION_MASK_ISA_MMX | OPTION_MASK_ISA_3DNOW_UNSET)
#define OPTION_MASK_ISA_3DNOW_UNSET \
(OPTION_MASK_ISA_3DNOW | OPTION_MASK_ISA_3DNOW_A_UNSET)
#define OPTION_MASK_ISA_3DNOW_A_UNSET OPTION_MASK_ISA_3DNOW_A
 
#define OPTION_MASK_ISA_SSE_UNSET \
(OPTION_MASK_ISA_SSE | OPTION_MASK_ISA_SSE2_UNSET)
#define OPTION_MASK_ISA_SSE2_UNSET \
(OPTION_MASK_ISA_SSE2 | OPTION_MASK_ISA_SSE3_UNSET)
#define OPTION_MASK_ISA_SSE3_UNSET \
(OPTION_MASK_ISA_SSE3 \
| OPTION_MASK_ISA_SSSE3_UNSET \
| OPTION_MASK_ISA_SSE4A_UNSET )
#define OPTION_MASK_ISA_SSSE3_UNSET \
(OPTION_MASK_ISA_SSSE3 | OPTION_MASK_ISA_SSE4_1_UNSET)
#define OPTION_MASK_ISA_SSE4_1_UNSET \
(OPTION_MASK_ISA_SSE4_1 | OPTION_MASK_ISA_SSE4_2_UNSET)
#define OPTION_MASK_ISA_SSE4_2_UNSET \
(OPTION_MASK_ISA_SSE4_2 | OPTION_MASK_ISA_AVX_UNSET )
#define OPTION_MASK_ISA_AVX_UNSET \
(OPTION_MASK_ISA_AVX | OPTION_MASK_ISA_FMA_UNSET \
| OPTION_MASK_ISA_FMA4_UNSET | OPTION_MASK_ISA_F16C_UNSET \
| OPTION_MASK_ISA_AVX2_UNSET)
#define OPTION_MASK_ISA_FMA_UNSET OPTION_MASK_ISA_FMA
#define OPTION_MASK_ISA_AVX2_UNSET OPTION_MASK_ISA_AVX2
 
/* SSE4 includes both SSE4.1 and SSE4.2. -mno-sse4 should the same
as -mno-sse4.1. */
#define OPTION_MASK_ISA_SSE4_UNSET OPTION_MASK_ISA_SSE4_1_UNSET
 
#define OPTION_MASK_ISA_SSE4A_UNSET \
(OPTION_MASK_ISA_SSE4A | OPTION_MASK_ISA_FMA4_UNSET)
 
#define OPTION_MASK_ISA_FMA4_UNSET \
(OPTION_MASK_ISA_FMA4 | OPTION_MASK_ISA_XOP_UNSET)
#define OPTION_MASK_ISA_XOP_UNSET OPTION_MASK_ISA_XOP
#define OPTION_MASK_ISA_LWP_UNSET OPTION_MASK_ISA_LWP
 
#define OPTION_MASK_ISA_AES_UNSET OPTION_MASK_ISA_AES
#define OPTION_MASK_ISA_PCLMUL_UNSET OPTION_MASK_ISA_PCLMUL
#define OPTION_MASK_ISA_ABM_UNSET OPTION_MASK_ISA_ABM
#define OPTION_MASK_ISA_BMI_UNSET OPTION_MASK_ISA_BMI
#define OPTION_MASK_ISA_BMI2_UNSET OPTION_MASK_ISA_BMI2
#define OPTION_MASK_ISA_TBM_UNSET OPTION_MASK_ISA_TBM
#define OPTION_MASK_ISA_POPCNT_UNSET OPTION_MASK_ISA_POPCNT
#define OPTION_MASK_ISA_CX16_UNSET OPTION_MASK_ISA_CX16
#define OPTION_MASK_ISA_SAHF_UNSET OPTION_MASK_ISA_SAHF
#define OPTION_MASK_ISA_MOVBE_UNSET OPTION_MASK_ISA_MOVBE
#define OPTION_MASK_ISA_CRC32_UNSET OPTION_MASK_ISA_CRC32
 
#define OPTION_MASK_ISA_FSGSBASE_UNSET OPTION_MASK_ISA_FSGSBASE
#define OPTION_MASK_ISA_RDRND_UNSET OPTION_MASK_ISA_RDRND
#define OPTION_MASK_ISA_F16C_UNSET OPTION_MASK_ISA_F16C
 
/* Implement TARGET_HANDLE_OPTION. */
 
bool
ix86_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
int value = decoded->value;
 
switch (code)
{
case OPT_mmmx:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_MMX_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_MMX_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_MMX_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_MMX_UNSET;
}
return true;
 
case OPT_m3dnow:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_3DNOW_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_3DNOW_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_3DNOW_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_3DNOW_UNSET;
}
return true;
 
case OPT_m3dnowa:
return false;
 
case OPT_msse:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE_UNSET;
}
return true;
 
case OPT_msse2:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE2_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE2_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE2_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE2_UNSET;
}
return true;
 
case OPT_msse3:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE3_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE3_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE3_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE3_UNSET;
}
return true;
 
case OPT_mssse3:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSSE3_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSSE3_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSSE3_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSSE3_UNSET;
}
return true;
 
case OPT_msse4_1:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4_1_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_1_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_1_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_1_UNSET;
}
return true;
 
case OPT_msse4_2:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4_2_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_2_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_2_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_2_UNSET;
}
return true;
 
case OPT_mavx:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_AVX_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_AVX_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_AVX_UNSET;
}
return true;
 
case OPT_mavx2:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AVX2_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_AVX2_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_AVX2_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_AVX2_UNSET;
}
return true;
 
case OPT_mfma:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FMA_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_FMA_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA_UNSET;
}
return true;
 
case OPT_msse4:
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_SET;
return true;
 
case OPT_mno_sse4:
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4_UNSET;
return true;
 
case OPT_msse4a:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SSE4A_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4A_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SSE4A_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SSE4A_UNSET;
}
return true;
 
case OPT_mfma4:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FMA4_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA4_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_FMA4_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_FMA4_UNSET;
}
return true;
 
case OPT_mxop:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_XOP_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_XOP_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_XOP_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_XOP_UNSET;
}
return true;
 
case OPT_mlwp:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_LWP_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_LWP_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_LWP_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_LWP_UNSET;
}
return true;
 
case OPT_mabm:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_ABM_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_ABM_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_ABM_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_ABM_UNSET;
}
return true;
 
case OPT_mbmi:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_BMI_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_BMI_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_BMI_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_BMI_UNSET;
}
return true;
 
case OPT_mbmi2:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_BMI2_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_BMI2_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_BMI2_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_BMI2_UNSET;
}
return true;
 
case OPT_mtbm:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_TBM_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_TBM_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_TBM_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_TBM_UNSET;
}
return true;
 
case OPT_mpopcnt:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_POPCNT_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_POPCNT_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_POPCNT_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_POPCNT_UNSET;
}
return true;
 
case OPT_msahf:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_SAHF_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SAHF_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_SAHF_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_SAHF_UNSET;
}
return true;
 
case OPT_mcx16:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_CX16_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_CX16_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_CX16_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_CX16_UNSET;
}
return true;
 
case OPT_mmovbe:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_MOVBE_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_MOVBE_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_MOVBE_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_MOVBE_UNSET;
}
return true;
 
case OPT_mcrc32:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_CRC32_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_CRC32_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_CRC32_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_CRC32_UNSET;
}
return true;
 
case OPT_maes:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_AES_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_AES_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_AES_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_AES_UNSET;
}
return true;
 
case OPT_mpclmul:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PCLMUL_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_PCLMUL_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_PCLMUL_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_PCLMUL_UNSET;
}
return true;
 
case OPT_mfsgsbase:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_FSGSBASE_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_FSGSBASE_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_FSGSBASE_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_FSGSBASE_UNSET;
}
return true;
 
case OPT_mrdrnd:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_RDRND_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_RDRND_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_RDRND_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_RDRND_UNSET;
}
return true;
 
case OPT_mf16c:
if (value)
{
opts->x_ix86_isa_flags |= OPTION_MASK_ISA_F16C_SET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_F16C_SET;
}
else
{
opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_F16C_UNSET;
opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_F16C_UNSET;
}
return true;
 
/* Comes from final.c -- no real reason to change it. */
#define MAX_CODE_ALIGN 16
 
case OPT_malign_loops_:
warning_at (loc, 0, "-malign-loops is obsolete, use -falign-loops");
if (value > MAX_CODE_ALIGN)
error_at (loc, "-malign-loops=%d is not between 0 and %d",
value, MAX_CODE_ALIGN);
else
opts->x_align_loops = 1 << value;
return true;
 
case OPT_malign_jumps_:
warning_at (loc, 0, "-malign-jumps is obsolete, use -falign-jumps");
if (value > MAX_CODE_ALIGN)
error_at (loc, "-malign-jumps=%d is not between 0 and %d",
value, MAX_CODE_ALIGN);
else
opts->x_align_jumps = 1 << value;
return true;
 
case OPT_malign_functions_:
warning_at (loc, 0,
"-malign-functions is obsolete, use -falign-functions");
if (value > MAX_CODE_ALIGN)
error_at (loc, "-malign-functions=%d is not between 0 and %d",
value, MAX_CODE_ALIGN);
else
opts->x_align_functions = 1 << value;
return true;
 
case OPT_mbranch_cost_:
if (value > 5)
{
error_at (loc, "-mbranch-cost=%d is not between 0 and 5", value);
opts->x_ix86_branch_cost = 5;
}
return true;
 
default:
return true;
}
}
 
static const struct default_options ix86_option_optimization_table[] =
{
/* Enable redundant extension instructions removal at -O2 and higher. */
{ OPT_LEVELS_2_PLUS, OPT_free, NULL, 1 },
/* Turn off -fschedule-insns by default. It tends to make the
problem with not enough registers even worse. */
{ OPT_LEVELS_ALL, OPT_fschedule_insns, NULL, 0 },
 
#ifdef SUBTARGET_OPTIMIZATION_OPTIONS
SUBTARGET_OPTIMIZATION_OPTIONS,
#endif
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_OPTION_INIT_STRUCT. */
 
static void
ix86_option_init_struct (struct gcc_options *opts)
{
if (TARGET_MACHO)
/* The Darwin libraries never set errno, so we might as well
avoid calling them when that's the only reason we would. */
opts->x_flag_errno_math = 0;
 
opts->x_flag_pcc_struct_return = 2;
opts->x_flag_asynchronous_unwind_tables = 2;
opts->x_flag_vect_cost_model = 1;
}
 
/* On the x86 -fsplit-stack and -fstack-protector both use the same
field in the TCB, so they can not be used together. */
 
static bool
ix86_supports_split_stack (bool report ATTRIBUTE_UNUSED,
struct gcc_options *opts ATTRIBUTE_UNUSED)
{
bool ret = true;
 
#ifndef TARGET_THREAD_SPLIT_STACK_OFFSET
if (report)
error ("%<-fsplit-stack%> currently only supported on GNU/Linux");
ret = false;
#else
if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
{
if (report)
error ("%<-fsplit-stack%> requires "
"assembler support for CFI directives");
ret = false;
}
#endif
 
return ret;
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS \
(TARGET_DEFAULT \
| TARGET_SUBTARGET_DEFAULT \
| TARGET_TLS_DIRECT_SEG_REFS_DEFAULT)
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION ix86_handle_option
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE ix86_option_optimization_table
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT ix86_option_init_struct
 
#undef TARGET_SUPPORTS_SPLIT_STACK
#define TARGET_SUPPORTS_SPLIT_STACK ix86_supports_split_stack
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/rx/rx-common.c
0,0 → 1,86
/* Common hooks for Renesas RX.
Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Extra processing for target specific command line options. */
 
static bool
rx_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
int value = decoded->value;
 
switch (code)
{
case OPT_mint_register_:
/* Make sure that the -mint-register option is in range. Other
handling in rx_option_override. */
return value >= 0 && value <= 4;
break;
 
case OPT_mmax_constant_size_:
/* Make sure that the -mmax-constant_size option is in range. */
return value >= 0 && value <= 4;
 
case OPT_mcpu_:
if ((enum rx_cpu_types) value == RX200)
opts->x_target_flags |= MASK_NO_USE_FPU;
break;
case OPT_fpu:
if (opts->x_rx_cpu_type == RX200)
error_at (loc, "the RX200 cpu does not have FPU hardware");
break;
 
default:
break;
}
 
return true;
}
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options rx_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION rx_handle_option
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE rx_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/rs6000/rs6000-common.c
0,0 → 1,341
/* Common hooks for IBM RS/6000.
Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
#include "params.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options rs6000_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_OPTION_INIT_STRUCT. */
 
static void
rs6000_option_init_struct (struct gcc_options *opts)
{
if (DEFAULT_ABI == ABI_DARWIN)
/* The Darwin libraries never set errno, so we might as well
avoid calling them when that's the only reason we would. */
opts->x_flag_errno_math = 0;
 
/* Enable section anchors by default. */
if (!TARGET_MACHO)
opts->x_flag_section_anchors = 1;
}
 
/* Implement TARGET_OPTION_DEFAULT_PARAMS. */
 
static void
rs6000_option_default_params (void)
{
/* Double growth factor to counter reduced min jump length. */
set_default_param_value (PARAM_MAX_GROW_COPY_BB_INSNS, 16);
}
 
/* If not otherwise specified by a target, make 'long double' equivalent to
'double'. */
 
#ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
#define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
#endif
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
rs6000_handle_option (struct gcc_options *opts, struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
location_t loc)
{
enum fpu_type_t fpu_type = FPU_NONE;
char *p, *q;
size_t code = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
 
switch (code)
{
case OPT_mno_power:
opts->x_target_flags &= ~(MASK_POWER | MASK_POWER2
| MASK_MULTIPLE | MASK_STRING);
opts_set->x_target_flags |= (MASK_POWER | MASK_POWER2
| MASK_MULTIPLE | MASK_STRING);
break;
case OPT_mno_powerpc:
opts->x_target_flags &= ~(MASK_POWERPC | MASK_PPC_GPOPT
| MASK_PPC_GFXOPT | MASK_POWERPC64);
opts_set->x_target_flags |= (MASK_POWERPC | MASK_PPC_GPOPT
| MASK_PPC_GFXOPT | MASK_POWERPC64);
break;
case OPT_mfull_toc:
opts->x_target_flags &= ~MASK_MINIMAL_TOC;
opts->x_TARGET_NO_FP_IN_TOC = 0;
opts->x_TARGET_NO_SUM_IN_TOC = 0;
opts_set->x_target_flags |= MASK_MINIMAL_TOC;
#ifdef TARGET_USES_SYSV4_OPT
/* Note, V.4 no longer uses a normal TOC, so make -mfull-toc, be
just the same as -mminimal-toc. */
opts->x_target_flags |= MASK_MINIMAL_TOC;
opts_set->x_target_flags |= MASK_MINIMAL_TOC;
#endif
break;
 
#ifdef TARGET_USES_SYSV4_OPT
case OPT_mtoc:
/* Make -mtoc behave like -mminimal-toc. */
opts->x_target_flags |= MASK_MINIMAL_TOC;
opts_set->x_target_flags |= MASK_MINIMAL_TOC;
break;
#endif
 
#ifdef TARGET_USES_AIX64_OPT
case OPT_maix64:
#else
case OPT_m64:
#endif
opts->x_target_flags |= MASK_POWERPC64 | MASK_POWERPC;
opts->x_target_flags |= ~opts_set->x_target_flags & MASK_PPC_GFXOPT;
opts_set->x_target_flags |= MASK_POWERPC64 | MASK_POWERPC;
break;
 
#ifdef TARGET_USES_AIX64_OPT
case OPT_maix32:
#else
case OPT_m32:
#endif
opts->x_target_flags &= ~MASK_POWERPC64;
opts_set->x_target_flags |= MASK_POWERPC64;
break;
 
case OPT_mminimal_toc:
if (value == 1)
{
opts->x_TARGET_NO_FP_IN_TOC = 0;
opts->x_TARGET_NO_SUM_IN_TOC = 0;
}
break;
 
case OPT_mpower:
if (value == 1)
{
opts->x_target_flags |= (MASK_MULTIPLE | MASK_STRING);
opts_set->x_target_flags |= (MASK_MULTIPLE | MASK_STRING);
}
break;
 
case OPT_mpower2:
if (value == 1)
{
opts->x_target_flags |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
opts_set->x_target_flags |= (MASK_POWER
| MASK_MULTIPLE
| MASK_STRING);
}
break;
 
case OPT_mpowerpc_gpopt:
case OPT_mpowerpc_gfxopt:
if (value == 1)
{
opts->x_target_flags |= MASK_POWERPC;
opts_set->x_target_flags |= MASK_POWERPC;
}
break;
 
case OPT_mdebug_:
p = ASTRDUP (arg);
opts->x_rs6000_debug = 0;
 
while ((q = strtok (p, ",")) != NULL)
{
unsigned mask = 0;
bool invert;
 
p = NULL;
if (*q == '!')
{
invert = true;
q++;
}
else
invert = false;
 
if (! strcmp (q, "all"))
mask = MASK_DEBUG_ALL;
else if (! strcmp (q, "stack"))
mask = MASK_DEBUG_STACK;
else if (! strcmp (q, "arg"))
mask = MASK_DEBUG_ARG;
else if (! strcmp (q, "reg"))
mask = MASK_DEBUG_REG;
else if (! strcmp (q, "addr"))
mask = MASK_DEBUG_ADDR;
else if (! strcmp (q, "cost"))
mask = MASK_DEBUG_COST;
else if (! strcmp (q, "target"))
mask = MASK_DEBUG_TARGET;
else if (! strcmp (q, "builtin"))
mask = MASK_DEBUG_BUILTIN;
else
error_at (loc, "unknown -mdebug-%s switch", q);
 
if (invert)
opts->x_rs6000_debug &= ~mask;
else
opts->x_rs6000_debug |= mask;
}
break;
 
#ifdef TARGET_USES_SYSV4_OPT
case OPT_mrelocatable:
if (value == 1)
{
opts->x_target_flags |= MASK_MINIMAL_TOC;
opts_set->x_target_flags |= MASK_MINIMAL_TOC;
opts->x_TARGET_NO_FP_IN_TOC = 1;
}
break;
 
case OPT_mrelocatable_lib:
if (value == 1)
{
opts->x_target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
opts_set->x_target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
opts->x_TARGET_NO_FP_IN_TOC = 1;
}
else
{
opts->x_target_flags &= ~MASK_RELOCATABLE;
opts_set->x_target_flags |= MASK_RELOCATABLE;
}
break;
#endif
 
case OPT_mabi_altivec:
/* Enabling the AltiVec ABI turns off the SPE ABI. */
opts->x_rs6000_spe_abi = 0;
break;
 
case OPT_mabi_spe:
opts->x_rs6000_altivec_abi = 0;
break;
 
case OPT_mlong_double_:
if (value != 64 && value != 128)
{
error_at (loc, "unknown switch -mlong-double-%s", arg);
opts->x_rs6000_long_double_type_size
= RS6000_DEFAULT_LONG_DOUBLE_SIZE;
return false;
}
break;
 
case OPT_msingle_float:
if (!TARGET_SINGLE_FPU)
warning_at (loc, 0,
"-msingle-float option equivalent to -mhard-float");
/* -msingle-float implies -mno-double-float and TARGET_HARD_FLOAT. */
opts->x_rs6000_double_float = 0;
opts->x_target_flags &= ~MASK_SOFT_FLOAT;
opts_set->x_target_flags |= MASK_SOFT_FLOAT;
break;
 
case OPT_mdouble_float:
/* -mdouble-float implies -msingle-float and TARGET_HARD_FLOAT. */
opts->x_rs6000_single_float = 1;
opts->x_target_flags &= ~MASK_SOFT_FLOAT;
opts_set->x_target_flags |= MASK_SOFT_FLOAT;
break;
 
case OPT_msimple_fpu:
if (!TARGET_SINGLE_FPU)
warning_at (loc, 0, "-msimple-fpu option ignored");
break;
 
case OPT_mhard_float:
/* -mhard_float implies -msingle-float and -mdouble-float. */
opts->x_rs6000_single_float = opts->x_rs6000_double_float = 1;
break;
 
case OPT_msoft_float:
/* -msoft_float implies -mnosingle-float and -mnodouble-float. */
opts->x_rs6000_single_float = opts->x_rs6000_double_float = 0;
break;
 
case OPT_mfpu_:
fpu_type = (enum fpu_type_t) value;
if (fpu_type != FPU_NONE)
{
/* If -mfpu is not none, then turn off SOFT_FLOAT, turn on
HARD_FLOAT. */
opts->x_target_flags &= ~MASK_SOFT_FLOAT;
opts_set->x_target_flags |= MASK_SOFT_FLOAT;
opts->x_rs6000_xilinx_fpu = 1;
if (fpu_type == FPU_SF_LITE || fpu_type == FPU_SF_FULL)
opts->x_rs6000_single_float = 1;
if (fpu_type == FPU_DF_LITE || fpu_type == FPU_DF_FULL)
opts->x_rs6000_single_float = opts->x_rs6000_double_float = 1;
if (fpu_type == FPU_SF_LITE || fpu_type == FPU_DF_LITE)
opts->x_rs6000_simple_fpu = 1;
}
else
{
/* -mfpu=none is equivalent to -msoft-float. */
opts->x_target_flags |= MASK_SOFT_FLOAT;
opts_set->x_target_flags |= MASK_SOFT_FLOAT;
opts->x_rs6000_single_float = opts->x_rs6000_double_float = 0;
}
break;
 
case OPT_mrecip:
opts->x_rs6000_recip_name = (value) ? "default" : "none";
break;
}
return true;
}
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION rs6000_handle_option
 
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT rs6000_option_init_struct
 
#undef TARGET_OPTION_DEFAULT_PARAMS
#define TARGET_OPTION_DEFAULT_PARAMS rs6000_option_default_params
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE rs6000_option_optimization_table
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS \
(TARGET_DEFAULT)
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/default-common.c
0,0 → 1,34
/* Default common target hooks initializer.
Copyright (C) 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Do not include tm.h or tm_p.h here; if it is useful for a target to
define some macros for the initializer in a header without defining
targetm_common itself (for example, because of interactions with
some hooks depending on the target OS and others on the target
architecture), create a separate tm_common.h for only the relevant
definitions. */
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/tilegx/tilegx-common.c
0,0 → 1,55
/* Common hooks for TILE-Gx.
Copyright (C) 2011, 2012
Free Software Foundation, Inc.
Contributed by Walter Lee (walt@tilera.com)
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
static const struct default_options tilegx_option_optimization_table[] = {
{OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1},
/* Scheduling and bundling are super important for our architecture, so
enable them at -O1. */
{OPT_LEVELS_1_PLUS, OPT_fschedule_insns, NULL, 1},
{OPT_LEVELS_1_PLUS, OPT_fschedule_insns2, NULL, 1},
{OPT_LEVELS_NONE, 0, NULL, 0}
};
 
 
static void
tilegx_option_init_struct (struct gcc_options *opts)
{
opts->x_flag_asynchronous_unwind_tables = 1;
}
 
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE tilegx_option_optimization_table
 
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT tilegx_option_init_struct
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/vax/vax-common.c
0,0 → 1,32
/* Common hooks for VAX.
Copyright (C) 1987, 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002,
2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/picochip/picochip-common.c
0,0 → 1,40
/* Common hooks for picoChip.
Copyright (C) 2001, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not, see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options picochip_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE picochip_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/cris/cris-common.c
0,0 → 1,105
/* Common hooks for CRIS.
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
 
static const struct default_options cris_option_optimization_table[] =
{
{ OPT_LEVELS_2_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* TARGET_HANDLE_OPTION worker. We just store the values into local
variables here. Checks for correct semantics are in
cris_option_override. */
 
static bool
cris_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
 
switch (code)
{
case OPT_metrax100:
opts->x_target_flags
|= (MASK_SVINTO
+ MASK_ETRAX4_ADD
+ MASK_ALIGN_BY_32);
break;
 
case OPT_mno_etrax100:
opts->x_target_flags
&= ~(MASK_SVINTO
+ MASK_ETRAX4_ADD
+ MASK_ALIGN_BY_32);
break;
 
case OPT_m32_bit:
case OPT_m32bit:
opts->x_target_flags
|= (MASK_STACK_ALIGN
+ MASK_CONST_ALIGN
+ MASK_DATA_ALIGN
+ MASK_ALIGN_BY_32);
break;
 
case OPT_m16_bit:
case OPT_m16bit:
opts->x_target_flags
|= (MASK_STACK_ALIGN
+ MASK_CONST_ALIGN
+ MASK_DATA_ALIGN);
break;
 
case OPT_m8_bit:
case OPT_m8bit:
opts->x_target_flags
&= ~(MASK_STACK_ALIGN
+ MASK_CONST_ALIGN
+ MASK_DATA_ALIGN);
break;
 
default:
break;
}
 
return true;
}
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | CRIS_SUBTARGET_DEFAULT)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION cris_handle_option
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE cris_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/v850/v850-common.c
0,0 → 1,133
/* Common hooks for NEC V850 series.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Information about the various small memory areas. */
static const int small_memory_physical_max[(int) SMALL_MEMORY_max] =
{
256,
65536,
32768,
};
 
/* Set the maximum size of small memory area TYPE to the value given
by SIZE in structure OPTS (option text OPT passed at location LOC). */
 
static void
v850_handle_memory_option (enum small_memory_type type,
struct gcc_options *opts, const char *opt,
int size, location_t loc)
{
if (size > small_memory_physical_max[type])
error_at (loc, "value passed in %qs is too large", opt);
else
opts->x_small_memory_max[type] = size;
}
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
v850_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
int value = decoded->value;
 
switch (code)
{
case OPT_mspace:
opts->x_target_flags |= MASK_EP | MASK_PROLOG_FUNCTION;
return true;
 
case OPT_mv850:
opts->x_target_flags &= ~(MASK_CPU ^ MASK_V850);
return true;
 
case OPT_mv850e:
case OPT_mv850e1:
case OPT_mv850es:
opts->x_target_flags &= ~(MASK_CPU ^ MASK_V850E);
return true;
 
case OPT_mv850e2:
opts->x_target_flags &= ~(MASK_CPU ^ MASK_V850E2);
return true;
 
case OPT_mv850e2v3:
opts->x_target_flags &= ~(MASK_CPU ^ MASK_V850E2V3);
return true;
 
case OPT_mtda_:
v850_handle_memory_option (SMALL_MEMORY_TDA, opts,
decoded->orig_option_with_args_text,
value, loc);
return true;
 
case OPT_msda_:
v850_handle_memory_option (SMALL_MEMORY_SDA, opts,
decoded->orig_option_with_args_text,
value, loc);
return true;
 
case OPT_mzda_:
v850_handle_memory_option (SMALL_MEMORY_ZDA, opts,
decoded->orig_option_with_args_text,
value, loc);
return true;
 
default:
return true;
}
}
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
 
static const struct default_options v850_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
/* Note - we no longer enable MASK_EP when optimizing. This is
because of a hardware bug which stops the SLD and SST instructions
from correctly detecting some hazards. If the user is sure that
their hardware is fixed or that their program will not encounter
the conditions that trigger the bug then they can enable -mep by
hand. */
{ OPT_LEVELS_1_PLUS, OPT_mprolog_function, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS (MASK_DEFAULT | MASK_APP_REGS)
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION v850_handle_option
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE v850_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/h8300/h8300-common.c
0,0 → 1,49
/* Common hooks for Renesas H8/300.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
 
static const struct default_options h8300_option_optimization_table[] =
{
/* Basic block reordering is only beneficial on targets with cache
and/or variable-cycle branches where (cycle count taken !=
cycle count not taken). */
{ OPT_LEVELS_ALL, OPT_freorder_blocks, NULL, 0 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE h8300_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/mcore/mcore-common.c
0,0 → 1,54
/* Common hooks for Motorola MCore.
Copyright (C) 1993, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
2009, 2010, 2011 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* What options are we going to default to specific settings when
-O* happens; the user can subsequently override these settings.
Omitting the frame pointer is a very good idea on the MCore.
Scheduling isn't worth anything on the current MCore implementation. */
 
static const struct default_options mcore_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_ffunction_cse, NULL, 0 },
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_ALL, OPT_fcaller_saves, NULL, 0 },
{ OPT_LEVELS_ALL, OPT_fschedule_insns, NULL, 0 },
{ OPT_LEVELS_ALL, OPT_fschedule_insns2, NULL, 0 },
{ OPT_LEVELS_SIZE, OPT_mhardlit, NULL, 0 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE mcore_option_optimization_table
 
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/sh/sh-common.c
0,0 → 1,218
/* Common hooks for Renesas / SuperH SH.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
#include "params.h"
 
/* Set default optimization options. */
static const struct default_options sh_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_1_PLUS_SPEED_ONLY, OPT_mdiv_, "inv:minlat", 1 },
{ OPT_LEVELS_SIZE, OPT_mdiv_, SH_DIV_STR_FOR_SIZE, 1 },
{ OPT_LEVELS_0_ONLY, OPT_mdiv_, "", 1 },
{ OPT_LEVELS_SIZE, OPT_mcbranchdi, NULL, 0 },
/* We can't meaningfully test TARGET_SHMEDIA here, because -m
options haven't been parsed yet, hence we'd read only the
default. sh_target_reg_class will return NO_REGS if this is
not SHMEDIA, so it's OK to always set
flag_branch_target_load_optimize. */
{ OPT_LEVELS_2_PLUS, OPT_fbranch_target_load_optimize, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
sh_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
 
switch (code)
{
case OPT_m1:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH1;
return true;
 
case OPT_m2:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH2;
return true;
 
case OPT_m2a:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH2A;
return true;
 
case OPT_m2a_nofpu:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH2A_NOFPU;
return true;
 
case OPT_m2a_single:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH2A_SINGLE;
return true;
 
case OPT_m2a_single_only:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH2A_SINGLE_ONLY;
return true;
 
case OPT_m2e:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH2E;
return true;
 
case OPT_m3:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH3;
return true;
 
case OPT_m3e:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH3E;
return true;
 
case OPT_m4:
case OPT_m4_100:
case OPT_m4_200:
case OPT_m4_300:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4;
return true;
 
case OPT_m4_nofpu:
case OPT_m4_100_nofpu:
case OPT_m4_200_nofpu:
case OPT_m4_300_nofpu:
case OPT_m4_340:
case OPT_m4_400:
case OPT_m4_500:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4_NOFPU;
return true;
 
case OPT_m4_single:
case OPT_m4_100_single:
case OPT_m4_200_single:
case OPT_m4_300_single:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4_SINGLE;
return true;
 
case OPT_m4_single_only:
case OPT_m4_100_single_only:
case OPT_m4_200_single_only:
case OPT_m4_300_single_only:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4_SINGLE_ONLY;
return true;
 
case OPT_m4a:
opts->x_target_flags = (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4A;
return true;
 
case OPT_m4a_nofpu:
case OPT_m4al:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4A_NOFPU;
return true;
 
case OPT_m4a_single:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4A_SINGLE;
return true;
 
case OPT_m4a_single_only:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH4A_SINGLE_ONLY;
return true;
 
case OPT_m5_32media:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH5_32MEDIA;
return true;
 
case OPT_m5_32media_nofpu:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH5_32MEDIA_NOFPU;
return true;
 
case OPT_m5_64media:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH5_64MEDIA;
return true;
 
case OPT_m5_64media_nofpu:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH5_64MEDIA_NOFPU;
return true;
 
case OPT_m5_compact:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH5_COMPACT;
return true;
 
case OPT_m5_compact_nofpu:
opts->x_target_flags
= (opts->x_target_flags & ~MASK_ARCH) | SELECT_SH5_COMPACT_NOFPU;
return true;
 
default:
return true;
}
}
 
/* Implement TARGET_OPTION_INIT_STRUCT. */
static void
sh_option_init_struct (struct gcc_options *opts)
{
/* We can't meaningfully test TARGET_SH2E / TARGET_IEEE
here, so leave it to TARGET_OPTION_OVERRIDE to set
flag_finite_math_only. We set it to 2 here so we know if the user
explicitly requested this to be on or off. */
opts->x_flag_finite_math_only = 2;
}
 
/* Implement TARGET_OPTION_DEFAULT_PARAMS. */
static void
sh_option_default_params (void)
{
set_default_param_value (PARAM_SIMULTANEOUS_PREFETCHES, 2);
}
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE sh_option_optimization_table
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT sh_option_init_struct
#undef TARGET_OPTION_DEFAULT_PARAMS
#define TARGET_OPTION_DEFAULT_PARAMS sh_option_default_params
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION sh_handle_option
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/mmix/mmix-common.c
0,0 → 1,44
/* Common hooks for MMIX.
Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* TARGET_OPTION_OPTIMIZATION_TABLE. */
 
static const struct default_options mmix_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fregmove, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE mmix_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/score/score-common.c
0,0 → 1,75
/* Common hooks for Sunplus S+CORE.
Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options score_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION score_handle_option
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE score_option_optimization_table
 
#define MASK_ALL_CPU_BITS (MASK_SCORE7 | MASK_SCORE7D)
 
/* Implement TARGET_HANDLE_OPTION. */
static bool
score_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc ATTRIBUTE_UNUSED)
{
size_t code = decoded->opt_index;
int value = decoded->value;
 
switch (code)
{
case OPT_mscore7d:
opts->x_target_flags &= ~(MASK_ALL_CPU_BITS);
opts->x_target_flags |= MASK_SCORE7 | MASK_SCORE7D;
return true;
 
case OPT_march_:
opts->x_target_flags &= ~(MASK_ALL_CPU_BITS);
opts->x_target_flags |= value;
return true;
 
default:
return true;
}
}
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/cr16/cr16-common.c
0,0 → 1,37
/* Common hooks for CR16.
Copyright (C) 2012 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options cr16_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE cr16_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/iq2000/iq2000-common.c
0,0 → 1,38
/* Common hooks for Vitesse IQ2000.
Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
 
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options iq2000_option_optimization_table[] =
{
{ OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE iq2000_option_optimization_table
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/bfin/bfin-common.c
0,0 → 1,390
/* Common hooks for Blackfin.
Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "machmode.h"
#include "tm_p.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
EXPORTED_CONST struct bfin_cpu bfin_cpus[] =
{
 
{"bf512", BFIN_CPU_BF512, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf512", BFIN_CPU_BF512, 0x0001,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf512", BFIN_CPU_BF512, 0x0000,
WA_SPECULATIVE_LOADS | WA_05000074},
 
{"bf514", BFIN_CPU_BF514, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf514", BFIN_CPU_BF514, 0x0001,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf514", BFIN_CPU_BF514, 0x0000,
WA_SPECULATIVE_LOADS | WA_05000074},
 
{"bf516", BFIN_CPU_BF516, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf516", BFIN_CPU_BF516, 0x0001,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf516", BFIN_CPU_BF516, 0x0000,
WA_SPECULATIVE_LOADS | WA_05000074},
 
{"bf518", BFIN_CPU_BF518, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf518", BFIN_CPU_BF518, 0x0001,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf518", BFIN_CPU_BF518, 0x0000,
WA_SPECULATIVE_LOADS | WA_05000074},
 
{"bf522", BFIN_CPU_BF522, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf522", BFIN_CPU_BF522, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
{"bf522", BFIN_CPU_BF522, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
 
{"bf523", BFIN_CPU_BF523, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf523", BFIN_CPU_BF523, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
{"bf523", BFIN_CPU_BF523, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
 
{"bf524", BFIN_CPU_BF524, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf524", BFIN_CPU_BF524, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
{"bf524", BFIN_CPU_BF524, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
 
{"bf525", BFIN_CPU_BF525, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf525", BFIN_CPU_BF525, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
{"bf525", BFIN_CPU_BF525, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
 
{"bf526", BFIN_CPU_BF526, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf526", BFIN_CPU_BF526, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
{"bf526", BFIN_CPU_BF526, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
 
{"bf527", BFIN_CPU_BF527, 0x0002,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf527", BFIN_CPU_BF527, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
{"bf527", BFIN_CPU_BF527, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000074},
 
{"bf531", BFIN_CPU_BF531, 0x0006,
WA_SPECULATIVE_LOADS | WA_LOAD_LCREGS | WA_05000074},
{"bf531", BFIN_CPU_BF531, 0x0005,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000283 | WA_05000315
| WA_LOAD_LCREGS | WA_05000074},
{"bf531", BFIN_CPU_BF531, 0x0004,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf531", BFIN_CPU_BF531, 0x0003,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf532", BFIN_CPU_BF532, 0x0006,
WA_SPECULATIVE_LOADS | WA_LOAD_LCREGS | WA_05000074},
{"bf532", BFIN_CPU_BF532, 0x0005,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000283 | WA_05000315
| WA_LOAD_LCREGS | WA_05000074},
{"bf532", BFIN_CPU_BF532, 0x0004,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf532", BFIN_CPU_BF532, 0x0003,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf533", BFIN_CPU_BF533, 0x0006,
WA_SPECULATIVE_LOADS | WA_LOAD_LCREGS | WA_05000074},
{"bf533", BFIN_CPU_BF533, 0x0005,
WA_SPECULATIVE_LOADS | WA_RETS | WA_05000283 | WA_05000315
| WA_LOAD_LCREGS | WA_05000074},
{"bf533", BFIN_CPU_BF533, 0x0004,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf533", BFIN_CPU_BF533, 0x0003,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf534", BFIN_CPU_BF534, 0x0003,
WA_SPECULATIVE_LOADS | WA_RETS | WA_LOAD_LCREGS | WA_05000074},
{"bf534", BFIN_CPU_BF534, 0x0002,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf534", BFIN_CPU_BF534, 0x0001,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf536", BFIN_CPU_BF536, 0x0003,
WA_SPECULATIVE_LOADS | WA_RETS | WA_LOAD_LCREGS | WA_05000074},
{"bf536", BFIN_CPU_BF536, 0x0002,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf536", BFIN_CPU_BF536, 0x0001,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf537", BFIN_CPU_BF537, 0x0003,
WA_SPECULATIVE_LOADS | WA_RETS | WA_LOAD_LCREGS | WA_05000074},
{"bf537", BFIN_CPU_BF537, 0x0002,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf537", BFIN_CPU_BF537, 0x0001,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf538", BFIN_CPU_BF538, 0x0005,
WA_SPECULATIVE_LOADS | WA_LOAD_LCREGS | WA_05000074},
{"bf538", BFIN_CPU_BF538, 0x0004,
WA_SPECULATIVE_LOADS | WA_RETS | WA_LOAD_LCREGS | WA_05000074},
{"bf538", BFIN_CPU_BF538, 0x0003,
WA_SPECULATIVE_LOADS | WA_RETS
| WA_05000283 | WA_05000315 | WA_LOAD_LCREGS | WA_05000074},
{"bf538", BFIN_CPU_BF538, 0x0002,
WA_SPECULATIVE_LOADS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf539", BFIN_CPU_BF539, 0x0005,
WA_SPECULATIVE_LOADS | WA_LOAD_LCREGS | WA_05000074},
{"bf539", BFIN_CPU_BF539, 0x0004,
WA_SPECULATIVE_LOADS | WA_RETS | WA_LOAD_LCREGS | WA_05000074},
{"bf539", BFIN_CPU_BF539, 0x0003,
WA_SPECULATIVE_LOADS | WA_RETS
| WA_05000283 | WA_05000315 | WA_LOAD_LCREGS | WA_05000074},
{"bf539", BFIN_CPU_BF539, 0x0002,
WA_SPECULATIVE_LOADS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf542m", BFIN_CPU_BF542M, 0x0003,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
 
{"bf542", BFIN_CPU_BF542, 0x0004,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf542", BFIN_CPU_BF542, 0x0002,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf542", BFIN_CPU_BF542, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_05000074},
{"bf542", BFIN_CPU_BF542, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf544m", BFIN_CPU_BF544M, 0x0003,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
 
{"bf544", BFIN_CPU_BF544, 0x0004,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf544", BFIN_CPU_BF544, 0x0002,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf544", BFIN_CPU_BF544, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_05000074},
{"bf544", BFIN_CPU_BF544, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf547m", BFIN_CPU_BF547M, 0x0003,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
 
{"bf547", BFIN_CPU_BF547, 0x0004,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf547", BFIN_CPU_BF547, 0x0002,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf547", BFIN_CPU_BF547, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_05000074},
{"bf547", BFIN_CPU_BF547, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf548m", BFIN_CPU_BF548M, 0x0003,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
 
{"bf548", BFIN_CPU_BF548, 0x0004,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf548", BFIN_CPU_BF548, 0x0002,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf548", BFIN_CPU_BF548, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_05000074},
{"bf548", BFIN_CPU_BF548, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf549m", BFIN_CPU_BF549M, 0x0003,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
 
{"bf549", BFIN_CPU_BF549, 0x0004,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf549", BFIN_CPU_BF549, 0x0002,
WA_SPECULATIVE_LOADS | WA_INDIRECT_CALLS | WA_05000074},
{"bf549", BFIN_CPU_BF549, 0x0001,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_05000074},
{"bf549", BFIN_CPU_BF549, 0x0000,
WA_SPECULATIVE_LOADS | WA_RETS | WA_INDIRECT_CALLS | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf561", BFIN_CPU_BF561, 0x0005, WA_RETS
| WA_05000283 | WA_05000315 | WA_LOAD_LCREGS | WA_05000074},
{"bf561", BFIN_CPU_BF561, 0x0003,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
{"bf561", BFIN_CPU_BF561, 0x0002,
WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS
| WA_05000283 | WA_05000257 | WA_05000315 | WA_LOAD_LCREGS
| WA_05000074},
 
{"bf592", BFIN_CPU_BF592, 0x0001,
WA_SPECULATIVE_LOADS | WA_05000074},
{"bf592", BFIN_CPU_BF592, 0x0000,
WA_SPECULATIVE_LOADS | WA_05000074},
 
{NULL, BFIN_CPU_UNKNOWN, 0, 0}
};
 
/* Implement TARGET_HANDLE_OPTION. */
 
static bool
bfin_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded,
location_t loc)
{
size_t code = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
 
switch (code)
{
case OPT_mshared_library_id_:
if (value > MAX_LIBRARY_ID)
error_at (loc, "-mshared-library-id=%s is not between 0 and %d",
arg, MAX_LIBRARY_ID);
return true;
 
case OPT_mcpu_:
{
const char *p, *q;
int i;
 
i = 0;
while ((p = bfin_cpus[i].name) != NULL)
{
if (strncmp (arg, p, strlen (p)) == 0)
break;
i++;
}
 
if (p == NULL)
{
error_at (loc, "-mcpu=%s is not valid", arg);
return false;
}
 
opts->x_bfin_cpu_type = bfin_cpus[i].type;
 
q = arg + strlen (p);
 
if (*q == '\0')
{
opts->x_bfin_si_revision = bfin_cpus[i].si_revision;
opts->x_bfin_workarounds |= bfin_cpus[i].workarounds;
}
else if (strcmp (q, "-none") == 0)
opts->x_bfin_si_revision = -1;
else if (strcmp (q, "-any") == 0)
{
opts->x_bfin_si_revision = 0xffff;
while (bfin_cpus[i].type == opts->x_bfin_cpu_type)
{
opts->x_bfin_workarounds |= bfin_cpus[i].workarounds;
i++;
}
}
else
{
unsigned int si_major, si_minor;
int rev_len, n;
 
rev_len = strlen (q);
 
if (sscanf (q, "-%u.%u%n", &si_major, &si_minor, &n) != 2
|| n != rev_len
|| si_major > 0xff || si_minor > 0xff)
{
invalid_silicon_revision:
error_at (loc, "-mcpu=%s has invalid silicon revision", arg);
return false;
}
 
opts->x_bfin_si_revision = (si_major << 8) | si_minor;
 
while (bfin_cpus[i].type == opts->x_bfin_cpu_type
&& bfin_cpus[i].si_revision != opts->x_bfin_si_revision)
i++;
 
if (bfin_cpus[i].type != opts->x_bfin_cpu_type)
goto invalid_silicon_revision;
 
opts->x_bfin_workarounds |= bfin_cpus[i].workarounds;
}
 
return true;
}
 
default:
return true;
}
}
 
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION bfin_handle_option
 
#undef TARGET_DEFAULT_TARGET_FLAGS
#define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/config/tilepro/tilepro-common.c
0,0 → 1,56
/* Common hooks for TILEPro.
Copyright (C) 2011, 2012
Free Software Foundation, Inc.
Contributed by Walter Lee (walt@tilera.com)
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "diagnostic-core.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-target-def.h"
#include "opts.h"
#include "flags.h"
 
static const struct default_options tilepro_option_optimization_table[] = {
{OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1},
/* Scheduling and bundling are super important for our architecture, so
enable them at -O1. */
{OPT_LEVELS_1_PLUS, OPT_fschedule_insns, NULL, 1},
{OPT_LEVELS_1_PLUS, OPT_fschedule_insns2, NULL, 1},
{OPT_LEVELS_NONE, 0, NULL, 0}
};
 
 
static void
tilepro_option_init_struct (struct gcc_options *opts)
{
opts->x_flag_asynchronous_unwind_tables = 1;
}
 
 
 
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE tilepro_option_optimization_table
 
#undef TARGET_OPTION_INIT_STRUCT
#define TARGET_OPTION_INIT_STRUCT tilepro_option_init_struct
 
struct gcc_targetm_common targetm_common = TARGETM_COMMON_INITIALIZER;
/common/common-targhooks.c
0,0 → 1,85
/* Default common target hook functions.
Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "input.h"
#include "tm.h"
#include "common/common-target.h"
#include "common/common-targhooks.h"
 
/* Determine the exception handling mechanism for the target. */
 
enum unwind_info_type
default_except_unwind_info (struct gcc_options *opts ATTRIBUTE_UNUSED)
{
/* Obey the configure switch to turn on sjlj exceptions. */
#ifdef CONFIG_SJLJ_EXCEPTIONS
if (CONFIG_SJLJ_EXCEPTIONS)
return UI_SJLJ;
#endif
 
/* ??? Change all users to the hook, then poison this. */
#ifdef DWARF2_UNWIND_INFO
if (DWARF2_UNWIND_INFO)
return UI_DWARF2;
#endif
 
return UI_SJLJ;
}
 
/* To be used by targets that force dwarf2 unwind enabled. */
 
enum unwind_info_type
dwarf2_except_unwind_info (struct gcc_options *opts ATTRIBUTE_UNUSED)
{
/* Obey the configure switch to turn on sjlj exceptions. */
#ifdef CONFIG_SJLJ_EXCEPTIONS
if (CONFIG_SJLJ_EXCEPTIONS)
return UI_SJLJ;
#endif
 
return UI_DWARF2;
}
 
/* To be used by targets that force sjlj unwind enabled. */
 
enum unwind_info_type
sjlj_except_unwind_info (struct gcc_options *opts ATTRIBUTE_UNUSED)
{
return UI_SJLJ;
}
 
/* Default version of TARGET_HANDLE_OPTION. */
 
bool
default_target_handle_option (struct gcc_options *opts ATTRIBUTE_UNUSED,
struct gcc_options *opts_set ATTRIBUTE_UNUSED,
const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
location_t loc ATTRIBUTE_UNUSED)
{
return true;
}
 
const struct default_options empty_optimization_table[] =
{
{ OPT_LEVELS_NONE, 0, NULL, 0 }
};
/common/common-target.def
0,0 → 1,108
/* Target hook definitions for common hooks.
Copyright (C) 2011
Free Software Foundation, Inc.
 
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
/* See target-hooks-macros.h for details of macros that should be
provided by the including file, and how to use them here. */
#include "target-hooks-macros.h"
 
#undef HOOK_TYPE
#define HOOK_TYPE "Common Target Hook"
 
HOOK_VECTOR (TARGETM_COMMON_INITIALIZER, gcc_targetm_common)
 
#undef HOOK_PREFIX
#define HOOK_PREFIX "TARGET_"
 
/* Handle target switch DECODED for options structures OPTS and
OPTS_SET, at location LOC. Return true if the switch was valid. */
DEFHOOK
(handle_option,
"",
bool, (struct gcc_options *opts, struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
location_t loc),
default_target_handle_option)
 
DEFHOOK
(option_init_struct,
"Set target-dependent initial values of fields in @var{opts}.",
void, (struct gcc_options *opts),
hook_void_gcc_optionsp)
 
/* Set default optimizations for the target. */
DEFHOOKPOD
(option_optimization_table,
"",
const struct default_options *, empty_optimization_table)
 
DEFHOOK
(option_default_params,
"Set target-dependent default values for @option{--param} settings, using\
calls to @code{set_default_param_value}.",
void, (void),
hook_void_void)
 
/* The initial value of target_flags. */
DEFHOOKPOD
(default_target_flags,
"",
int, 0)
 
/* Determine the type of unwind info to emit for exceptions. */
DEFHOOK
(except_unwind_info,
"",
enum unwind_info_type, (struct gcc_options *opts),
default_except_unwind_info)
 
DEFHOOK
(supports_split_stack,
"Whether this target supports splitting the stack when the options\
described in @var{opts} have been passed. This is called\
after options have been parsed, so the target may reject splitting\
the stack in some configurations. The default version of this hook\
returns false. If @var{report} is true, this function may issue a warning\
or error; if @var{report} is false, it must simply return a value",
bool, (bool report, struct gcc_options *opts),
hook_bool_bool_gcc_optionsp_false)
 
/* Leave the boolean fields at the end. */
 
/* True if unwinding tables should be generated by default. */
DEFHOOKPOD
(unwind_tables_default,
"",
bool, false)
 
/* True if arbitrary sections are supported. */
DEFHOOKPOD
(have_named_sections,
"",
bool, true)
 
DEFHOOKPOD
(always_strip_dotdot,
"True if @file{..} components should always be removed from directory names\
computed relative to GCC's internal directories, false (default) if such\
components should be preserved and directory names containing them passed\
to other tools such as the linker.",
bool, false)
HOOK_VECTOR_END (C90_EMPTY_HACK)
 
#undef HOOK_PREFIX
/common/common-targhooks.h
0,0 → 1,35
/* Default common target hook functions.
Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#ifndef GCC_COMMON_TARGHOOKS_H
#define GCC_COMMON_TARGHOOKS_H
 
extern enum unwind_info_type default_except_unwind_info (struct gcc_options *);
extern enum unwind_info_type dwarf2_except_unwind_info (struct gcc_options *);
extern enum unwind_info_type sjlj_except_unwind_info (struct gcc_options *);
 
extern bool default_target_handle_option (struct gcc_options *,
struct gcc_options *,
const struct cl_decoded_option *,
location_t);
 
extern const struct default_options empty_optimization_table[];
 
#endif
/common/common-target-def.h
0,0 → 1,21
/* Default initializers for common target hooks.
Copyright (C) 2011
Free Software Foundation, Inc.
 
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
 
#include "common/common-target-hooks-def.h"
#include "hooks.h"
#include "common/common-targhooks.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.