[thirdparty/gcc.git] / gcc / reg-notes.def

/* Register note definitions.
   Copyright (C) 2004, 2005, 2006, 2007, 2008 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/>.  */

/* This file defines all the codes that may appear on individual
   EXPR_LIST rtxes in the REG_NOTES chain of an insn.  The codes are
   stored in the mode field of the EXPR_LIST.  Source files define
   DEF_REG_NOTE appropriately before including this file.  */

/* Shorthand.  */
#define REG_NOTE(NAME) DEF_REG_NOTE (REG_##NAME)

/* REG_DEP_TRUE is used in scheduler dependencies lists to represent a
   read-after-write dependency (i.e. a true data dependency).  This is
   here, not grouped with REG_DEP_ANTI and REG_DEP_OUTPUT, because some
   passes use a literal 0 for it.  */
REG_NOTE (DEP_TRUE)

/* The value in REG dies in this insn (i.e., it is not needed past
   this insn).  If REG is set in this insn, the REG_DEAD note may,
   but need not, be omitted.  */
REG_NOTE (DEAD)

/* The REG is autoincremented or autodecremented in this insn.  */
REG_NOTE (INC)

/* Describes the insn as a whole; it says that the insn sets a
   register to a constant value or to be equivalent to a memory
   address.  If the register is spilled to the stack then the constant
   value should be substituted for it.  The contents of the REG_EQUIV
   is the constant value or memory address, which may be different
   from the source of the SET although it has the same value.  A
   REG_EQUIV note may also appear on an insn which copies a register
   parameter to a pseudo-register, if there is a memory address which
   could be used to hold that pseudo-register throughout the function.  */
REG_NOTE (EQUIV)

/* Like REG_EQUIV except that the destination is only momentarily
   equal to the specified rtx.  Therefore, it cannot be used for
   substitution; but it can be used for cse.  */
REG_NOTE (EQUAL)

/* The register is always nonnegative during the containing loop.
   This is used in branches so that decrement and branch instructions
   terminating on zero can be matched.  There must be an insn pattern
   in the md file named `decrement_and_branch_until_zero' or else this
   will never be added to any instructions.  */
REG_NOTE (NONNEG)

/* Identifies a register set in this insn and never used.  */
REG_NOTE (UNUSED)

/* REG_CC_SETTER and REG_CC_USER link a pair of insns that set and use
   CC0, respectively.  Normally, these are required to be consecutive
   insns, but we permit putting a cc0-setting insn in the delay slot
   of a branch as long as only one copy of the insn exists.  In that
   case, these notes point from one to the other to allow code
   generation to determine what any require information and to
   properly update CC_STATUS.  These notes are INSN_LISTs.  */
REG_NOTE (CC_SETTER)
REG_NOTE (CC_USER)

/* Points to a CODE_LABEL.  Used by JUMP_INSNs to say that the CODE_LABEL
   contained in the REG_LABEL_TARGET note is a possible jump target of
   this insn.  This note is an INSN_LIST.  */
REG_NOTE (LABEL_TARGET)

/* Points to a CODE_LABEL.  Used by any insn to say that the CODE_LABEL
   contained in the REG_LABEL_OPERAND note is used by the insn, but as an
   operand, not as a jump target (though it may indirectly be a jump
   target for a later jump insn).  This note is an INSN_LIST.  */
REG_NOTE (LABEL_OPERAND)

/* REG_DEP_OUTPUT and REG_DEP_ANTI are used in scheduler dependencies lists
   to represent write-after-write and write-after-read dependencies
   respectively.  */
REG_NOTE (DEP_OUTPUT)
REG_NOTE (DEP_ANTI)

/* REG_BR_PROB is attached to JUMP_INSNs and CALL_INSNs.  It has an
   integer value.  For jumps, it is the probability that this is a
   taken branch.  For calls, it is the probability that this call
   won't return.  */
REG_NOTE (BR_PROB)

/* REG_VALUE_PROFILE is attached when the profile is read in to an
   insn before that the code to profile the value is inserted.  It
   contains the results of profiling.  */
REG_NOTE (VALUE_PROFILE)

/* Attached to a call insn; indicates that the call is malloc-like and
   that the pointer returned cannot alias anything else.  */
REG_NOTE (NOALIAS)

/* REG_BR_PRED is attached to JUMP_INSNs and CALL_INSNSs.  It contains
   CONCAT of two integer value.  First specifies the branch predictor
   that added the note, second specifies the predicted hitrate of
   branch in the same format as REG_BR_PROB note uses.  */
REG_NOTE (BR_PRED)

/* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex
   for DWARF to interpret what they imply.  The attached rtx is used
   instead of intuition.  */
REG_NOTE (FRAME_RELATED_EXPR)

/* Indicates that REG holds the exception context for the function.
   This context is shared by inline functions, so the code to acquire
   the real exception context is delayed until after inlining.  */
REG_NOTE (EH_CONTEXT)

/* Indicates what exception region an INSN belongs in.  This is used
   to indicate what region to which a call may throw.  REGION 0
   indicates that a call cannot throw at all.  REGION -1 indicates
   that it cannot throw, nor will it execute a non-local goto.  */
REG_NOTE (EH_REGION)

/* Used by haifa-sched to save NOTE_INSN notes across scheduling.  */
REG_NOTE (SAVE_NOTE)

/* Indicates that a call does not return.  */
REG_NOTE (NORETURN)

/* Indicates that an indirect jump is a non-local goto instead of a
   computed goto.  */
REG_NOTE (NON_LOCAL_GOTO)

/* Indicates that a jump crosses between hot and cold sections in a
   (partitioned) assembly or .o file, and therefore should not be
   reduced to a simpler jump by optimizations.  */
REG_NOTE (CROSSING_JUMP)

/* This kind of note is generated at each to `setjmp', and similar
   functions that can return twice.  */
REG_NOTE (SETJMP)
Commit	Line	Data
30f4db0d	1	/* Register note definitions.
cfaf579d	2	Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
30f4db0d	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
8c4c00c1	8	Software Foundation; either version 3, or (at your option) any later
30f4db0d	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
8c4c00c1	17	along with GCC; see the file COPYING3. If not see
8c4c00c1	18	<http://www.gnu.org/licenses/>. */
30f4db0d	19
	20	/* This file defines all the codes that may appear on individual
	21	EXPR_LIST rtxes in the REG_NOTES chain of an insn. The codes are
	22	stored in the mode field of the EXPR_LIST. Source files define
e2bb72c9	23	DEF_REG_NOTE appropriately before including this file. */
30f4db0d	24
	25	/* Shorthand. */
	26	#define REG_NOTE(NAME) DEF_REG_NOTE (REG_##NAME)
	27
9997bd27	28	/* REG_DEP_TRUE is used in scheduler dependencies lists to represent a
	29	read-after-write dependency (i.e. a true data dependency). This is
	30	here, not grouped with REG_DEP_ANTI and REG_DEP_OUTPUT, because some
	31	passes use a literal 0 for it. */
99caba0f	32	REG_NOTE (DEP_TRUE)
99caba0f	33
30f4db0d	34	/* The value in REG dies in this insn (i.e., it is not needed past
	35	this insn). If REG is set in this insn, the REG_DEAD note may,
	36	but need not, be omitted. */
	37	REG_NOTE (DEAD)
	38
	39	/* The REG is autoincremented or autodecremented in this insn. */
	40	REG_NOTE (INC)
	41
	42	/* Describes the insn as a whole; it says that the insn sets a
	43	register to a constant value or to be equivalent to a memory
	44	address. If the register is spilled to the stack then the constant
	45	value should be substituted for it. The contents of the REG_EQUIV
	46	is the constant value or memory address, which may be different
	47	from the source of the SET although it has the same value. A
	48	REG_EQUIV note may also appear on an insn which copies a register
	49	parameter to a pseudo-register, if there is a memory address which
	50	could be used to hold that pseudo-register throughout the function. */
	51	REG_NOTE (EQUIV)
	52
	53	/* Like REG_EQUIV except that the destination is only momentarily
	54	equal to the specified rtx. Therefore, it cannot be used for
1e5b92fa	55	substitution; but it can be used for cse. */
30f4db0d	56	REG_NOTE (EQUAL)
30f4db0d	57
30f4db0d	58	/* The register is always nonnegative during the containing loop.
	59	This is used in branches so that decrement and branch instructions
	60	terminating on zero can be matched. There must be an insn pattern
	61	in the md file named `decrement_and_branch_until_zero' or else this
	62	will never be added to any instructions. */
	63	REG_NOTE (NONNEG)
	64
30f4db0d	65	/* Identifies a register set in this insn and never used. */
	66	REG_NOTE (UNUSED)
	67
	68	/* REG_CC_SETTER and REG_CC_USER link a pair of insns that set and use
	69	CC0, respectively. Normally, these are required to be consecutive
	70	insns, but we permit putting a cc0-setting insn in the delay slot
	71	of a branch as long as only one copy of the insn exists. In that
	72	case, these notes point from one to the other to allow code
	73	generation to determine what any require information and to
	74	properly update CC_STATUS. These notes are INSN_LISTs. */
	75	REG_NOTE (CC_SETTER)
	76	REG_NOTE (CC_USER)
	77
19d2fe05	78	/* Points to a CODE_LABEL. Used by JUMP_INSNs to say that the CODE_LABEL
	79	contained in the REG_LABEL_TARGET note is a possible jump target of
	80	this insn. This note is an INSN_LIST. */
	81	REG_NOTE (LABEL_TARGET)
	82
	83	/* Points to a CODE_LABEL. Used by any insn to say that the CODE_LABEL
	84	contained in the REG_LABEL_OPERAND note is used by the insn, but as an
	85	operand, not as a jump target (though it may indirectly be a jump
	86	target for a later jump insn). This note is an INSN_LIST. */
	87	REG_NOTE (LABEL_OPERAND)
30f4db0d	88
9997bd27	89	/* REG_DEP_OUTPUT and REG_DEP_ANTI are used in scheduler dependencies lists
	90	to represent write-after-write and write-after-read dependencies
	91	respectively. */
30f4db0d	92	REG_NOTE (DEP_OUTPUT)
4d64d9a4	93	REG_NOTE (DEP_ANTI)
30f4db0d	94
	95	/* REG_BR_PROB is attached to JUMP_INSNs and CALL_INSNs. It has an
	96	integer value. For jumps, it is the probability that this is a
	97	taken branch. For calls, it is the probability that this call
	98	won't return. */
	99	REG_NOTE (BR_PROB)
	100
	101	/* REG_VALUE_PROFILE is attached when the profile is read in to an
	102	insn before that the code to profile the value is inserted. It
	103	contains the results of profiling. */
	104	REG_NOTE (VALUE_PROFILE)
	105
	106	/* Attached to a call insn; indicates that the call is malloc-like and
	107	that the pointer returned cannot alias anything else. */
	108	REG_NOTE (NOALIAS)
	109
30f4db0d	110	/* REG_BR_PRED is attached to JUMP_INSNs and CALL_INSNSs. It contains
	111	CONCAT of two integer value. First specifies the branch predictor
	112	that added the note, second specifies the predicted hitrate of
	113	branch in the same format as REG_BR_PROB note uses. */
	114	REG_NOTE (BR_PRED)
	115
	116	/* Attached to insns that are RTX_FRAME_RELATED_P, but are too complex
	117	for DWARF to interpret what they imply. The attached rtx is used
	118	instead of intuition. */
	119	REG_NOTE (FRAME_RELATED_EXPR)
	120
	121	/* Indicates that REG holds the exception context for the function.
	122	This context is shared by inline functions, so the code to acquire
	123	the real exception context is delayed until after inlining. */
	124	REG_NOTE (EH_CONTEXT)
	125
	126	/* Indicates what exception region an INSN belongs in. This is used
	127	to indicate what region to which a call may throw. REGION 0
	128	indicates that a call cannot throw at all. REGION -1 indicates
	129	that it cannot throw, nor will it execute a non-local goto. */
	130	REG_NOTE (EH_REGION)
	131
	132	/* Used by haifa-sched to save NOTE_INSN notes across scheduling. */
	133	REG_NOTE (SAVE_NOTE)
	134
30f4db0d	135	/* Indicates that a call does not return. */
	136	REG_NOTE (NORETURN)
	137
	138	/* Indicates that an indirect jump is a non-local goto instead of a
	139	computed goto. */
	140	REG_NOTE (NON_LOCAL_GOTO)
	141
	142	/* Indicates that a jump crosses between hot and cold sections in a
	143	(partitioned) assembly or .o file, and therefore should not be
	144	reduced to a simpler jump by optimizations. */
	145	REG_NOTE (CROSSING_JUMP)
	146
	147	/* This kind of note is generated at each to `setjmp', and similar
	148	functions that can return twice. */
	149	REG_NOTE (SETJMP)