CbC/CbC_gcc: gcc/doc/c-tree.texi comparison

comparison gcc/doc/c-tree.texi @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 @item TYPE_ALIGN
 The alignment of the type, in bits, represented as an @code{int}.
 @item TYPE_NAME
 This macro returns a declaration (in the form of a @code{TYPE_DECL}) for
-the type.  (Note this macro does @emph{not} return a
+the type.  (Note this macro does @emph{not} return an
 @code{IDENTIFIER_NODE}, as you might expect, given its name!)  You can
 look at the @code{DECL_NAME} of the @code{TYPE_DECL} to obtain the
 actual name of the type.  The @code{TYPE_NAME} will be @code{NULL_TREE}
 for a type that is not a built-in type, the result of a typedef, or a
 named class type.
 @tindex OVERLOAD
 @findex OVL_CURRENT
 @findex OVL_NEXT
 A function is represented by a @code{FUNCTION_DECL} node.  A set of
-overloaded functions is sometimes represented by a @code{OVERLOAD} node.
+overloaded functions is sometimes represented by an @code{OVERLOAD} node.
 An @code{OVERLOAD} node is not a declaration, so none of the
 @samp{DECL_} macros should be used on an @code{OVERLOAD}.  An
 @code{OVERLOAD} node is similar to a @code{TREE_LIST}.  Use
 @code{OVL_CURRENT} to get the function associated with an
 @tindex COMPOUND_LITERAL_EXPR
 @tindex SAVE_EXPR
 @tindex TARGET_EXPR
 @tindex AGGR_INIT_EXPR
 @tindex VA_ARG_EXPR
-@tindex CHANGE_DYNAMIC_TYPE_EXPR
 @tindex OMP_PARALLEL
 @tindex OMP_FOR
 @tindex OMP_SECTIONS
 @tindex OMP_SINGLE
 @tindex OMP_SECTION
 @item FIXED_CST
 These nodes represent fixed-point constants.  The type of these constants
 is obtained with @code{TREE_TYPE}.  @code{TREE_FIXED_CST_PTR} points to
-to struct fixed_value;  @code{TREE_FIXED_CST} returns the structure itself.
+a @code{struct fixed_value};  @code{TREE_FIXED_CST} returns the structure
-Struct fixed_value contains @code{data} with the size of two
+itself.  @code{struct fixed_value} contains @code{data} with the size of two
-HOST_BITS_PER_WIDE_INT and @code{mode} as the associated fixed-point
+@code{HOST_BITS_PER_WIDE_INT} and @code{mode} as the associated fixed-point
 machine mode for @code{data}.
 @item COMPLEX_CST
 These nodes are used to represent complex number constants, that is a
 @code{__complex__} whose parts are constant nodes.  The
 These nodes are used to represent GCC's statement-expression extension.
 The statement-expression extension allows code like this:
 @smallexample
 int f() @{ return (@{ int j; j = 3; j + 7; @}); @}
 @end smallexample
-In other words, an sequence of statements may occur where a single
+In other words, a sequence of statements may occur where a single
 expression would normally appear.  The @code{STMT_EXPR} node represents
 such an expression.  The @code{STMT_EXPR_STMT} gives the statement
 contained in the expression.  The value of the expression is the value
 of the last sub-statement in the body.  More precisely, the value is the
 value computed by the last statement nested inside @code{BIND_EXPR},
 particular order.  However, in the middle end, fields must appear in
 declaration order.  You should not assume that all fields will be
 represented.  Unrepresented fields will be set to zero.
 @item COMPOUND_LITERAL_EXPR
-@findex COMPOUND_LITERAL_EXPR_DECL_STMT
+@findex COMPOUND_LITERAL_EXPR_DECL_EXPR
 @findex COMPOUND_LITERAL_EXPR_DECL
 These nodes represent ISO C99 compound literals.  The
-@code{COMPOUND_LITERAL_EXPR_DECL_STMT} is a @code{DECL_STMT}
+@code{COMPOUND_LITERAL_EXPR_DECL_EXPR} is a @code{DECL_EXPR}
 containing an anonymous @code{VAR_DECL} for
 the unnamed object represented by the compound literal; the
 @code{DECL_INITIAL} of that @code{VAR_DECL} is a @code{CONSTRUCTOR}
 representing the brace-enclosed list of initializers in the compound
 literal.  That anonymous @code{VAR_DECL} can also be accessed directly
 @item VA_ARG_EXPR
 This node is used to implement support for the C/C++ variable argument-list
 mechanism.  It represents expressions like @code{va_arg (ap, type)}.
 Its @code{TREE_TYPE} yields the tree representation for @code{type} and
 its sole argument yields the representation for @code{ap}.
-@item CHANGE_DYNAMIC_TYPE_EXPR
-Indicates the special aliasing required by C++ placement new.  It has
-two operands: a type and a location.  It means that the dynamic type
-of the location is changing to be the specified type.  The alias
-analysis code takes this into account when doing type based alias
-analysis.
 @item OMP_PARALLEL
 Represents @code{#pragma omp parallel [clause1 @dots{} clauseN]}. It
 has four operands:
 same clause @code{C} need to be represented as multiple @code{C} clauses
 chained together.  This facilitates adding new clauses during
 compilation.
 @item VEC_LSHIFT_EXPR
-@item VEC_RSHIFT_EXPR
+@itemx VEC_RSHIFT_EXPR
 These nodes represent whole vector left and right shifts, respectively.
 The first operand is the vector to shift; it will always be of vector type.
 The second operand is an expression for the number of bits by which to
 shift.  Note that the result is undefined if the second operand is larger
 than or equal to the first operand's type size.
 @item VEC_WIDEN_MULT_HI_EXPR
-@item VEC_WIDEN_MULT_LO_EXPR
+@itemx VEC_WIDEN_MULT_LO_EXPR
 These nodes represent widening vector multiplication of the high and low
 parts of the two input vectors, respectively.  Their operands are vectors
 that contain the same number of elements (@code{N}) of the same integral type.
 The result is a vector that contains half as many elements, of an integral type
 whose size is twice as wide.  In the case of @code{VEC_WIDEN_MULT_HI_EXPR} the
 vector of @code{N/2} products. In the case of @code{VEC_WIDEN_MULT_LO_EXPR} the
 low @code{N/2} elements of the two vector are multiplied to produce the
 vector of @code{N/2} products.
 @item VEC_UNPACK_HI_EXPR
-@item VEC_UNPACK_LO_EXPR
+@itemx VEC_UNPACK_LO_EXPR
 These nodes represent unpacking of the high and low parts of the input vector,
 respectively.  The single operand is a vector that contains @code{N} elements
 of the same integral or floating point type.  The result is a vector
 that contains half as many elements, of an integral or floating point type
 whose size is twice as wide.  In the case of @code{VEC_UNPACK_HI_EXPR} the
 high @code{N/2} elements of the vector are extracted and widened (promoted).
 In the case of @code{VEC_UNPACK_LO_EXPR} the low @code{N/2} elements of the
 vector are extracted and widened (promoted).
 @item VEC_UNPACK_FLOAT_HI_EXPR
-@item VEC_UNPACK_FLOAT_LO_EXPR
+@itemx VEC_UNPACK_FLOAT_LO_EXPR
 These nodes represent unpacking of the high and low parts of the input vector,
 where the values are converted from fixed point to floating point.  The
 single operand is a vector that contains @code{N} elements of the same
 integral type.  The result is a vector that contains half as many elements
 of a floating point type whose size is twice as wide.  In the case of
 twice as many elements of an integral type whose size is half as wide.  The
 elements of the two vectors are merged (concatenated) to form the output
 vector.
 @item VEC_EXTRACT_EVEN_EXPR
-@item VEC_EXTRACT_ODD_EXPR
+@itemx VEC_EXTRACT_ODD_EXPR
 These nodes represent extracting of the even/odd elements of the two input
 vectors, respectively. Their operands and result are vectors that contain the
 same number of elements of the same type.
 @item VEC_INTERLEAVE_HIGH_EXPR
-@item VEC_INTERLEAVE_LOW_EXPR
+@itemx VEC_INTERLEAVE_LOW_EXPR
 These nodes represent merging and interleaving of the high/low elements of the
 two input vectors, respectively. The operands and the result are vectors that
 contain the same number of elements (@code{N}) of the same type.
 In the case of @code{VEC_INTERLEAVE_HIGH_EXPR}, the high @code{N/2} elements of
 the first input vector are interleaved with the high @code{N/2} elements of the

Mercurial > hg > CbC > CbC_gcc

comparison gcc/doc/c-tree.texi @ 55:77e2b8dfacca gcc-4.4.5