--- a/gcc/tree.def	Sun Feb 07 18:28:00 2010 +0900
+++ b/gcc/tree.def	Fri Feb 12 23:39:51 2010 +0900
@@ -1,6 +1,6 @@
 /* This file contains the definitions and documentation for the
    tree codes used in GCC.
-   Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004, 2005, 
+   Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000, 2001, 2004, 2005,
    2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -89,16 +89,6 @@
      that are variants made by type modifiers such as "const" and "volatile".
    The TYPE_MAIN_VARIANT field, in any member of such a chain,
      points to the start of the chain.
-   The TYPE_NONCOPIED_PARTS field is a list specifying which parts
-     of an object of this type should *not* be copied by assignment.
-     The TREE_VALUE of each is a FIELD_DECL that should not be
-     copied.  The TREE_PURPOSE is an initial value for that field when
-     an object of this type is initialized via an INIT_EXPR.  It may
-     be NULL if no special value is required.  Even the things in this
-     list are copied if the right-hand side of an assignment is known
-     to be a complete object (rather than being, perhaps, a subobject
-     of some other object.)  The determination of what constitutes a
-     complete object is done by fixed_type_p.
    The TYPE_NAME field contains info on the name used in the program
      for this type (for GDB symbol table output).  It is either a
      TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE
@@ -125,7 +115,7 @@
    macros in tree.h.  Changing the order will degrade the speed of the
    compiler.  OFFSET_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, INTEGER_TYPE,
    REAL_TYPE, POINTER_TYPE.  */
-     
+
 /* An offset is a pointer relative to an object.
    The TREE_TYPE field is the type of the object at the offset.
    The TYPE_OFFSET_BASETYPE points to the node for the type of object
@@ -167,7 +157,7 @@
    macros in tree.h.  Changing the order will degrade the speed of the
    compiler.  POINTER_TYPE, REFERENCE_TYPE.  Note that this range
    overlaps the previous range of ordered types.  */
-     
+
 /* All pointer-to-x types have code POINTER_TYPE.
    The TREE_TYPE points to the node for the type pointed to.  */
 DEFTREECODE (POINTER_TYPE, "pointer_type", tcc_type, 0)
@@ -184,7 +174,7 @@
 /* The ordering of the following codes is optimized for the checking
    macros in tree.h.  Changing the order will degrade the speed of the
    compiler.  COMPLEX_TYPE, VECTOR_TYPE, ARRAY_TYPE.  */
-     
+
 /* Complex number types.  The TREE_TYPE field is the data type
    of the real and imaginary parts.  It must be of scalar
    arithmetic type, not including pointer type.  */
@@ -199,7 +189,7 @@
    macros in tree.h.  Changing the order will degrade the speed of the
    compiler.  ARRAY_TYPE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE.
    Note that this range overlaps the previous range.  */
-     
+
 /* Types of arrays.  Special fields:
    TREE_TYPE		  Type of an array element.
    TYPE_DOMAIN		  Type to index by.
@@ -236,7 +226,7 @@
 /* The ordering of the following codes is optimized for the checking
    macros in tree.h.  Changing the order will degrade the speed of the
    compiler.  VOID_TYPE, FUNCTION_TYPE, METHOD_TYPE.  */
-     
+
 /* The void type in C */
 DEFTREECODE (VOID_TYPE, "void_type", tcc_type, 0)
 
@@ -268,9 +258,8 @@
 /* Contents are in TREE_INT_CST_LOW and TREE_INT_CST_HIGH fields,
    32 bits each, giving us a 64 bit constant capability.  INTEGER_CST
    nodes can be shared, and therefore should be considered read only.
-   They should be copied, before setting a flag such as
-   TREE_OVERFLOW.  If an INTEGER_CST has TREE_OVERFLOW or
-   TREE_CONSTANT_OVERFLOW already set, it is known to be unique.
+   They should be copied, before setting a flag such as TREE_OVERFLOW.
+   If an INTEGER_CST has TREE_OVERFLOW already set, it is known to be unique.
    INTEGER_CST nodes are created for the integral types, for pointer
    types and for vector and float types in some circumstances.  */
 DEFTREECODE (INTEGER_CST, "integer_cst", tcc_constant, 0)
@@ -362,11 +351,9 @@
 DEFTREECODE (TYPE_DECL, "type_decl", tcc_declaration, 0)
 DEFTREECODE (RESULT_DECL, "result_decl", tcc_declaration, 0)
 
-/* Memory tags used in tree-ssa to represent memory locations in
-   virtual SSA.  */
-DEFTREECODE (NAME_MEMORY_TAG, "name_memory_tag", tcc_declaration, 0)
-DEFTREECODE (SYMBOL_MEMORY_TAG, "symbol_memory_tag", tcc_declaration, 0)
-DEFTREECODE (MEMORY_PARTITION_TAG, "memory_partition_tag", tcc_declaration, 0)
+/* A "declaration" of a debug temporary.  It should only appear in
+   DEBUG stmts.  */
+DEFTREECODE (DEBUG_EXPR_DECL, "debug_expr_decl", tcc_declaration, 0)
 
 /* A namespace declaration.  Namespaces appear in DECL_CONTEXT of other
    _DECLs, providing a hierarchy of names.  */
@@ -390,6 +377,9 @@
 
 /* References to storage.  */
 
+/* The ordering of the following codes is optimized for the classification
+   in handled_component_p.  Keep them in a consecutive group.  */
+
 /* Value is structure or union component.
    Operand 0 is the structure or union (an expression).
    Operand 1 is the field (a node of type FIELD_DECL).
@@ -407,6 +397,23 @@
    to its mode width.  */
 DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", tcc_reference, 3)
 
+/* Used only on an operand of complex type, these return
+   a value of the corresponding component type.  */
+DEFTREECODE (REALPART_EXPR, "realpart_expr", tcc_reference, 1)
+DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", tcc_reference, 1)
+
+/* Array indexing.
+   Operand 0 is the array; operand 1 is a (single) array index.
+   Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index.
+   Operand 3, if present, is the element size, measured in units of
+   the alignment of the element type.  */
+DEFTREECODE (ARRAY_REF, "array_ref", tcc_reference, 4)
+
+/* Likewise, except that the result is a range ("slice") of the array.  The
+   starting index of the resulting array is taken from operand 1 and the size
+   of the range is taken from the type of the expression.  */
+DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", tcc_reference, 4)
+
 /* The ordering of the following codes is optimized for the checking
    macros in tree.h.  Changing the order will degrade the speed of the
    compiler.  INDIRECT_REF, ALIGN_INDIRECT_REF, MISALIGNED_INDIRECT_REF.  */
@@ -425,18 +432,6 @@
    or 0 if the alignment is unknown.  */
 DEFTREECODE (MISALIGNED_INDIRECT_REF, "misaligned_indirect_ref", tcc_reference, 2)
 
-/* Array indexing.
-   Operand 0 is the array; operand 1 is a (single) array index.
-   Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index.
-   Operand 3, if present, is the element size, measured in units of
-   the alignment of the element type.  */
-DEFTREECODE (ARRAY_REF, "array_ref", tcc_reference, 4)
-
-/* Likewise, except that the result is a range ("slice") of the array.  The
-   starting index of the resulting array is taken from operand 1 and the size
-   of the range is taken from the type of the expression.  */
-DEFTREECODE (ARRAY_RANGE_REF, "array_range_ref", tcc_reference, 4)
-
 /* Used to represent lookup of runtime type dependent data.  Often this is
    a reference to a vtable, but it needn't be.  Operands are:
    OBJ_TYPE_REF_EXPR: An expression that evaluates the value to use.
@@ -449,12 +444,6 @@
    identifier or a vtable index.  */
 DEFTREECODE (OBJ_TYPE_REF, "obj_type_ref", tcc_expression, 3)
 
-/* The exception object from the runtime.  */
-DEFTREECODE (EXC_PTR_EXPR, "exc_ptr_expr", tcc_expression, 0)
-
-/* The filter object from the runtime.  */
-DEFTREECODE (FILTER_EXPR, "filter_expr", tcc_expression, 0)
-
 /* Constructor: return an aggregate value made from specified components.
    In C, this is used only for structure and array initializers.
    The operand is a sequence of component values made out of a VEC of
@@ -505,7 +494,7 @@
    Operand 1 must have the same type as the entire expression, unless
    it unconditionally throws an exception, in which case it should
    have VOID_TYPE.  The same constraints apply to operand 2.  The
-   condition in operand 0 must be of integral type. 
+   condition in operand 0 must be of integral type.
 
    In cfg gimple, if you do not have a selection expression, operands
    1 and 2 are NULL.  The operands are then taken from the cfg edges. */
@@ -763,6 +752,10 @@
    represented by CONVERT_EXPR or NOP_EXPR nodes.  */
 DEFTREECODE (CONVERT_EXPR, "convert_expr", tcc_unary, 1)
 
+/* Conversion of a pointer value to a pointer to a different
+   address space.  */
+DEFTREECODE (ADDR_SPACE_CONVERT_EXPR, "addr_space_convert_expr", tcc_unary, 1)
+
 /* Conversion of a fixed-point value to an integer, a real, or a fixed-point
    value.  Or conversion of a fixed-point value from an integer, a real, or
    a fixed-point value.  */
@@ -786,6 +779,13 @@
    generating insns.  */
 DEFTREECODE (VIEW_CONVERT_EXPR, "view_convert_expr", tcc_reference, 1)
 
+/* A COMPOUND_LITERAL_EXPR represents a literal that is placed in a DECL.  The
+   COMPOUND_LITERAL_EXPR_DECL_EXPR is the a DECL_EXPR containing the decl
+   for the anonymous object represented by the COMPOUND_LITERAL;
+   the DECL_INITIAL of that decl is the CONSTRUCTOR that initializes
+   the compound literal.  */
+DEFTREECODE (COMPOUND_LITERAL_EXPR, "compound_literal_expr", tcc_expression, 1)
+
 /* Represents something we computed once and will use multiple times.
    First operand is that expression.  After it is evaluated once, it
    will be replaced by the temporary variable that holds the value.  */
@@ -806,11 +806,6 @@
 /* Complex conjugate of operand.  Used only on complex types.  */
 DEFTREECODE (CONJ_EXPR, "conj_expr", tcc_unary, 1)
 
-/* Used only on an operand of complex type, these return
-   a value of the corresponding component type.  */
-DEFTREECODE (REALPART_EXPR, "realpart_expr", tcc_reference, 1)
-DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", tcc_reference, 1)
-
 /* Nodes for ++ and -- in C.
    The second arg is how much to increment or decrement by.
    For a pointer, it would be the size of the object pointed to.  */
@@ -885,15 +880,12 @@
    label.  CASE_LABEL is the corresponding LABEL_DECL.  */
 DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", tcc_statement, 3)
 
-/* RESX.  Resume execution after an exception.  Operand 0 is a
-   number indicating the exception region that is being left.  */
-DEFTREECODE (RESX_EXPR, "resx_expr", tcc_statement, 1)
-
 /* Used to represent an inline assembly statement.  ASM_STRING returns a
    STRING_CST for the instruction (e.g., "mov x, y"). ASM_OUTPUTS,
    ASM_INPUTS, and ASM_CLOBBERS represent the outputs, inputs, and clobbers
-   for the statement.  */
-DEFTREECODE (ASM_EXPR, "asm_expr", tcc_statement, 4)
+   for the statement.  ASM_LABELS, if present, indicates various destinations
+   for the asm; labels cannot be combined with outputs.  */
+DEFTREECODE (ASM_EXPR, "asm_expr", tcc_statement, 5)
 
 /* Variable references for SSA analysis.  New SSA names are created every
    time a variable is assigned a new value.  The SSA builder uses SSA_NAME
@@ -910,15 +902,6 @@
    expanding.  */
 DEFTREECODE (EH_FILTER_EXPR, "eh_filter_expr", tcc_statement, 2)
 
-/* Indicates a change in the dynamic type of a memory location.  This
-   has no value and generates no executable code.  It is only used for
-   type based alias analysis.  This is generated by C++ placement new.
-   CHANGE_DYNAMIC_TYPE_NEW_TYPE, the first operand, is the new type.
-   CHANGE_DYNAMIC_TYPE_LOCATION, the second operand, is the location
-   whose type is being changed.  */
-DEFTREECODE (CHANGE_DYNAMIC_TYPE_EXPR, "change_dynamic_type_expr",
-	     tcc_statement, 2)
-
 /* Node used for describing a property that is known at compile
    time.  */
 DEFTREECODE (SCEV_KNOWN, "scev_known", tcc_expression, 0)
@@ -938,7 +921,7 @@
 /* Predicate assertion.  Artificial expression generated by the optimizers
    to keep track of predicate values.  This expression may only appear on
    the RHS of assignments.
-   
+
    Given X = ASSERT_EXPR <Y, EXPR>, the optimizers can infer
    two things:
 
@@ -971,8 +954,8 @@
    If OFF > 0, the last VS - OFF elements of vector OP0 are concatenated to
    the first OFF elements of the vector OP1.
    If OFF == 0, then the returned vector is OP1.
-   On different targets OFF may take different forms; It can be an address, in 
-   which case its low log2(VS)-1 bits define the offset, or it can be a mask 
+   On different targets OFF may take different forms; It can be an address, in
+   which case its low log2(VS)-1 bits define the offset, or it can be a mask
    generated by the builtin targetm.vectorize.mask_for_load_builtin_decl.  */
 DEFTREECODE (REALIGN_LOAD_EXPR, "realign_load", tcc_expression, 3)
 
@@ -984,12 +967,11 @@
 
    The type of STEP, INDEX and OFFSET is sizetype.  The type of BASE is
    sizetype or a pointer type (if SYMBOL is NULL).
-   
+
    The sixth argument is the reference to the original memory access, which
-   is preserved for the purposes of the RTL alias analysis.  The seventh
-   argument is a tag representing results of the tree level alias analysis.  */
+   is preserved for the purpose of alias analysis.  */
 
-DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 7)
+DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 6)
 
 /* The ordering of the codes between OMP_PARALLEL and OMP_CRITICAL is
    exposed to TREE_RANGE_CHECK.  */
@@ -1064,12 +1046,12 @@
 /* OpenMP clauses.  */
 DEFTREECODE (OMP_CLAUSE, "omp_clause", tcc_exceptional, 0)
 
-/* Reduction operations. 
+/* Reduction operations.
    Operations that take a vector of elements and "reduce" it to a scalar
    result (e.g. summing the elements of the vector, finding the minimum over
    the vector elements, etc).
    Operand 0 is a vector; the first element in the vector has the result.
-   Operand 1 is a vector.  */ 
+   Operand 1 is a vector.  */
 DEFTREECODE (REDUC_MAX_EXPR, "reduc_max_expr", tcc_unary, 1)
 DEFTREECODE (REDUC_MIN_EXPR, "reduc_min_expr", tcc_unary, 1)
 DEFTREECODE (REDUC_PLUS_EXPR, "reduc_plus_expr", tcc_unary, 1)
@@ -1080,7 +1062,7 @@
    twice the size of t1. DOT_PROD_EXPR(arg1,arg2,arg3) is equivalent to:
    	tmp = WIDEN_MULT_EXPR(arg1, arg2);
    	arg3 = PLUS_EXPR (tmp, arg3);
-   or: 
+   or:
 	tmp = WIDEN_MULT_EXPR(arg1, arg2);
         arg3 = WIDEN_SUM_EXPR (tmp, arg3);		 */
 DEFTREECODE (DOT_PROD_EXPR, "dot_prod_expr", tcc_expression, 3)
@@ -1093,7 +1075,7 @@
    the first argument from type t1 to type t2, and then summing it
    with the second argument.  */
 DEFTREECODE (WIDEN_SUM_EXPR, "widen_sum_expr", tcc_binary, 2)
-   
+
 /* Widening multiplication.
    The two arguments are of type t1.
    The result is of type t2, such that t2 is at least twice