#include "tree.h"
#include "expr.h"
#include "output.h"
+#include "diagnostic-core.h"
#include "toplev.h"
#include "function.h"
#include "target.h"
return named;
}
-/* Emit any directives required to unwind this instruction. */
-
-void
-default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
- rtx insn ATTRIBUTE_UNUSED)
-{
- /* Should never happen. */
- gcc_unreachable ();
-}
-
/* Emit to STREAM the assembler syntax for insn operand X. */
void
#endif
}
+/* The default implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA. */
+
+bool
+default_asm_output_addr_const_extra (FILE *file ATTRIBUTE_UNUSED,
+ rtx x ATTRIBUTE_UNUSED)
+{
+#ifdef OUTPUT_ADDR_CONST_EXTRA
+ OUTPUT_ADDR_CONST_EXTRA (file, x, fail);
+ return true;
+
+fail:
+#endif
+ return false;
+}
+
/* True if MODE is valid for the target. By "valid", we mean able to
be manipulated in non-trivial ways. In particular, this means all
the arithmetic is supported.
/* Default vectorizer cost model values. */
int
-default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost)
+default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
+ tree vectype ATTRIBUTE_UNUSED,
+ int misalign ATTRIBUTE_UNUSED)
{
switch (type_of_cost)
{
return 1;
case unaligned_load:
+ case unaligned_store:
return 2;
case cond_branch_taken:
}
void
+default_function_arg_advance (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
+ enum machine_mode mode ATTRIBUTE_UNUSED,
+ const_tree type ATTRIBUTE_UNUSED,
+ bool named ATTRIBUTE_UNUSED)
+{
+#ifdef FUNCTION_ARG_ADVANCE
+ CUMULATIVE_ARGS args = *ca;
+ FUNCTION_ARG_ADVANCE (args, mode, CONST_CAST_TREE (type), named);
+ *ca = args;
+#else
+ gcc_unreachable ();
+#endif
+}
+
+rtx
+default_function_arg (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
+ enum machine_mode mode ATTRIBUTE_UNUSED,
+ const_tree type ATTRIBUTE_UNUSED,
+ bool named ATTRIBUTE_UNUSED)
+{
+#ifdef FUNCTION_ARG
+ return FUNCTION_ARG (*ca, mode, CONST_CAST_TREE (type), named);
+#else
+ gcc_unreachable ();
+#endif
+}
+
+rtx
+default_function_incoming_arg (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
+ enum machine_mode mode ATTRIBUTE_UNUSED,
+ const_tree type ATTRIBUTE_UNUSED,
+ bool named ATTRIBUTE_UNUSED)
+{
+#ifdef FUNCTION_INCOMING_ARG
+ return FUNCTION_INCOMING_ARG (*ca, mode, CONST_CAST_TREE (type), named);
+#else
+ gcc_unreachable ();
+#endif
+}
+
+void
hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
{
}
sorry ("nested function trampolines not supported on this target");
}
-enum reg_class
+int
+default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
+ tree funtype ATTRIBUTE_UNUSED,
+ int size ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
+reg_class_t
default_branch_target_register_class (void)
{
return NO_REGS;
}
#ifdef IRA_COVER_CLASSES
-const enum reg_class *
+const reg_class_t *
default_ira_cover_classes (void)
{
- static enum reg_class classes[] = IRA_COVER_CLASSES;
+ static reg_class_t classes[] = IRA_COVER_CLASSES;
return classes;
}
#endif
-enum reg_class
+reg_class_t
default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
- enum reg_class reload_class ATTRIBUTE_UNUSED,
+ reg_class_t reload_class_i ATTRIBUTE_UNUSED,
enum machine_mode reload_mode ATTRIBUTE_UNUSED,
secondary_reload_info *sri)
{
enum reg_class rclass = NO_REGS;
+ enum reg_class reload_class = (enum reg_class) reload_class_i;
if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
{
#endif
if (rclass != NO_REGS)
{
- enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
- : reload_out_optab[(int) reload_mode]);
+ enum insn_code icode
+ = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
+ reload_mode);
if (icode != CODE_FOR_nothing
&& insn_data[(int) icode].operand[in_p].predicate
bool is_packed
ATTRIBUTE_UNUSED)
{
- if (optab_handler (movmisalign_optab, mode)->insn_code != CODE_FOR_nothing)
+ if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
return true;
return false;
}
+/* By default, only attempt to parallelize bitwise operations, and
+ possibly adds/subtracts using bit-twiddling. */
+
+unsigned int
+default_units_per_simd_word (enum machine_mode mode ATTRIBUTE_UNUSED)
+{
+ return UNITS_PER_WORD;
+}
+
/* Determine whether or not a pointer mode is valid. Assume defaults
of ptr_mode or Pmode - can be overridden. */
bool
int
default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
- enum reg_class rclass ATTRIBUTE_UNUSED,
+ reg_class_t rclass ATTRIBUTE_UNUSED,
bool in ATTRIBUTE_UNUSED)
{
#ifndef MEMORY_MOVE_COST
- return (4 + memory_move_secondary_cost (mode, rclass, in));
+ return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
#else
- return MEMORY_MOVE_COST (mode, rclass, in);
+ return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
#endif
}
int
default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
- enum reg_class from ATTRIBUTE_UNUSED,
- enum reg_class to ATTRIBUTE_UNUSED)
+ reg_class_t from ATTRIBUTE_UNUSED,
+ reg_class_t to ATTRIBUTE_UNUSED)
{
#ifndef REGISTER_MOVE_COST
return 2;
#else
- return REGISTER_MOVE_COST (mode, from, to);
+ return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
+#endif
+}
+
+bool
+default_profile_before_prologue (void)
+{
+#ifdef PROFILE_BEFORE_PROLOGUE
+ return true;
+#else
+ return false;
+#endif
+}
+
+/* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */
+
+bool
+default_class_likely_spilled_p (reg_class_t rclass)
+{
+#ifndef CLASS_LIKELY_SPILLED_P
+ return (reg_class_size[(int) rclass] == 1);
+#else
+ return CLASS_LIKELY_SPILLED_P ((enum reg_class) rclass);
#endif
}