Update copyright years.

[thirdparty/gcc.git] / gcc / doc / gimple.texi

diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi
index 4b3d7d7452e3af54dc9cf67f07c457b06ff402bb..322c7609cf3159f5f908400440a21287c622c9fa 100644 (file)
--- a/gcc/doc/gimple.texi
+++ b/gcc/doc/gimple.texi
@@ -1,4 +1,4 @@
-@c Copyright (C) 2008-2021 Free Software Foundation, Inc.
+@c Copyright (C) 2008-2023 Free Software Foundation, Inc.
 @c Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
@@ -682,8 +682,7 @@ more than two slots on the RHS.  For instance, a @code{COND_EXPR}
 expression of the form @code{(a op b) ? x : y} could be flattened
 out on the operand vector using 4 slots, but it would also
 require additional processing to distinguish @code{c = a op b}
-from @code{c = a op b ? x : y}.  Something similar occurs with
-@code{ASSERT_EXPR}.   In time, these special case tree
+from @code{c = a op b ? x : y}.  In time, these special case tree
 expressions should be flattened into the operand vector.
 @end itemize
 
@@ -868,14 +867,6 @@ Return the basic block to which statement @code{G} belongs to.
 Return the lexical scope block holding statement @code{G}.
 @end deftypefn
 
-@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
-Return the type of the main expression computed by @code{STMT}. Return
-@code{void_type_node} if @code{STMT} computes nothing. This will only return
-something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
-@code{GIMPLE_CALL}.  For all other tuple codes, it will return
-@code{void_type_node}.
-@end deftypefn
-
 @deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
 Return the tree code for the expression computed by @code{STMT}.  This
 is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and
@@ -1973,11 +1964,10 @@ statements to be executed by just the master.
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
 Build a @code{GIMPLE_OMP_ORDERED} statement.
-@end deftypefn
 
 @code{BODY} is the sequence of statements inside a loop that will
 executed in sequence.
-
+@end deftypefn
 
 @node @code{GIMPLE_OMP_PARALLEL}
 @subsection @code{GIMPLE_OMP_PARALLEL}
@@ -1986,12 +1976,12 @@ executed in sequence.
 @deftypefn {GIMPLE function} gomp_parallel *gimple_build_omp_parallel (@
 gimple_seq body, tree clauses, tree child_fn, tree data_arg)
 Build a @code{GIMPLE_OMP_PARALLEL} statement.
-@end deftypefn
 
 @code{BODY} is sequence of statements which are executed in parallel.
 @code{CLAUSES}, are the @code{OMP} parallel construct's clauses.  @code{CHILD_FN} is
 the function created for the parallel threads to execute.
 @code{DATA_ARG} are the shared data argument(s).
+@end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
 Return true if @code{OMP} parallel statement @code{G} has the
@@ -2085,9 +2075,9 @@ Return true if @code{OMP} return statement @code{G} has the
 
 @deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
 Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
-@end deftypefn
 
 @code{BODY} is the sequence of statements in the section.
+@end deftypefn
 
 @deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
 Return true if @code{OMP} section statement @code{G} has the
@@ -2699,21 +2689,21 @@ modifying the file @code{gimple.def}, which contains all the GIMPLE
 codes.  Then you must add a corresponding gimple subclass
 located in @code{gimple.h}.  This in turn, will require you to add a
 corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle
-this tag in @code{gss_for_code} which is located in @code{gimple.c}.
+this tag in @code{gss_for_code} which is located in @code{gimple.cc}.
 
 In order for the garbage collector to know the size of the
 structure you created in @code{gimple.h}, you need to add a case to
 handle your new GIMPLE statement in @code{gimple_size} which is located
-in @code{gimple.c}.
+in @code{gimple.cc}.
 
 You will probably want to create a function to build the new
-gimple statement in @code{gimple.c}.  The function should be called
+gimple statement in @code{gimple.cc}.  The function should be called
 @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple
 as a pointer to the appropriate gimple subclass.
 
 If your new statement requires accessors for any members or
 operands it may have, put simple inline accessors in
-@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a
+@code{gimple.h} and any non-trivial accessors in @code{gimple.cc} with a
 corresponding prototype in @code{gimple.h}.
 
 You should add the new statement subclass to the class hierarchy diagram