CbC/CbC_gcc: gcc/function.h comparison

comparison gcc/function.h @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Structure for saving state for a nested function.
-Copyright (C) 1989-2017 Free Software Foundation, Inc.
+Copyright (C) 1989-2018 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
 #define REGNO_POINTER_ALIGN(REGNO) (crtl->emit.regno_pointer_align[REGNO])
 struct GTY(()) expr_status {
 /* Number of units that we should eventually pop off the stack.
 These are the arguments to function calls that have already returned.  */
-int x_pending_stack_adjust;
+poly_int64_pod x_pending_stack_adjust;
 /* Under some ABIs, it is the caller's responsibility to pop arguments
 pushed for function calls.  A naive implementation would simply pop
 the arguments immediately after each call.  However, if several
 function calls are made in a row, it is typically cheaper to pop
 /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack
 boundary can be momentarily unaligned while pushing the arguments.
 Record the delta since last aligned boundary here in order to get
 stack alignment in the nested function calls working right.  */
-int x_stack_pointer_delta;
+poly_int64_pod x_stack_pointer_delta;
 /* Nonzero means __builtin_saveregs has already been done in this function.
 The value is the pseudoreg containing the value __builtin_saveregs
 returned.  */
 rtx x_saveregs_value;
 reasons.  */
 struct GTY(()) frame_space
 {
 struct frame_space *next;
-HOST_WIDE_INT start;
+poly_int64 start;
-HOST_WIDE_INT length;
+poly_int64 length;
 };
 struct GTY(()) stack_usage
 {
 /* # of bytes of static stack space allocated by the function.  */
 /* # of bytes of dynamic stack space allocated by the function.  This is
 meaningful only if has_unbounded_dynamic_stack_size is zero.  */
 HOST_WIDE_INT dynamic_stack_size;
-/* # of bytes of space pushed onto the stack after the prologue.  If
+/* Upper bound on the number of bytes pushed onto the stack after the
-!ACCUMULATE_OUTGOING_ARGS, it contains the outgoing arguments.  */
+prologue.  If !ACCUMULATE_OUTGOING_ARGS, it contains the outgoing
-int pushed_stack_size;
+arguments.  */
+poly_int64 pushed_stack_size;
 /* Nonzero if the amount of stack space allocated dynamically cannot
 be bounded at compile-time.  */
 unsigned int has_unbounded_dynamic_stack_size : 1;
 };
 tree nonlocal_goto_save_area;
 /* Vector of function local variables, functions, types and constants.  */
 vec<tree, va_gc> *local_decls;
-/* In a Cilk function, the VAR_DECL for the frame descriptor. */
-tree cilk_frame_decl;
 /* For md files.  */
 /* tm.h can use this to store whatever it likes.  */
 struct machine_function * GTY ((maybe_undef)) machine;
 struct dw_fde_node *fde;
 /* Last statement uid.  */
 int last_stmt_uid;
+/* Debug marker counter.  Count begin stmt markers.  We don't have
+to keep it exact, it's more of a rough estimate to enable us to
+decide whether they are too many to copy during inlining, or when
+expanding to RTL.  */
+int debug_marker_count;
 /* Function sequence number for profiling, debugging, etc.  */
 int funcdef_no;
 /* Line number of the start of the function for debugging purposes.  */
 location_t function_start_locus;
 /* Nonzero if function being compiled can call alloca,
 either as a subroutine or builtin.  */
 unsigned int calls_alloca : 1;
-/* This will indicate whether a function is a cilk function */
-unsigned int is_cilk_function : 1;
-/* Nonzero if this is a Cilk function that spawns. */
-unsigned int calls_cilk_spawn : 1;
 /* Nonzero if function being compiled receives nonlocal gotos
 from nested functions.  */
 unsigned int has_nonlocal_label : 1;
 /* Nonzero if function being compiled has a forced label
 /* Nonzero if the current function contains any loops with
 nonzero value in loop->simduid.  */
 unsigned int has_simduid_loops : 1;
-/* Set when the tail call has been identified.  */
+/* Nonzero when the tail call has been identified.  */
 unsigned int tail_call_marked : 1;
+/* Nonzero if the current function contains a #pragma GCC unroll.  */
+unsigned int has_unroll : 1;
+/* Set when the function was compiled with generation of debug
+(begin stmt, inline entry, ...) markers enabled.  */
+unsigned int debug_nonbind_markers : 1;
 };
 /* Add the decl D to the local_decls list of FUN.  */
 void add_local_decl (struct function *fun, tree d);
 also used to store offsets from the stack, which might be negative,
 so the variable part must be ssizetype, not sizetype.  */
 struct args_size
 {
-HOST_WIDE_INT constant;
+poly_int64_pod constant;
 tree var;
 };
 /* Package up various arg related fields of struct args for
 locate_and_pad_parm.  */
 : size_binop (PLUS_EXPR, fold_convert (ssizetype, (SIZE).var),	\
 	       ssize_int ((SIZE).constant)))
 /* Convert the implicit sum in a `struct args_size' into an rtx.  */
 #define ARGS_SIZE_RTX(SIZE)					\
-((SIZE).var == 0 ? GEN_INT ((SIZE).constant)			\
+((SIZE).var == 0 ? gen_int_mode ((SIZE).constant, Pmode)	\
 : expand_normal (ARGS_SIZE_TREE (SIZE)))
 #define ASLK_REDUCE_ALIGN 1
 #define ASLK_RECORD_PAD 2
 extern void free_after_compilation (struct function *);
 /* Return size needed for stack frame based on slots so far allocated.
 This size counts from zero.  It is not rounded to STACK_BOUNDARY;
 the caller may have to do that.  */
-extern HOST_WIDE_INT get_frame_size (void);
+extern poly_int64 get_frame_size (void);
 /* Issue an error message and return TRUE if frame OFFSET overflows in
 the signed target pointer arithmetics for function FUNC.  Otherwise
 return FALSE.  */
-extern bool frame_offset_overflow (HOST_WIDE_INT, tree);
+extern bool frame_offset_overflow (poly_int64, tree);
 extern unsigned int spill_slot_alignment (machine_mode);
-extern rtx assign_stack_local_1 (machine_mode, HOST_WIDE_INT, int, int);
+extern rtx assign_stack_local_1 (machine_mode, poly_int64, int, int);
-extern rtx assign_stack_local (machine_mode, HOST_WIDE_INT, int);
+extern rtx assign_stack_local (machine_mode, poly_int64, int);
-extern rtx assign_stack_temp_for_type (machine_mode, HOST_WIDE_INT, tree);
+extern rtx assign_stack_temp_for_type (machine_mode, poly_int64, tree);
-extern rtx assign_stack_temp (machine_mode, HOST_WIDE_INT);
+extern rtx assign_stack_temp (machine_mode, poly_int64);
 extern rtx assign_temp (tree, int, int);
 extern void update_temp_slot_address (rtx, rtx);
 extern void preserve_temp_slots (rtx);
 extern void free_temp_slots (void);
 extern void push_temp_slots (void);
 extern bool initial_value_entry (int i, rtx *, rtx *);
 extern void instantiate_decl_rtl (rtx x);
 extern int aggregate_value_p (const_tree, const_tree);
 extern bool use_register_for_decl (const_tree);
-extern gimple_seq gimplify_parameters (void);
+extern gimple_seq gimplify_parameters (gimple_seq *);
 extern void locate_and_pad_parm (machine_mode, tree, int, int, int,
 				 tree, struct args_size *,
 				 struct locate_and_pad_arg_data *);
 extern void generate_setjmp_warnings (void);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/function.h @ 131:84e7813d76e9