1@c Copyright (c) 2008, 2009, 2010 Free Software Foundation, Inc. 2@c Free Software Foundation, Inc. 3@c This is part of the GCC manual. 4@c For copying conditions, see the file gcc.texi. 5 6@node GIMPLE 7@chapter GIMPLE 8@cindex GIMPLE 9 10GIMPLE is a three-address representation derived from GENERIC by 11breaking down GENERIC expressions into tuples of no more than 3 12operands (with some exceptions like function calls). GIMPLE was 13heavily influenced by the SIMPLE IL used by the McCAT compiler 14project at McGill University, though we have made some different 15choices. For one thing, SIMPLE doesn't support @code{goto}. 16 17Temporaries are introduced to hold intermediate values needed to 18compute complex expressions. Additionally, all the control 19structures used in GENERIC are lowered into conditional jumps, 20lexical scopes are removed and exception regions are converted 21into an on the side exception region tree. 22 23The compiler pass which converts GENERIC into GIMPLE is referred to as 24the @samp{gimplifier}. The gimplifier works recursively, generating 25GIMPLE tuples out of the original GENERIC expressions. 26 27One of the early implementation strategies used for the GIMPLE 28representation was to use the same internal data structures used 29by front ends to represent parse trees. This simplified 30implementation because we could leverage existing functionality 31and interfaces. However, GIMPLE is a much more restrictive 32representation than abstract syntax trees (AST), therefore it 33does not require the full structural complexity provided by the 34main tree data structure. 35 36The GENERIC representation of a function is stored in the 37@code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL} 38tree node. It is converted to GIMPLE by a call to 39@code{gimplify_function_tree}. 40 41If a front end wants to include language-specific tree codes in the tree 42representation which it provides to the back end, it must provide a 43definition of @code{LANG_HOOKS_GIMPLIFY_EXPR} which knows how to 44convert the front end trees to GIMPLE@. Usually such a hook will involve 45much of the same code for expanding front end trees to RTL@. This function 46can return fully lowered GIMPLE, or it can return GENERIC trees and let the 47main gimplifier lower them the rest of the way; this is often simpler. 48GIMPLE that is not fully lowered is known as ``High GIMPLE'' and 49consists of the IL before the pass @code{pass_lower_cf}. High GIMPLE 50contains some container statements like lexical scopes 51(represented by @code{GIMPLE_BIND}) and nested expressions (e.g., 52@code{GIMPLE_TRY}), while ``Low GIMPLE'' exposes all of the 53implicit jumps for control and exception expressions directly in 54the IL and EH region trees. 55 56The C and C++ front ends currently convert directly from front end 57trees to GIMPLE, and hand that off to the back end rather than first 58converting to GENERIC@. Their gimplifier hooks know about all the 59@code{_STMT} nodes and how to convert them to GENERIC forms. There 60was some work done on a genericization pass which would run first, but 61the existence of @code{STMT_EXPR} meant that in order to convert all 62of the C statements into GENERIC equivalents would involve walking the 63entire tree anyway, so it was simpler to lower all the way. This 64might change in the future if someone writes an optimization pass 65which would work better with higher-level trees, but currently the 66optimizers all expect GIMPLE@. 67 68You can request to dump a C-like representation of the GIMPLE form 69with the flag @option{-fdump-tree-gimple}. 70 71@menu 72* Tuple representation:: 73* GIMPLE instruction set:: 74* GIMPLE Exception Handling:: 75* Temporaries:: 76* Operands:: 77* Manipulating GIMPLE statements:: 78* Tuple specific accessors:: 79* GIMPLE sequences:: 80* Sequence iterators:: 81* Adding a new GIMPLE statement code:: 82* Statement and operand traversals:: 83@end menu 84 85@node Tuple representation 86@section Tuple representation 87@cindex tuples 88 89GIMPLE instructions are tuples of variable size divided in two 90groups: a header describing the instruction and its locations, 91and a variable length body with all the operands. Tuples are 92organized into a hierarchy with 3 main classes of tuples. 93 94@subsection @code{gimple_statement_base} (gsbase) 95@cindex gimple_statement_base 96 97This is the root of the hierarchy, it holds basic information 98needed by most GIMPLE statements. There are some fields that 99may not be relevant to every GIMPLE statement, but those were 100moved into the base structure to take advantage of holes left by 101other fields (thus making the structure more compact). The 102structure takes 4 words (32 bytes) on 64 bit hosts: 103 104@multitable {@code{references_memory_p}} {Size (bits)} 105@item Field @tab Size (bits) 106@item @code{code} @tab 8 107@item @code{subcode} @tab 16 108@item @code{no_warning} @tab 1 109@item @code{visited} @tab 1 110@item @code{nontemporal_move} @tab 1 111@item @code{plf} @tab 2 112@item @code{modified} @tab 1 113@item @code{has_volatile_ops} @tab 1 114@item @code{references_memory_p} @tab 1 115@item @code{uid} @tab 32 116@item @code{location} @tab 32 117@item @code{num_ops} @tab 32 118@item @code{bb} @tab 64 119@item @code{block} @tab 63 120@item Total size @tab 32 bytes 121@end multitable 122 123@itemize @bullet 124@item @code{code} 125Main identifier for a GIMPLE instruction. 126 127@item @code{subcode} 128Used to distinguish different variants of the same basic 129instruction or provide flags applicable to a given code. The 130@code{subcode} flags field has different uses depending on the code of 131the instruction, but mostly it distinguishes instructions of the 132same family. The most prominent use of this field is in 133assignments, where subcode indicates the operation done on the 134RHS of the assignment. For example, a = b + c is encoded as 135@code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}. 136 137@item @code{no_warning} 138Bitflag to indicate whether a warning has already been issued on 139this statement. 140 141@item @code{visited} 142General purpose ``visited'' marker. Set and cleared by each pass 143when needed. 144 145@item @code{nontemporal_move} 146Bitflag used in assignments that represent non-temporal moves. 147Although this bitflag is only used in assignments, it was moved 148into the base to take advantage of the bit holes left by the 149previous fields. 150 151@item @code{plf} 152Pass Local Flags. This 2-bit mask can be used as general purpose 153markers by any pass. Passes are responsible for clearing and 154setting these two flags accordingly. 155 156@item @code{modified} 157Bitflag to indicate whether the statement has been modified. 158Used mainly by the operand scanner to determine when to re-scan a 159statement for operands. 160 161@item @code{has_volatile_ops} 162Bitflag to indicate whether this statement contains operands that 163have been marked volatile. 164 165@item @code{references_memory_p} 166Bitflag to indicate whether this statement contains memory 167references (i.e., its operands are either global variables, or 168pointer dereferences or anything that must reside in memory). 169 170@item @code{uid} 171This is an unsigned integer used by passes that want to assign 172IDs to every statement. These IDs must be assigned and used by 173each pass. 174 175@item @code{location} 176This is a @code{location_t} identifier to specify source code 177location for this statement. It is inherited from the front 178end. 179 180@item @code{num_ops} 181Number of operands that this statement has. This specifies the 182size of the operand vector embedded in the tuple. Only used in 183some tuples, but it is declared in the base tuple to take 184advantage of the 32-bit hole left by the previous fields. 185 186@item @code{bb} 187Basic block holding the instruction. 188 189@item @code{block} 190Lexical block holding this statement. Also used for debug 191information generation. 192@end itemize 193 194@subsection @code{gimple_statement_with_ops} 195@cindex gimple_statement_with_ops 196 197This tuple is actually split in two: 198@code{gimple_statement_with_ops_base} and 199@code{gimple_statement_with_ops}. This is needed to accommodate the 200way the operand vector is allocated. The operand vector is 201defined to be an array of 1 element. So, to allocate a dynamic 202number of operands, the memory allocator (@code{gimple_alloc}) simply 203allocates enough memory to hold the structure itself plus @code{N 204- 1} operands which run ``off the end'' of the structure. For 205example, to allocate space for a tuple with 3 operands, 206@code{gimple_alloc} reserves @code{sizeof (struct 207gimple_statement_with_ops) + 2 * sizeof (tree)} bytes. 208 209On the other hand, several fields in this tuple need to be shared 210with the @code{gimple_statement_with_memory_ops} tuple. So, these 211common fields are placed in @code{gimple_statement_with_ops_base} which 212is then inherited from the other two tuples. 213 214 215@multitable {@code{def_ops}} {48 + 8 * @code{num_ops} bytes} 216@item @code{gsbase} @tab 256 217@item @code{def_ops} @tab 64 218@item @code{use_ops} @tab 64 219@item @code{op} @tab @code{num_ops} * 64 220@item Total size @tab 48 + 8 * @code{num_ops} bytes 221@end multitable 222 223@itemize @bullet 224@item @code{gsbase} 225Inherited from @code{struct gimple_statement_base}. 226 227@item @code{def_ops} 228Array of pointers into the operand array indicating all the slots that 229contain a variable written-to by the statement. This array is 230also used for immediate use chaining. Note that it would be 231possible to not rely on this array, but the changes required to 232implement this are pretty invasive. 233 234@item @code{use_ops} 235Similar to @code{def_ops} but for variables read by the statement. 236 237@item @code{op} 238Array of trees with @code{num_ops} slots. 239@end itemize 240 241@subsection @code{gimple_statement_with_memory_ops} 242 243This tuple is essentially identical to @code{gimple_statement_with_ops}, 244except that it contains 4 additional fields to hold vectors 245related memory stores and loads. Similar to the previous case, 246the structure is split in two to accommodate for the operand 247vector (@code{gimple_statement_with_memory_ops_base} and 248@code{gimple_statement_with_memory_ops}). 249 250 251@multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes} 252@item Field @tab Size (bits) 253@item @code{gsbase} @tab 256 254@item @code{def_ops} @tab 64 255@item @code{use_ops} @tab 64 256@item @code{vdef_ops} @tab 64 257@item @code{vuse_ops} @tab 64 258@item @code{stores} @tab 64 259@item @code{loads} @tab 64 260@item @code{op} @tab @code{num_ops} * 64 261@item Total size @tab 80 + 8 * @code{num_ops} bytes 262@end multitable 263 264@itemize @bullet 265@item @code{vdef_ops} 266Similar to @code{def_ops} but for @code{VDEF} operators. There is 267one entry per memory symbol written by this statement. This is 268used to maintain the memory SSA use-def and def-def chains. 269 270@item @code{vuse_ops} 271Similar to @code{use_ops} but for @code{VUSE} operators. There is 272one entry per memory symbol loaded by this statement. This is 273used to maintain the memory SSA use-def chains. 274 275@item @code{stores} 276Bitset with all the UIDs for the symbols written-to by the 277statement. This is different than @code{vdef_ops} in that all the 278affected symbols are mentioned in this set. If memory 279partitioning is enabled, the @code{vdef_ops} vector will refer to memory 280partitions. Furthermore, no SSA information is stored in this 281set. 282 283@item @code{loads} 284Similar to @code{stores}, but for memory loads. (Note that there 285is some amount of redundancy here, it should be possible to 286reduce memory utilization further by removing these sets). 287@end itemize 288 289All the other tuples are defined in terms of these three basic 290ones. Each tuple will add some fields. The main gimple type 291is defined to be the union of all these structures (@code{GTY} markers 292elided for clarity): 293 294@smallexample 295union gimple_statement_d 296@{ 297 struct gimple_statement_base gsbase; 298 struct gimple_statement_with_ops gsops; 299 struct gimple_statement_with_memory_ops gsmem; 300 struct gimple_statement_omp omp; 301 struct gimple_statement_bind gimple_bind; 302 struct gimple_statement_catch gimple_catch; 303 struct gimple_statement_eh_filter gimple_eh_filter; 304 struct gimple_statement_phi gimple_phi; 305 struct gimple_statement_resx gimple_resx; 306 struct gimple_statement_try gimple_try; 307 struct gimple_statement_wce gimple_wce; 308 struct gimple_statement_asm gimple_asm; 309 struct gimple_statement_omp_critical gimple_omp_critical; 310 struct gimple_statement_omp_for gimple_omp_for; 311 struct gimple_statement_omp_parallel gimple_omp_parallel; 312 struct gimple_statement_omp_task gimple_omp_task; 313 struct gimple_statement_omp_sections gimple_omp_sections; 314 struct gimple_statement_omp_single gimple_omp_single; 315 struct gimple_statement_omp_continue gimple_omp_continue; 316 struct gimple_statement_omp_atomic_load gimple_omp_atomic_load; 317 struct gimple_statement_omp_atomic_store gimple_omp_atomic_store; 318@}; 319@end smallexample 320 321 322@node GIMPLE instruction set 323@section GIMPLE instruction set 324@cindex GIMPLE instruction set 325 326The following table briefly describes the GIMPLE instruction set. 327 328@multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE} 329@item Instruction @tab High GIMPLE @tab Low GIMPLE 330@item @code{GIMPLE_ASM} @tab x @tab x 331@item @code{GIMPLE_ASSIGN} @tab x @tab x 332@item @code{GIMPLE_BIND} @tab x @tab 333@item @code{GIMPLE_CALL} @tab x @tab x 334@item @code{GIMPLE_CATCH} @tab x @tab 335@item @code{GIMPLE_COND} @tab x @tab x 336@item @code{GIMPLE_DEBUG} @tab x @tab x 337@item @code{GIMPLE_EH_FILTER} @tab x @tab 338@item @code{GIMPLE_GOTO} @tab x @tab x 339@item @code{GIMPLE_LABEL} @tab x @tab x 340@item @code{GIMPLE_NOP} @tab x @tab x 341@item @code{GIMPLE_OMP_ATOMIC_LOAD} @tab x @tab x 342@item @code{GIMPLE_OMP_ATOMIC_STORE} @tab x @tab x 343@item @code{GIMPLE_OMP_CONTINUE} @tab x @tab x 344@item @code{GIMPLE_OMP_CRITICAL} @tab x @tab x 345@item @code{GIMPLE_OMP_FOR} @tab x @tab x 346@item @code{GIMPLE_OMP_MASTER} @tab x @tab x 347@item @code{GIMPLE_OMP_ORDERED} @tab x @tab x 348@item @code{GIMPLE_OMP_PARALLEL} @tab x @tab x 349@item @code{GIMPLE_OMP_RETURN} @tab x @tab x 350@item @code{GIMPLE_OMP_SECTION} @tab x @tab x 351@item @code{GIMPLE_OMP_SECTIONS} @tab x @tab x 352@item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x @tab x 353@item @code{GIMPLE_OMP_SINGLE} @tab x @tab x 354@item @code{GIMPLE_PHI} @tab @tab x 355@item @code{GIMPLE_RESX} @tab @tab x 356@item @code{GIMPLE_RETURN} @tab x @tab x 357@item @code{GIMPLE_SWITCH} @tab x @tab x 358@item @code{GIMPLE_TRY} @tab x @tab 359@end multitable 360 361@node GIMPLE Exception Handling 362@section Exception Handling 363@cindex GIMPLE Exception Handling 364 365Other exception handling constructs are represented using 366@code{GIMPLE_TRY_CATCH}. @code{GIMPLE_TRY_CATCH} has two operands. The 367first operand is a sequence of statements to execute. If executing 368these statements does not throw an exception, then the second operand 369is ignored. Otherwise, if an exception is thrown, then the second 370operand of the @code{GIMPLE_TRY_CATCH} is checked. The second 371operand may have the following forms: 372 373@enumerate 374 375@item A sequence of statements to execute. When an exception occurs, 376these statements are executed, and then the exception is rethrown. 377 378@item A sequence of @code{GIMPLE_CATCH} statements. Each 379@code{GIMPLE_CATCH} has a list of applicable exception types and 380handler code. If the thrown exception matches one of the caught 381types, the associated handler code is executed. If the handler 382code falls off the bottom, execution continues after the original 383@code{GIMPLE_TRY_CATCH}. 384 385@item A @code{GIMPLE_EH_FILTER} statement. This has a list of 386permitted exception types, and code to handle a match failure. If the 387thrown exception does not match one of the allowed types, the 388associated match failure code is executed. If the thrown exception 389does match, it continues unwinding the stack looking for the next 390handler. 391 392@end enumerate 393 394Currently throwing an exception is not directly represented in 395GIMPLE, since it is implemented by calling a function. At some 396point in the future we will want to add some way to express that 397the call will throw an exception of a known type. 398 399Just before running the optimizers, the compiler lowers the 400high-level EH constructs above into a set of @samp{goto}s, magic 401labels, and EH regions. Continuing to unwind at the end of a 402cleanup is represented with a @code{GIMPLE_RESX}. 403 404 405@node Temporaries 406@section Temporaries 407@cindex Temporaries 408 409When gimplification encounters a subexpression that is too 410complex, it creates a new temporary variable to hold the value of 411the subexpression, and adds a new statement to initialize it 412before the current statement. These special temporaries are known 413as @samp{expression temporaries}, and are allocated using 414@code{get_formal_tmp_var}. The compiler tries to always evaluate 415identical expressions into the same temporary, to simplify 416elimination of redundant calculations. 417 418We can only use expression temporaries when we know that it will 419not be reevaluated before its value is used, and that it will not 420be otherwise modified@footnote{These restrictions are derived 421from those in Morgan 4.8.}. Other temporaries can be allocated 422using @code{get_initialized_tmp_var} or @code{create_tmp_var}. 423 424Currently, an expression like @code{a = b + 5} is not reduced any 425further. We tried converting it to something like 426@smallexample 427T1 = b + 5; 428a = T1; 429@end smallexample 430but this bloated the representation for minimal benefit. However, a 431variable which must live in memory cannot appear in an expression; its 432value is explicitly loaded into a temporary first. Similarly, storing 433the value of an expression to a memory variable goes through a 434temporary. 435 436@node Operands 437@section Operands 438@cindex Operands 439 440In general, expressions in GIMPLE consist of an operation and the 441appropriate number of simple operands; these operands must either be a 442GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register 443variable. More complex operands are factored out into temporaries, so 444that 445@smallexample 446a = b + c + d 447@end smallexample 448becomes 449@smallexample 450T1 = b + c; 451a = T1 + d; 452@end smallexample 453 454The same rule holds for arguments to a @code{GIMPLE_CALL}. 455 456The target of an assignment is usually a variable, but can also be a 457@code{MEM_REF} or a compound lvalue as described below. 458 459@menu 460* Compound Expressions:: 461* Compound Lvalues:: 462* Conditional Expressions:: 463* Logical Operators:: 464@end menu 465 466@node Compound Expressions 467@subsection Compound Expressions 468@cindex Compound Expressions 469 470The left-hand side of a C comma expression is simply moved into a separate 471statement. 472 473@node Compound Lvalues 474@subsection Compound Lvalues 475@cindex Compound Lvalues 476 477Currently compound lvalues involving array and structure field references 478are not broken down; an expression like @code{a.b[2] = 42} is not reduced 479any further (though complex array subscripts are). This restriction is a 480workaround for limitations in later optimizers; if we were to convert this 481to 482 483@smallexample 484T1 = &a.b; 485T1[2] = 42; 486@end smallexample 487 488alias analysis would not remember that the reference to @code{T1[2]} came 489by way of @code{a.b}, so it would think that the assignment could alias 490another member of @code{a}; this broke @code{struct-alias-1.c}. Future 491optimizer improvements may make this limitation unnecessary. 492 493@node Conditional Expressions 494@subsection Conditional Expressions 495@cindex Conditional Expressions 496 497A C @code{?:} expression is converted into an @code{if} statement with 498each branch assigning to the same temporary. So, 499 500@smallexample 501a = b ? c : d; 502@end smallexample 503becomes 504@smallexample 505if (b == 1) 506 T1 = c; 507else 508 T1 = d; 509a = T1; 510@end smallexample 511 512The GIMPLE level if-conversion pass re-introduces @code{?:} 513expression, if appropriate. It is used to vectorize loops with 514conditions using vector conditional operations. 515 516Note that in GIMPLE, @code{if} statements are represented using 517@code{GIMPLE_COND}, as described below. 518 519@node Logical Operators 520@subsection Logical Operators 521@cindex Logical Operators 522 523Except when they appear in the condition operand of a 524@code{GIMPLE_COND}, logical `and' and `or' operators are simplified 525as follows: @code{a = b && c} becomes 526 527@smallexample 528T1 = (bool)b; 529if (T1 == true) 530 T1 = (bool)c; 531a = T1; 532@end smallexample 533 534Note that @code{T1} in this example cannot be an expression temporary, 535because it has two different assignments. 536 537@subsection Manipulating operands 538 539All gimple operands are of type @code{tree}. But only certain 540types of trees are allowed to be used as operand tuples. Basic 541validation is controlled by the function 542@code{get_gimple_rhs_class}, which given a tree code, returns an 543@code{enum} with the following values of type @code{enum 544gimple_rhs_class} 545 546@itemize @bullet 547@item @code{GIMPLE_INVALID_RHS} 548The tree cannot be used as a GIMPLE operand. 549 550@item @code{GIMPLE_TERNARY_RHS} 551The tree is a valid GIMPLE ternary operation. 552 553@item @code{GIMPLE_BINARY_RHS} 554The tree is a valid GIMPLE binary operation. 555 556@item @code{GIMPLE_UNARY_RHS} 557The tree is a valid GIMPLE unary operation. 558 559@item @code{GIMPLE_SINGLE_RHS} 560The tree is a single object, that cannot be split into simpler 561operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc). 562 563This operand class also acts as an escape hatch for tree nodes 564that may be flattened out into the operand vector, but would need 565more than two slots on the RHS. For instance, a @code{COND_EXPR} 566expression of the form @code{(a op b) ? x : y} could be flattened 567out on the operand vector using 4 slots, but it would also 568require additional processing to distinguish @code{c = a op b} 569from @code{c = a op b ? x : y}. Something similar occurs with 570@code{ASSERT_EXPR}. In time, these special case tree 571expressions should be flattened into the operand vector. 572@end itemize 573 574For tree nodes in the categories @code{GIMPLE_TERNARY_RHS}, 575@code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be 576stored inside tuples directly. They first need to be flattened and 577separated into individual components. For instance, given the GENERIC 578expression 579 580@smallexample 581a = b + c 582@end smallexample 583 584its tree representation is: 585 586@smallexample 587MODIFY_EXPR <VAR_DECL <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>> 588@end smallexample 589 590In this case, the GIMPLE form for this statement is logically 591identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR} 592on the RHS of the assignment is not represented as a tree, 593instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree 594and flattened into the GIMPLE tuple as follows: 595 596@smallexample 597GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>> 598@end smallexample 599 600@subsection Operand vector allocation 601 602The operand vector is stored at the bottom of the three tuple 603structures that accept operands. This means, that depending on 604the code of a given statement, its operand vector will be at 605different offsets from the base of the structure. To access 606tuple operands use the following accessors 607 608@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g) 609Returns the number of operands in statement G. 610@end deftypefn 611 612@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i) 613Returns operand @code{I} from statement @code{G}. 614@end deftypefn 615 616@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g) 617Returns a pointer into the operand vector for statement @code{G}. This 618is computed using an internal table called @code{gimple_ops_offset_}[]. 619This table is indexed by the gimple code of @code{G}. 620 621When the compiler is built, this table is filled-in using the 622sizes of the structures used by each statement code defined in 623gimple.def. Since the operand vector is at the bottom of the 624structure, for a gimple code @code{C} the offset is computed as sizeof 625(struct-of @code{C}) - sizeof (tree). 626 627This mechanism adds one memory indirection to every access when 628using @code{gimple_op}(), if this becomes a bottleneck, a pass can 629choose to memoize the result from @code{gimple_ops}() and use that to 630access the operands. 631@end deftypefn 632 633@subsection Operand validation 634 635When adding a new operand to a gimple statement, the operand will 636be validated according to what each tuple accepts in its operand 637vector. These predicates are called by the 638@code{gimple_@var{name}_set_...()}. Each tuple will use one of the 639following predicates (Note, this list is not exhaustive): 640 641@deftypefn {GIMPLE function} bool is_gimple_val (tree t) 642Returns true if t is a "GIMPLE value", which are all the 643non-addressable stack variables (variables for which 644@code{is_gimple_reg} returns true) and constants (expressions for which 645@code{is_gimple_min_invariant} returns true). 646@end deftypefn 647 648@deftypefn {GIMPLE function} bool is_gimple_addressable (tree t) 649Returns true if t is a symbol or memory reference whose address 650can be taken. 651@end deftypefn 652 653@deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t) 654Similar to @code{is_gimple_val} but it also accepts hard registers. 655@end deftypefn 656 657@deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t) 658Return true if t is a valid expression to use as the function 659called by a @code{GIMPLE_CALL}. 660@end deftypefn 661 662@deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t) 663Return true if t is a valid expression to use as first operand 664of a @code{MEM_REF} expression. 665@end deftypefn 666 667@deftypefn {GIMPLE function} bool is_gimple_constant (tree t) 668Return true if t is a valid gimple constant. 669@end deftypefn 670 671@deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t) 672Return true if t is a valid minimal invariant. This is different 673from constants, in that the specific value of t may not be known 674at compile time, but it is known that it doesn't change (e.g., 675the address of a function local variable). 676@end deftypefn 677 678@deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t) 679Return true if t is an interprocedural invariant. This means that t 680is a valid invariant in all functions (e.g. it can be an address of a 681global variable but not of a local one). 682@end deftypefn 683 684@deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t) 685Return true if t is an @code{ADDR_EXPR} that does not change once the 686program is running (and which is valid in all functions). 687@end deftypefn 688 689 690@subsection Statement validation 691 692@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g) 693Return true if the code of g is @code{GIMPLE_ASSIGN}. 694@end deftypefn 695 696@deftypefn {GIMPLE function} bool is_gimple_call (gimple g) 697Return true if the code of g is @code{GIMPLE_CALL}. 698@end deftypefn 699 700@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g) 701Return true if the code of g is @code{GIMPLE_DEBUG}. 702@end deftypefn 703 704@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple g) 705Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast 706operation. 707@end deftypefn 708 709@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g) 710Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an 711expression to a variable. 712@end deftypefn 713 714@node Manipulating GIMPLE statements 715@section Manipulating GIMPLE statements 716@cindex Manipulating GIMPLE statements 717 718This section documents all the functions available to handle each 719of the GIMPLE instructions. 720 721@subsection Common accessors 722The following are common accessors for gimple statements. 723 724@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g) 725Return the code for statement @code{G}. 726@end deftypefn 727 728@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g) 729Return the basic block to which statement @code{G} belongs to. 730@end deftypefn 731 732@deftypefn {GIMPLE function} tree gimple_block (gimple g) 733Return the lexical scope block holding statement @code{G}. 734@end deftypefn 735 736@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt) 737Return the type of the main expression computed by @code{STMT}. Return 738@code{void_type_node} if @code{STMT} computes nothing. This will only return 739something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and 740@code{GIMPLE_CALL}. For all other tuple codes, it will return 741@code{void_type_node}. 742@end deftypefn 743 744@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt) 745Return the tree code for the expression computed by @code{STMT}. This 746is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and 747@code{GIMPLE_COND}. If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}. 748For @code{GIMPLE_COND}, it returns the code of the comparison predicate. 749For @code{GIMPLE_ASSIGN} it returns the code of the operation performed 750by the @code{RHS} of the assignment. 751@end deftypefn 752 753@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block) 754Set the lexical scope block of @code{G} to @code{BLOCK}. 755@end deftypefn 756 757@deftypefn {GIMPLE function} location_t gimple_locus (gimple g) 758Return locus information for statement @code{G}. 759@end deftypefn 760 761@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus) 762Set locus information for statement @code{G}. 763@end deftypefn 764 765@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g) 766Return true if @code{G} does not have locus information. 767@end deftypefn 768 769@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt) 770Return true if no warnings should be emitted for statement @code{STMT}. 771@end deftypefn 772 773@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p) 774Set the visited status on statement @code{STMT} to @code{VISITED_P}. 775@end deftypefn 776 777@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt) 778Return the visited status on statement @code{STMT}. 779@end deftypefn 780 781@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p) 782Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}. 783@end deftypefn 784 785@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf) 786Return the value of pass local flag @code{PLF} on statement @code{STMT}. 787@end deftypefn 788 789@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g) 790Return true if statement @code{G} has register or memory operands. 791@end deftypefn 792 793@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g) 794Return true if statement @code{G} has memory operands. 795@end deftypefn 796 797@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g) 798Return the number of operands for statement @code{G}. 799@end deftypefn 800 801@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g) 802Return the array of operands for statement @code{G}. 803@end deftypefn 804 805@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i) 806Return operand @code{I} for statement @code{G}. 807@end deftypefn 808 809@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i) 810Return a pointer to operand @code{I} for statement @code{G}. 811@end deftypefn 812 813@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op) 814Set operand @code{I} of statement @code{G} to @code{OP}. 815@end deftypefn 816 817@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt) 818Return the set of symbols that have had their address taken by 819@code{STMT}. 820@end deftypefn 821 822@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g) 823Return the set of @code{DEF} operands for statement @code{G}. 824@end deftypefn 825 826@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def) 827Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}. 828@end deftypefn 829 830@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g) 831Return the set of @code{USE} operands for statement @code{G}. 832@end deftypefn 833 834@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use) 835Set @code{USE} to be the set of @code{USE} operands for statement @code{G}. 836@end deftypefn 837 838@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g) 839Return the set of @code{VUSE} operands for statement @code{G}. 840@end deftypefn 841 842@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops) 843Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}. 844@end deftypefn 845 846@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g) 847Return the set of @code{VDEF} operands for statement @code{G}. 848@end deftypefn 849 850@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops) 851Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}. 852@end deftypefn 853 854@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g) 855Return the set of symbols loaded by statement @code{G}. Each element of 856the set is the @code{DECL_UID} of the corresponding symbol. 857@end deftypefn 858 859@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g) 860Return the set of symbols stored by statement @code{G}. Each element of 861the set is the @code{DECL_UID} of the corresponding symbol. 862@end deftypefn 863 864@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g) 865Return true if statement @code{G} has operands and the modified field 866has been set. 867@end deftypefn 868 869@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt) 870Return true if statement @code{STMT} contains volatile operands. 871@end deftypefn 872 873@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep) 874Return true if statement @code{STMT} contains volatile operands. 875@end deftypefn 876 877@deftypefn {GIMPLE function} void update_stmt (gimple s) 878Mark statement @code{S} as modified, and update it. 879@end deftypefn 880 881@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s) 882Update statement @code{S} if it has been marked modified. 883@end deftypefn 884 885@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt) 886Return a deep copy of statement @code{STMT}. 887@end deftypefn 888 889@node Tuple specific accessors 890@section Tuple specific accessors 891@cindex Tuple specific accessors 892 893@menu 894* @code{GIMPLE_ASM}:: 895* @code{GIMPLE_ASSIGN}:: 896* @code{GIMPLE_BIND}:: 897* @code{GIMPLE_CALL}:: 898* @code{GIMPLE_CATCH}:: 899* @code{GIMPLE_COND}:: 900* @code{GIMPLE_DEBUG}:: 901* @code{GIMPLE_EH_FILTER}:: 902* @code{GIMPLE_LABEL}:: 903* @code{GIMPLE_NOP}:: 904* @code{GIMPLE_OMP_ATOMIC_LOAD}:: 905* @code{GIMPLE_OMP_ATOMIC_STORE}:: 906* @code{GIMPLE_OMP_CONTINUE}:: 907* @code{GIMPLE_OMP_CRITICAL}:: 908* @code{GIMPLE_OMP_FOR}:: 909* @code{GIMPLE_OMP_MASTER}:: 910* @code{GIMPLE_OMP_ORDERED}:: 911* @code{GIMPLE_OMP_PARALLEL}:: 912* @code{GIMPLE_OMP_RETURN}:: 913* @code{GIMPLE_OMP_SECTION}:: 914* @code{GIMPLE_OMP_SECTIONS}:: 915* @code{GIMPLE_OMP_SINGLE}:: 916* @code{GIMPLE_PHI}:: 917* @code{GIMPLE_RESX}:: 918* @code{GIMPLE_RETURN}:: 919* @code{GIMPLE_SWITCH}:: 920* @code{GIMPLE_TRY}:: 921* @code{GIMPLE_WITH_CLEANUP_EXPR}:: 922@end menu 923 924 925@node @code{GIMPLE_ASM} 926@subsection @code{GIMPLE_ASM} 927@cindex @code{GIMPLE_ASM} 928 929@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...) 930Build a @code{GIMPLE_ASM} statement. This statement is used for 931building in-line assembly constructs. @code{STRING} is the assembly 932code. @code{NINPUT} is the number of register inputs. @code{NOUTPUT} is the 933number of register outputs. @code{NCLOBBERS} is the number of clobbered 934registers. The rest of the arguments trees for each input, 935output, and clobbered registers. 936@end deftypefn 937 938@deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *) 939Identical to gimple_build_asm, but the arguments are passed in 940VECs. 941@end deftypefn 942 943@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g) 944Return the number of input operands for @code{GIMPLE_ASM} @code{G}. 945@end deftypefn 946 947@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g) 948Return the number of output operands for @code{GIMPLE_ASM} @code{G}. 949@end deftypefn 950 951@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g) 952Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}. 953@end deftypefn 954 955@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index) 956Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 957@end deftypefn 958 959@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op) 960Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 961@end deftypefn 962 963@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index) 964Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 965@end deftypefn 966 967@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @ 968unsigned index, tree out_op) 969Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 970@end deftypefn 971 972@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index) 973Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}. 974@end deftypefn 975 976@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op) 977Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}. 978@end deftypefn 979 980@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g) 981Return the string representing the assembly instruction in 982@code{GIMPLE_ASM} @code{G}. 983@end deftypefn 984 985@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g) 986Return true if @code{G} is an asm statement marked volatile. 987@end deftypefn 988 989@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g) 990Mark asm statement @code{G} as volatile. 991@end deftypefn 992 993@deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g) 994Remove volatile marker from asm statement @code{G}. 995@end deftypefn 996 997@node @code{GIMPLE_ASSIGN} 998@subsection @code{GIMPLE_ASSIGN} 999@cindex @code{GIMPLE_ASSIGN} 1000 1001@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs) 1002Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue 1003passed in lhs. The right-hand side can be either a unary or 1004binary tree expression. The expression tree rhs will be 1005flattened and its operands assigned to the corresponding operand 1006slots in the new statement. This function is useful when you 1007already have a tree expression that you want to convert into a 1008tuple. However, try to avoid building expression trees for the 1009sole purpose of calling this function. If you already have the 1010operands in separate trees, it is better to use 1011@code{gimple_build_assign_with_ops}. 1012@end deftypefn 1013 1014 1015@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p) 1016Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of 1017@code{*SEQ_P}. 1018@end deftypefn 1019 1020@code{DST}/@code{SRC} are the destination and source respectively. You can 1021pass ungimplified trees in @code{DST} or @code{SRC}, in which 1022case they will be converted to a gimple operand if necessary. 1023 1024This function returns the newly created @code{GIMPLE_ASSIGN} tuple. 1025 1026@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @ 1027(enum tree_code subcode, tree lhs, tree op1, tree op2) 1028This function is similar to @code{gimple_build_assign}, but is used to 1029build a @code{GIMPLE_ASSIGN} statement when the operands of the 1030right-hand side of the assignment are already split into 1031different operands. 1032 1033The left-hand side is an lvalue passed in lhs. Subcode is the 1034@code{tree_code} for the right-hand side of the assignment. Op1 and op2 1035are the operands. If op2 is null, subcode must be a @code{tree_code} 1036for a unary expression. 1037@end deftypefn 1038 1039@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g) 1040Return the code of the expression computed on the @code{RHS} of 1041assignment statement @code{G}. 1042@end deftypefn 1043 1044 1045@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g) 1046Return the gimple rhs class of the code for the expression 1047computed on the rhs of assignment statement @code{G}. This will never 1048return @code{GIMPLE_INVALID_RHS}. 1049@end deftypefn 1050 1051@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g) 1052Return the @code{LHS} of assignment statement @code{G}. 1053@end deftypefn 1054 1055@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g) 1056Return a pointer to the @code{LHS} of assignment statement @code{G}. 1057@end deftypefn 1058 1059@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g) 1060Return the first operand on the @code{RHS} of assignment statement @code{G}. 1061@end deftypefn 1062 1063@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g) 1064Return the address of the first operand on the @code{RHS} of assignment 1065statement @code{G}. 1066@end deftypefn 1067 1068@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g) 1069Return the second operand on the @code{RHS} of assignment statement @code{G}. 1070@end deftypefn 1071 1072@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g) 1073Return the address of the second operand on the @code{RHS} of assignment 1074statement @code{G}. 1075@end deftypefn 1076 1077@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g) 1078Return the third operand on the @code{RHS} of assignment statement @code{G}. 1079@end deftypefn 1080 1081@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g) 1082Return the address of the third operand on the @code{RHS} of assignment 1083statement @code{G}. 1084@end deftypefn 1085 1086@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs) 1087Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}. 1088@end deftypefn 1089 1090@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs) 1091Set @code{RHS} to be the first operand on the @code{RHS} of assignment 1092statement @code{G}. 1093@end deftypefn 1094 1095@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs) 1096Set @code{RHS} to be the second operand on the @code{RHS} of assignment 1097statement @code{G}. 1098@end deftypefn 1099 1100@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs) 1101Set @code{RHS} to be the third operand on the @code{RHS} of assignment 1102statement @code{G}. 1103@end deftypefn 1104 1105@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s) 1106Return true if @code{S} is a type-cast assignment. 1107@end deftypefn 1108 1109 1110@node @code{GIMPLE_BIND} 1111@subsection @code{GIMPLE_BIND} 1112@cindex @code{GIMPLE_BIND} 1113 1114@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body) 1115Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS} 1116and a body of statements in sequence @code{BODY}. 1117@end deftypefn 1118 1119@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g) 1120Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}. 1121@end deftypefn 1122 1123@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars) 1124Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND} 1125statement @code{G}. 1126@end deftypefn 1127 1128@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars) 1129Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND} 1130statement @code{G}. 1131@end deftypefn 1132 1133@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g) 1134Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement 1135@code{G}. 1136@end deftypefn 1137 1138@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq) 1139Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}. 1140@end deftypefn 1141 1142@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt) 1143Append a statement to the end of a @code{GIMPLE_BIND}'s body. 1144@end deftypefn 1145 1146@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq) 1147Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s 1148body. 1149@end deftypefn 1150 1151@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g) 1152Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement 1153@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees. 1154@end deftypefn 1155 1156@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block) 1157Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} 1158statement @code{G}. 1159@end deftypefn 1160 1161 1162@node @code{GIMPLE_CALL} 1163@subsection @code{GIMPLE_CALL} 1164@cindex @code{GIMPLE_CALL} 1165 1166@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...) 1167Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN} 1168must be either a @code{FUNCTION_DECL} or a gimple call address as 1169determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of 1170arguments. The rest of the arguments follow the argument @code{NARGS}, 1171and must be trees that are valid as rvalues in gimple (i.e., each 1172operand is validated with @code{is_gimple_operand}). 1173@end deftypefn 1174 1175 1176@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr) 1177Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments and the 1178function are taken from the expression directly. This routine 1179assumes that @code{call_expr} is already in GIMPLE form. That is, its 1180operands are GIMPLE values and the function call needs no further 1181simplification. All the call flags in @code{call_expr} are copied over 1182to the new @code{GIMPLE_CALL}. 1183@end deftypefn 1184 1185@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args) 1186Identical to @code{gimple_build_call} but the arguments are stored in a 1187@code{VEC}(). 1188@end deftypefn 1189 1190@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g) 1191Return the @code{LHS} of call statement @code{G}. 1192@end deftypefn 1193 1194@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g) 1195Return a pointer to the @code{LHS} of call statement @code{G}. 1196@end deftypefn 1197 1198@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs) 1199Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}. 1200@end deftypefn 1201 1202@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g) 1203Return the tree node representing the function called by call 1204statement @code{G}. 1205@end deftypefn 1206 1207@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn) 1208Set @code{FN} to be the function called by call statement @code{G}. This has 1209to be a gimple value specifying the address of the called 1210function. 1211@end deftypefn 1212 1213@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g) 1214If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it. 1215Otherwise return @code{NULL}. This function is analogous to 1216@code{get_callee_fndecl} in @code{GENERIC}. 1217@end deftypefn 1218 1219@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl) 1220Set the called function to @code{FNDECL}. 1221@end deftypefn 1222 1223@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g) 1224Return the type returned by call statement @code{G}. 1225@end deftypefn 1226 1227@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g) 1228Return the static chain for call statement @code{G}. 1229@end deftypefn 1230 1231@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain) 1232Set @code{CHAIN} to be the static chain for call statement @code{G}. 1233@end deftypefn 1234 1235@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g) 1236Return the number of arguments used by call statement @code{G}. 1237@end deftypefn 1238 1239@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index) 1240Return the argument at position @code{INDEX} for call statement @code{G}. The 1241first argument is 0. 1242@end deftypefn 1243 1244@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index) 1245Return a pointer to the argument at position @code{INDEX} for call 1246statement @code{G}. 1247@end deftypefn 1248 1249@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg) 1250Set @code{ARG} to be the argument at position @code{INDEX} for call statement 1251@code{G}. 1252@end deftypefn 1253 1254@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s) 1255Mark call statement @code{S} as being a tail call (i.e., a call just 1256before the exit of a function). These calls are candidate for 1257tail call optimization. 1258@end deftypefn 1259 1260@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s) 1261Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call. 1262@end deftypefn 1263 1264@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s) 1265Mark @code{GIMPLE_CALL} @code{S} as being uninlinable. 1266@end deftypefn 1267 1268@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s) 1269Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined. 1270@end deftypefn 1271 1272@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s) 1273Return true if @code{S} is a noreturn call. 1274@end deftypefn 1275 1276@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip) 1277Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments 1278in the positions marked by the set @code{ARGS_TO_SKIP}. 1279@end deftypefn 1280 1281 1282@node @code{GIMPLE_CATCH} 1283@subsection @code{GIMPLE_CATCH} 1284@cindex @code{GIMPLE_CATCH} 1285 1286@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler) 1287Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this 1288catch handles. @code{HANDLER} is a sequence of statements with the code 1289for the handler. 1290@end deftypefn 1291 1292@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g) 1293Return the types handled by @code{GIMPLE_CATCH} statement @code{G}. 1294@end deftypefn 1295 1296@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g) 1297Return a pointer to the types handled by @code{GIMPLE_CATCH} statement 1298@code{G}. 1299@end deftypefn 1300 1301@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g) 1302Return the GIMPLE sequence representing the body of the handler 1303of @code{GIMPLE_CATCH} statement @code{G}. 1304@end deftypefn 1305 1306@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t) 1307Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}. 1308@end deftypefn 1309 1310@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler) 1311Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}. 1312@end deftypefn 1313 1314 1315@node @code{GIMPLE_COND} 1316@subsection @code{GIMPLE_COND} 1317@cindex @code{GIMPLE_COND} 1318 1319@deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label) 1320Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares 1321@code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to 1322the label in @code{t_label}, otherwise jump to the label in @code{f_label}. 1323@code{PRED_CODE} are relational operator tree codes like @code{EQ_EXPR}, 1324@code{LT_EXPR}, @code{LE_EXPR}, @code{NE_EXPR}, etc. 1325@end deftypefn 1326 1327 1328@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label) 1329Build a @code{GIMPLE_COND} statement from the conditional expression 1330tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}. 1331@end deftypefn 1332 1333@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g) 1334Return the code of the predicate computed by conditional 1335statement @code{G}. 1336@end deftypefn 1337 1338@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code) 1339Set @code{CODE} to be the predicate code for the conditional statement 1340@code{G}. 1341@end deftypefn 1342 1343@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g) 1344Return the @code{LHS} of the predicate computed by conditional statement 1345@code{G}. 1346@end deftypefn 1347 1348@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs) 1349Set @code{LHS} to be the @code{LHS} operand of the predicate computed by 1350conditional statement @code{G}. 1351@end deftypefn 1352 1353@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g) 1354Return the @code{RHS} operand of the predicate computed by conditional 1355@code{G}. 1356@end deftypefn 1357 1358@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs) 1359Set @code{RHS} to be the @code{RHS} operand of the predicate computed by 1360conditional statement @code{G}. 1361@end deftypefn 1362 1363@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g) 1364Return the label used by conditional statement @code{G} when its 1365predicate evaluates to true. 1366@end deftypefn 1367 1368@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label) 1369Set @code{LABEL} to be the label used by conditional statement @code{G} when 1370its predicate evaluates to true. 1371@end deftypefn 1372 1373@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label) 1374Set @code{LABEL} to be the label used by conditional statement @code{G} when 1375its predicate evaluates to false. 1376@end deftypefn 1377 1378@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g) 1379Return the label used by conditional statement @code{G} when its 1380predicate evaluates to false. 1381@end deftypefn 1382 1383@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g) 1384Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'. 1385@end deftypefn 1386 1387@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g) 1388Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'. 1389@end deftypefn 1390 1391@node @code{GIMPLE_DEBUG} 1392@subsection @code{GIMPLE_DEBUG} 1393@cindex @code{GIMPLE_DEBUG} 1394@cindex @code{GIMPLE_DEBUG_BIND} 1395 1396@deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt) 1397Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of 1398@code{subcode}. The effect of this statement is to tell debug 1399information generation machinery that the value of user variable 1400@code{var} is given by @code{value} at that point, and to remain with 1401that value until @code{var} runs out of scope, a 1402dynamically-subsequent debug bind statement overrides the binding, or 1403conflicting values reach a control flow merge point. Even if 1404components of the @code{value} expression change afterwards, the 1405variable is supposed to retain the same value, though not necessarily 1406the same location. 1407 1408It is expected that @code{var} be most often a tree for automatic user 1409variables (@code{VAR_DECL} or @code{PARM_DECL}) that satisfy the 1410requirements for gimple registers, but it may also be a tree for a 1411scalarized component of a user variable (@code{ARRAY_REF}, 1412@code{COMPONENT_REF}), or a debug temporary (@code{DEBUG_EXPR_DECL}). 1413 1414As for @code{value}, it can be an arbitrary tree expression, but it is 1415recommended that it be in a suitable form for a gimple assignment 1416@code{RHS}. It is not expected that user variables that could appear 1417as @code{var} ever appear in @code{value}, because in the latter we'd 1418have their @code{SSA_NAME}s instead, but even if they were not in SSA 1419form, user variables appearing in @code{value} are to be regarded as 1420part of the executable code space, whereas those in @code{var} are to 1421be regarded as part of the source code space. There is no way to 1422refer to the value bound to a user variable within a @code{value} 1423expression. 1424 1425If @code{value} is @code{GIMPLE_DEBUG_BIND_NOVALUE}, debug information 1426generation machinery is informed that the variable @code{var} is 1427unbound, i.e., that its value is indeterminate, which sometimes means 1428it is really unavailable, and other times that the compiler could not 1429keep track of it. 1430 1431Block and location information for the newly-created stmt are 1432taken from @code{stmt}, if given. 1433@end deftypefn 1434 1435@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt) 1436Return the user variable @var{var} that is bound at @code{stmt}. 1437@end deftypefn 1438 1439@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt) 1440Return the value expression that is bound to a user variable at 1441@code{stmt}. 1442@end deftypefn 1443 1444@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt) 1445Return a pointer to the value expression that is bound to a user 1446variable at @code{stmt}. 1447@end deftypefn 1448 1449@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var) 1450Modify the user variable bound at @code{stmt} to @var{var}. 1451@end deftypefn 1452 1453@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var) 1454Modify the value bound to the user variable bound at @code{stmt} to 1455@var{value}. 1456@end deftypefn 1457 1458@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt) 1459Modify the value bound to the user variable bound at @code{stmt} so 1460that the variable becomes unbound. 1461@end deftypefn 1462 1463@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt) 1464Return @code{TRUE} if @code{stmt} binds a user variable to a value, 1465and @code{FALSE} if it unbinds the variable. 1466@end deftypefn 1467 1468@node @code{GIMPLE_EH_FILTER} 1469@subsection @code{GIMPLE_EH_FILTER} 1470@cindex @code{GIMPLE_EH_FILTER} 1471 1472@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure) 1473Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's 1474types. @code{FAILURE} is a sequence with the filter's failure action. 1475@end deftypefn 1476 1477@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g) 1478Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}. 1479@end deftypefn 1480 1481@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g) 1482Return a pointer to the types handled by @code{GIMPLE_EH_FILTER} 1483statement @code{G}. 1484@end deftypefn 1485 1486@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g) 1487Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER} 1488statement fails. 1489@end deftypefn 1490 1491@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types) 1492Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}. 1493@end deftypefn 1494 1495@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure) 1496Set @code{FAILURE} to be the sequence of statements to execute on 1497failure for @code{GIMPLE_EH_FILTER} @code{G}. 1498@end deftypefn 1499 1500@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g) 1501Return the @code{EH_FILTER_MUST_NOT_THROW} flag. 1502@end deftypefn 1503 1504@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp) 1505Set the @code{EH_FILTER_MUST_NOT_THROW} flag. 1506@end deftypefn 1507 1508 1509@node @code{GIMPLE_LABEL} 1510@subsection @code{GIMPLE_LABEL} 1511@cindex @code{GIMPLE_LABEL} 1512 1513@deftypefn {GIMPLE function} gimple gimple_build_label (tree label) 1514Build a @code{GIMPLE_LABEL} statement with corresponding to the tree 1515label, @code{LABEL}. 1516@end deftypefn 1517 1518@deftypefn {GIMPLE function} tree gimple_label_label (gimple g) 1519Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}. 1520@end deftypefn 1521 1522@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label) 1523Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} 1524statement @code{G}. 1525@end deftypefn 1526 1527 1528@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest) 1529Build a @code{GIMPLE_GOTO} statement to label @code{DEST}. 1530@end deftypefn 1531 1532@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g) 1533Return the destination of the unconditional jump @code{G}. 1534@end deftypefn 1535 1536@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest) 1537Set @code{DEST} to be the destination of the unconditional jump @code{G}. 1538@end deftypefn 1539 1540 1541@node @code{GIMPLE_NOP} 1542@subsection @code{GIMPLE_NOP} 1543@cindex @code{GIMPLE_NOP} 1544 1545@deftypefn {GIMPLE function} gimple gimple_build_nop (void) 1546Build a @code{GIMPLE_NOP} statement. 1547@end deftypefn 1548 1549@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g) 1550Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}. 1551@end deftypefn 1552 1553@node @code{GIMPLE_OMP_ATOMIC_LOAD} 1554@subsection @code{GIMPLE_OMP_ATOMIC_LOAD} 1555@cindex @code{GIMPLE_OMP_ATOMIC_LOAD} 1556 1557@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs) 1558Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand 1559side of the assignment. @code{RHS} is the right-hand side of the 1560assignment. 1561@end deftypefn 1562 1563@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs) 1564Set the @code{LHS} of an atomic load. 1565@end deftypefn 1566 1567@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g) 1568Get the @code{LHS} of an atomic load. 1569@end deftypefn 1570 1571@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs) 1572Set the @code{RHS} of an atomic set. 1573@end deftypefn 1574 1575@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g) 1576Get the @code{RHS} of an atomic set. 1577@end deftypefn 1578 1579 1580@node @code{GIMPLE_OMP_ATOMIC_STORE} 1581@subsection @code{GIMPLE_OMP_ATOMIC_STORE} 1582@cindex @code{GIMPLE_OMP_ATOMIC_STORE} 1583 1584@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val) 1585Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be 1586stored. 1587@end deftypefn 1588 1589@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val) 1590Set the value being stored in an atomic store. 1591@end deftypefn 1592 1593@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g) 1594Return the value being stored in an atomic store. 1595@end deftypefn 1596 1597@node @code{GIMPLE_OMP_CONTINUE} 1598@subsection @code{GIMPLE_OMP_CONTINUE} 1599@cindex @code{GIMPLE_OMP_CONTINUE} 1600 1601@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use) 1602Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the 1603definition of the control variable. @code{CONTROL_USE} is the use of 1604the control variable. 1605@end deftypefn 1606 1607@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s) 1608Return the definition of the control variable on a 1609@code{GIMPLE_OMP_CONTINUE} in @code{S}. 1610@end deftypefn 1611 1612@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s) 1613Same as above, but return the pointer. 1614@end deftypefn 1615 1616@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s) 1617Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE} 1618statement in @code{S}. 1619@end deftypefn 1620 1621@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s) 1622Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE} 1623in @code{S}. 1624@end deftypefn 1625 1626@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s) 1627Same as above, but return the pointer. 1628@end deftypefn 1629 1630@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s) 1631Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement 1632in @code{S}. 1633@end deftypefn 1634 1635 1636@node @code{GIMPLE_OMP_CRITICAL} 1637@subsection @code{GIMPLE_OMP_CRITICAL} 1638@cindex @code{GIMPLE_OMP_CRITICAL} 1639 1640@deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name) 1641Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of 1642statements for which only one thread can execute. @code{NAME} is an 1643optional identifier for this critical block. 1644@end deftypefn 1645 1646@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g) 1647Return the name associated with @code{OMP_CRITICAL} statement @code{G}. 1648@end deftypefn 1649 1650@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g) 1651Return a pointer to the name associated with @code{OMP} critical 1652statement @code{G}. 1653@end deftypefn 1654 1655@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name) 1656Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}. 1657@end deftypefn 1658 1659@node @code{GIMPLE_OMP_FOR} 1660@subsection @code{GIMPLE_OMP_FOR} 1661@cindex @code{GIMPLE_OMP_FOR} 1662 1663@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @ 1664tree clauses, tree index, tree initial, tree final, tree incr, @ 1665gimple_seq pre_body, enum tree_code omp_for_cond) 1666Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements 1667inside the for loop. @code{CLAUSES}, are any of the @code{OMP} loop 1668construct's clauses: private, firstprivate, lastprivate, 1669reductions, ordered, schedule, and nowait. @code{PRE_BODY} is the 1670sequence of statements that are loop invariant. @code{INDEX} is the 1671index variable. @code{INITIAL} is the initial value of @code{INDEX}. @code{FINAL} is 1672final value of @code{INDEX}. OMP_FOR_COND is the predicate used to 1673compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression. 1674@end deftypefn 1675 1676@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g) 1677Return the clauses associated with @code{OMP_FOR} @code{G}. 1678@end deftypefn 1679 1680@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g) 1681Return a pointer to the @code{OMP_FOR} @code{G}. 1682@end deftypefn 1683 1684@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses) 1685Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}. 1686@end deftypefn 1687 1688@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g) 1689Return the index variable for @code{OMP_FOR} @code{G}. 1690@end deftypefn 1691 1692@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g) 1693Return a pointer to the index variable for @code{OMP_FOR} @code{G}. 1694@end deftypefn 1695 1696@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index) 1697Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}. 1698@end deftypefn 1699 1700@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g) 1701Return the initial value for @code{OMP_FOR} @code{G}. 1702@end deftypefn 1703 1704@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g) 1705Return a pointer to the initial value for @code{OMP_FOR} @code{G}. 1706@end deftypefn 1707 1708@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial) 1709Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}. 1710@end deftypefn 1711 1712@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g) 1713Return the final value for @code{OMP_FOR} @code{G}. 1714@end deftypefn 1715 1716@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g) 1717turn a pointer to the final value for @code{OMP_FOR} @code{G}. 1718@end deftypefn 1719 1720@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final) 1721Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}. 1722@end deftypefn 1723 1724@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g) 1725Return the increment value for @code{OMP_FOR} @code{G}. 1726@end deftypefn 1727 1728@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g) 1729Return a pointer to the increment value for @code{OMP_FOR} @code{G}. 1730@end deftypefn 1731 1732@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr) 1733Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}. 1734@end deftypefn 1735 1736@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g) 1737Return the sequence of statements to execute before the @code{OMP_FOR} 1738statement @code{G} starts. 1739@end deftypefn 1740 1741@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body) 1742Set @code{PRE_BODY} to be the sequence of statements to execute before 1743the @code{OMP_FOR} statement @code{G} starts. 1744@end deftypefn 1745 1746@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond) 1747Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}. 1748@end deftypefn 1749 1750@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g) 1751Return the condition code associated with @code{OMP_FOR} @code{G}. 1752@end deftypefn 1753 1754 1755@node @code{GIMPLE_OMP_MASTER} 1756@subsection @code{GIMPLE_OMP_MASTER} 1757@cindex @code{GIMPLE_OMP_MASTER} 1758 1759@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body) 1760Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of 1761statements to be executed by just the master. 1762@end deftypefn 1763 1764 1765@node @code{GIMPLE_OMP_ORDERED} 1766@subsection @code{GIMPLE_OMP_ORDERED} 1767@cindex @code{GIMPLE_OMP_ORDERED} 1768 1769@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body) 1770Build a @code{GIMPLE_OMP_ORDERED} statement. 1771@end deftypefn 1772 1773@code{BODY} is the sequence of statements inside a loop that will 1774executed in sequence. 1775 1776 1777@node @code{GIMPLE_OMP_PARALLEL} 1778@subsection @code{GIMPLE_OMP_PARALLEL} 1779@cindex @code{GIMPLE_OMP_PARALLEL} 1780 1781@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq @ 1782body, tree clauses, tree child_fn, tree data_arg) 1783Build a @code{GIMPLE_OMP_PARALLEL} statement. 1784@end deftypefn 1785 1786@code{BODY} is sequence of statements which are executed in parallel. 1787@code{CLAUSES}, are the @code{OMP} parallel construct's clauses. @code{CHILD_FN} is 1788the function created for the parallel threads to execute. 1789@code{DATA_ARG} are the shared data argument(s). 1790 1791@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g) 1792Return true if @code{OMP} parallel statement @code{G} has the 1793@code{GF_OMP_PARALLEL_COMBINED} flag set. 1794@end deftypefn 1795 1796@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g) 1797Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement 1798@code{G}. 1799@end deftypefn 1800 1801@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g) 1802Return the body for the @code{OMP} statement @code{G}. 1803@end deftypefn 1804 1805@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body) 1806Set @code{BODY} to be the body for the @code{OMP} statement @code{G}. 1807@end deftypefn 1808 1809@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g) 1810Return the clauses associated with @code{OMP_PARALLEL} @code{G}. 1811@end deftypefn 1812 1813@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g) 1814Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}. 1815@end deftypefn 1816 1817@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses) 1818Set @code{CLAUSES} to be the list of clauses associated with 1819@code{OMP_PARALLEL} @code{G}. 1820@end deftypefn 1821 1822@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g) 1823Return the child function used to hold the body of @code{OMP_PARALLEL} 1824@code{G}. 1825@end deftypefn 1826 1827@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g) 1828Return a pointer to the child function used to hold the body of 1829@code{OMP_PARALLEL} @code{G}. 1830@end deftypefn 1831 1832@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn) 1833Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}. 1834@end deftypefn 1835 1836@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g) 1837Return the artificial argument used to send variables and values 1838from the parent to the children threads in @code{OMP_PARALLEL} @code{G}. 1839@end deftypefn 1840 1841@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g) 1842Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}. 1843@end deftypefn 1844 1845@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg) 1846Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}. 1847@end deftypefn 1848 1849@deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt) 1850Returns true when the gimple statement @code{STMT} is any of the OpenMP 1851types. 1852@end deftypefn 1853 1854 1855@node @code{GIMPLE_OMP_RETURN} 1856@subsection @code{GIMPLE_OMP_RETURN} 1857@cindex @code{GIMPLE_OMP_RETURN} 1858 1859@deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p) 1860Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a 1861non-waiting return. 1862@end deftypefn 1863 1864@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s) 1865Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}. 1866@end deftypefn 1867 1868 1869@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g) 1870Return true if @code{OMP} return statement @code{G} has the 1871@code{GF_OMP_RETURN_NOWAIT} flag set. 1872@end deftypefn 1873 1874@node @code{GIMPLE_OMP_SECTION} 1875@subsection @code{GIMPLE_OMP_SECTION} 1876@cindex @code{GIMPLE_OMP_SECTION} 1877 1878@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body) 1879Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement. 1880@end deftypefn 1881 1882@code{BODY} is the sequence of statements in the section. 1883 1884@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g) 1885Return true if @code{OMP} section statement @code{G} has the 1886@code{GF_OMP_SECTION_LAST} flag set. 1887@end deftypefn 1888 1889@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g) 1890Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}. 1891@end deftypefn 1892 1893@node @code{GIMPLE_OMP_SECTIONS} 1894@subsection @code{GIMPLE_OMP_SECTIONS} 1895@cindex @code{GIMPLE_OMP_SECTIONS} 1896 1897@deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses) 1898Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of 1899section statements. @code{CLAUSES} are any of the @code{OMP} sections 1900construct's clauses: private, firstprivate, lastprivate, 1901reduction, and nowait. 1902@end deftypefn 1903 1904 1905@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void) 1906Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement. 1907@end deftypefn 1908 1909@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g) 1910Return the control variable associated with the 1911@code{GIMPLE_OMP_SECTIONS} in @code{G}. 1912@end deftypefn 1913 1914@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g) 1915Return a pointer to the clauses associated with the 1916@code{GIMPLE_OMP_SECTIONS} in @code{G}. 1917@end deftypefn 1918 1919@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control) 1920Set @code{CONTROL} to be the set of clauses associated with the 1921@code{GIMPLE_OMP_SECTIONS} in @code{G}. 1922@end deftypefn 1923 1924@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g) 1925Return the clauses associated with @code{OMP_SECTIONS} @code{G}. 1926@end deftypefn 1927 1928@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g) 1929Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}. 1930@end deftypefn 1931 1932@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses) 1933Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS} 1934@code{G}. 1935@end deftypefn 1936 1937 1938@node @code{GIMPLE_OMP_SINGLE} 1939@subsection @code{GIMPLE_OMP_SINGLE} 1940@cindex @code{GIMPLE_OMP_SINGLE} 1941 1942@deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses) 1943Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of 1944statements that will be executed once. @code{CLAUSES} are any of the 1945@code{OMP} single construct's clauses: private, firstprivate, 1946copyprivate, nowait. 1947@end deftypefn 1948 1949@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g) 1950Return the clauses associated with @code{OMP_SINGLE} @code{G}. 1951@end deftypefn 1952 1953@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g) 1954Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}. 1955@end deftypefn 1956 1957@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses) 1958Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}. 1959@end deftypefn 1960 1961 1962@node @code{GIMPLE_PHI} 1963@subsection @code{GIMPLE_PHI} 1964@cindex @code{GIMPLE_PHI} 1965 1966@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g) 1967Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}. 1968@end deftypefn 1969 1970@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g) 1971Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always 1972be exactly the number of incoming edges for the basic block 1973holding @code{G}. 1974@end deftypefn 1975 1976@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g) 1977Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 1978@end deftypefn 1979 1980@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g) 1981Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 1982@end deftypefn 1983 1984@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result) 1985Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}. 1986@end deftypefn 1987 1988@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index) 1989Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for 1990@code{GIMPLE_PHI} @code{G}. 1991@end deftypefn 1992 1993@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg) 1994Set @code{PHIARG} to be the argument corresponding to incoming edge 1995@code{INDEX} for @code{GIMPLE_PHI} @code{G}. 1996@end deftypefn 1997 1998@node @code{GIMPLE_RESX} 1999@subsection @code{GIMPLE_RESX} 2000@cindex @code{GIMPLE_RESX} 2001 2002@deftypefn {GIMPLE function} gimple gimple_build_resx (int region) 2003Build a @code{GIMPLE_RESX} statement which is a statement. This 2004statement is a placeholder for _Unwind_Resume before we know if a 2005function call or a branch is needed. @code{REGION} is the exception 2006region from which control is flowing. 2007@end deftypefn 2008 2009@deftypefn {GIMPLE function} int gimple_resx_region (gimple g) 2010Return the region number for @code{GIMPLE_RESX} @code{G}. 2011@end deftypefn 2012 2013@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region) 2014Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}. 2015@end deftypefn 2016 2017@node @code{GIMPLE_RETURN} 2018@subsection @code{GIMPLE_RETURN} 2019@cindex @code{GIMPLE_RETURN} 2020 2021@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval) 2022Build a @code{GIMPLE_RETURN} statement whose return value is retval. 2023@end deftypefn 2024 2025@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g) 2026Return the return value for @code{GIMPLE_RETURN} @code{G}. 2027@end deftypefn 2028 2029@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval) 2030Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}. 2031@end deftypefn 2032 2033@node @code{GIMPLE_SWITCH} 2034@subsection @code{GIMPLE_SWITCH} 2035@cindex @code{GIMPLE_SWITCH} 2036 2037@deftypefn {GIMPLE function} gimple gimple_build_switch (unsigned nlabels, @ 2038tree index, tree default_label, ...) 2039Build a @code{GIMPLE_SWITCH} statement. @code{NLABELS} are the number of 2040labels excluding the default label. The default label is passed 2041in @code{DEFAULT_LABEL}. The rest of the arguments are trees 2042representing the labels. Each label is a tree of code 2043@code{CASE_LABEL_EXPR}. 2044@end deftypefn 2045 2046@deftypefn {GIMPLE function} gimple gimple_build_switch_vec (tree index, tree @ 2047default_label, @code{VEC}(tree,heap) *args) 2048This function is an alternate way of building @code{GIMPLE_SWITCH} 2049statements. @code{INDEX} and @code{DEFAULT_LABEL} are as in 2050gimple_build_switch. @code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees 2051that contain the labels. 2052@end deftypefn 2053 2054@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g) 2055Return the number of labels associated with the switch statement 2056@code{G}. 2057@end deftypefn 2058 2059@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @ 2060unsigned nlabels) 2061Set @code{NLABELS} to be the number of labels for the switch statement 2062@code{G}. 2063@end deftypefn 2064 2065@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g) 2066Return the index variable used by the switch statement @code{G}. 2067@end deftypefn 2068 2069@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index) 2070Set @code{INDEX} to be the index variable for switch statement @code{G}. 2071@end deftypefn 2072 2073@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index) 2074Return the label numbered @code{INDEX}. The default label is 0, followed 2075by any labels in a switch statement. 2076@end deftypefn 2077 2078@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @ 2079index, tree label) 2080Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default 2081label. 2082@end deftypefn 2083 2084@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g) 2085Return the default label for a switch statement. 2086@end deftypefn 2087 2088@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @ 2089tree label) 2090Set the default label for a switch statement. 2091@end deftypefn 2092 2093 2094@node @code{GIMPLE_TRY} 2095@subsection @code{GIMPLE_TRY} 2096@cindex @code{GIMPLE_TRY} 2097 2098@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, @ 2099gimple_seq cleanup, unsigned int kind) 2100Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the 2101expression to evaluate. @code{CLEANUP} is a sequence of statements to 2102run at clean-up time. @code{KIND} is the enumeration value 2103@code{GIMPLE_TRY_CATCH} if this statement denotes a try/catch construct 2104or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally 2105construct. 2106@end deftypefn 2107 2108@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g) 2109Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is 2110either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}. 2111@end deftypefn 2112 2113@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g) 2114Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag. 2115@end deftypefn 2116 2117@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g) 2118Return the sequence of statements used as the body for @code{GIMPLE_TRY} 2119@code{G}. 2120@end deftypefn 2121 2122@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g) 2123Return the sequence of statements used as the cleanup body for 2124@code{GIMPLE_TRY} @code{G}. 2125@end deftypefn 2126 2127@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @ 2128bool catch_is_cleanup) 2129Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag. 2130@end deftypefn 2131 2132@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval) 2133Set @code{EVAL} to be the sequence of statements to use as the body for 2134@code{GIMPLE_TRY} @code{G}. 2135@end deftypefn 2136 2137@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup) 2138Set @code{CLEANUP} to be the sequence of statements to use as the 2139cleanup body for @code{GIMPLE_TRY} @code{G}. 2140@end deftypefn 2141 2142@node @code{GIMPLE_WITH_CLEANUP_EXPR} 2143@subsection @code{GIMPLE_WITH_CLEANUP_EXPR} 2144@cindex @code{GIMPLE_WITH_CLEANUP_EXPR} 2145 2146@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup) 2147Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the 2148clean-up expression. 2149@end deftypefn 2150 2151@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g) 2152Return the cleanup sequence for cleanup statement @code{G}. 2153@end deftypefn 2154 2155@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup) 2156Set @code{CLEANUP} to be the cleanup sequence for @code{G}. 2157@end deftypefn 2158 2159@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g) 2160Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple. 2161@end deftypefn 2162 2163@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p) 2164Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple. 2165@end deftypefn 2166 2167 2168@node GIMPLE sequences 2169@section GIMPLE sequences 2170@cindex GIMPLE sequences 2171 2172GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s 2173used in @code{GENERIC}. They are used to chain statements together, and 2174when used in conjunction with sequence iterators, provide a 2175framework for iterating through statements. 2176 2177GIMPLE sequences are of type struct @code{gimple_sequence}, but are more 2178commonly passed by reference to functions dealing with sequences. 2179The type for a sequence pointer is @code{gimple_seq} which is the same 2180as struct @code{gimple_sequence} *. When declaring a local sequence, 2181you can define a local variable of type struct @code{gimple_sequence}. 2182When declaring a sequence allocated on the garbage collected 2183heap, use the function @code{gimple_seq_alloc} documented below. 2184 2185There are convenience functions for iterating through sequences 2186in the section entitled Sequence Iterators. 2187 2188Below is a list of functions to manipulate and query sequences. 2189 2190@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g) 2191Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is 2192not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking. 2193@end deftypefn 2194 2195@deftypefn {GIMPLE function} void gimple_seq_add_seq (gimple_seq *dest, gimple_seq src) 2196Append sequence @code{SRC} to the end of sequence *@code{DEST} if @code{SRC} is not 2197@code{NULL}. If *@code{DEST} is @code{NULL}, allocate a new sequence before 2198appending. 2199@end deftypefn 2200 2201@deftypefn {GIMPLE function} gimple_seq gimple_seq_deep_copy (gimple_seq src) 2202Perform a deep copy of sequence @code{SRC} and return the result. 2203@end deftypefn 2204 2205@deftypefn {GIMPLE function} gimple_seq gimple_seq_reverse (gimple_seq seq) 2206Reverse the order of the statements in the sequence @code{SEQ}. Return 2207@code{SEQ}. 2208@end deftypefn 2209 2210@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s) 2211Return the first statement in sequence @code{S}. 2212@end deftypefn 2213 2214@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s) 2215Return the last statement in sequence @code{S}. 2216@end deftypefn 2217 2218@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last) 2219Set the last statement in sequence @code{S} to the statement in @code{LAST}. 2220@end deftypefn 2221 2222@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first) 2223Set the first statement in sequence @code{S} to the statement in @code{FIRST}. 2224@end deftypefn 2225 2226@deftypefn {GIMPLE function} void gimple_seq_init (gimple_seq s) 2227Initialize sequence @code{S} to an empty sequence. 2228@end deftypefn 2229 2230@deftypefn {GIMPLE function} gimple_seq gimple_seq_alloc (void) 2231Allocate a new sequence in the garbage collected store and return 2232it. 2233@end deftypefn 2234 2235@deftypefn {GIMPLE function} void gimple_seq_copy (gimple_seq dest, gimple_seq src) 2236Copy the sequence @code{SRC} into the sequence @code{DEST}. 2237@end deftypefn 2238 2239@deftypefn {GIMPLE function} bool gimple_seq_empty_p (gimple_seq s) 2240Return true if the sequence @code{S} is empty. 2241@end deftypefn 2242 2243@deftypefn {GIMPLE function} gimple_seq bb_seq (basic_block bb) 2244Returns the sequence of statements in @code{BB}. 2245@end deftypefn 2246 2247@deftypefn {GIMPLE function} void set_bb_seq (basic_block bb, gimple_seq seq) 2248Sets the sequence of statements in @code{BB} to @code{SEQ}. 2249@end deftypefn 2250 2251@deftypefn {GIMPLE function} bool gimple_seq_singleton_p (gimple_seq seq) 2252Determine whether @code{SEQ} contains exactly one statement. 2253@end deftypefn 2254 2255@node Sequence iterators 2256@section Sequence iterators 2257@cindex Sequence iterators 2258 2259Sequence iterators are convenience constructs for iterating 2260through statements in a sequence. Given a sequence @code{SEQ}, here is 2261a typical use of gimple sequence iterators: 2262 2263@smallexample 2264gimple_stmt_iterator gsi; 2265 2266for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) 2267 @{ 2268 gimple g = gsi_stmt (gsi); 2269 /* Do something with gimple statement @code{G}. */ 2270 @} 2271@end smallexample 2272 2273Backward iterations are possible: 2274 2275@smallexample 2276 for (gsi = gsi_last (seq); !gsi_end_p (gsi); gsi_prev (&gsi)) 2277@end smallexample 2278 2279Forward and backward iterations on basic blocks are possible with 2280@code{gsi_start_bb} and @code{gsi_last_bb}. 2281 2282In the documentation below we sometimes refer to enum 2283@code{gsi_iterator_update}. The valid options for this enumeration are: 2284 2285@itemize @bullet 2286@item @code{GSI_NEW_STMT} 2287Only valid when a single statement is added. Move the iterator to it. 2288 2289@item @code{GSI_SAME_STMT} 2290Leave the iterator at the same statement. 2291 2292@item @code{GSI_CONTINUE_LINKING} 2293Move iterator to whatever position is suitable for linking other 2294statements in the same direction. 2295@end itemize 2296 2297Below is a list of the functions used to manipulate and use 2298statement iterators. 2299 2300@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start (gimple_seq seq) 2301Return a new iterator pointing to the sequence @code{SEQ}'s first 2302statement. If @code{SEQ} is empty, the iterator's basic block is @code{NULL}. 2303Use @code{gsi_start_bb} instead when the iterator needs to always have 2304the correct basic block set. 2305@end deftypefn 2306 2307@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_start_bb (basic_block bb) 2308Return a new iterator pointing to the first statement in basic 2309block @code{BB}. 2310@end deftypefn 2311 2312@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last (gimple_seq seq) 2313Return a new iterator initially pointing to the last statement of 2314sequence @code{SEQ}. If @code{SEQ} is empty, the iterator's basic block is 2315@code{NULL}. Use @code{gsi_last_bb} instead when the iterator needs to always 2316have the correct basic block set. 2317@end deftypefn 2318 2319@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_last_bb (basic_block bb) 2320Return a new iterator pointing to the last statement in basic 2321block @code{BB}. 2322@end deftypefn 2323 2324@deftypefn {GIMPLE function} bool gsi_end_p (gimple_stmt_iterator i) 2325Return @code{TRUE} if at the end of @code{I}. 2326@end deftypefn 2327 2328@deftypefn {GIMPLE function} bool gsi_one_before_end_p (gimple_stmt_iterator i) 2329Return @code{TRUE} if we're one statement before the end of @code{I}. 2330@end deftypefn 2331 2332@deftypefn {GIMPLE function} void gsi_next (gimple_stmt_iterator *i) 2333Advance the iterator to the next gimple statement. 2334@end deftypefn 2335 2336@deftypefn {GIMPLE function} void gsi_prev (gimple_stmt_iterator *i) 2337Advance the iterator to the previous gimple statement. 2338@end deftypefn 2339 2340@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i) 2341Return the current stmt. 2342@end deftypefn 2343 2344@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_after_labels (basic_block bb) 2345Return a block statement iterator that points to the first 2346non-label statement in block @code{BB}. 2347@end deftypefn 2348 2349@deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i) 2350Return a pointer to the current stmt. 2351@end deftypefn 2352 2353@deftypefn {GIMPLE function} basic_block gsi_bb (gimple_stmt_iterator i) 2354Return the basic block associated with this iterator. 2355@end deftypefn 2356 2357@deftypefn {GIMPLE function} gimple_seq gsi_seq (gimple_stmt_iterator i) 2358Return the sequence associated with this iterator. 2359@end deftypefn 2360 2361@deftypefn {GIMPLE function} void gsi_remove (gimple_stmt_iterator *i, bool remove_eh_info) 2362Remove the current stmt from the sequence. The iterator is 2363updated to point to the next statement. When @code{REMOVE_EH_INFO} is 2364true we remove the statement pointed to by iterator @code{I} from the @code{EH} 2365tables. Otherwise we do not modify the @code{EH} tables. Generally, 2366@code{REMOVE_EH_INFO} should be true when the statement is going to be 2367removed from the @code{IL} and not reinserted elsewhere. 2368@end deftypefn 2369 2370@deftypefn {GIMPLE function} void gsi_link_seq_before (gimple_stmt_iterator *i, gimple_seq seq, enum gsi_iterator_update mode) 2371Links the sequence of statements @code{SEQ} before the statement pointed 2372by iterator @code{I}. @code{MODE} indicates what to do with the iterator 2373after insertion (see @code{enum gsi_iterator_update} above). 2374@end deftypefn 2375 2376@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode) 2377Links statement @code{G} before the statement pointed-to by iterator @code{I}. 2378Updates iterator @code{I} according to @code{MODE}. 2379@end deftypefn 2380 2381@deftypefn {GIMPLE function} void gsi_link_seq_after (gimple_stmt_iterator *i, @ 2382gimple_seq seq, enum gsi_iterator_update mode) 2383Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}. 2384@code{MODE} is as in @code{gsi_insert_after}. 2385@end deftypefn 2386 2387@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @ 2388gimple g, enum gsi_iterator_update mode) 2389Links statement @code{G} after the statement pointed-to by iterator @code{I}. 2390@code{MODE} is as in @code{gsi_insert_after}. 2391@end deftypefn 2392 2393@deftypefn {GIMPLE function} gimple_seq gsi_split_seq_after (gimple_stmt_iterator i) 2394Move all statements in the sequence after @code{I} to a new sequence. 2395Return this new sequence. 2396@end deftypefn 2397 2398@deftypefn {GIMPLE function} gimple_seq gsi_split_seq_before (gimple_stmt_iterator *i) 2399Move all statements in the sequence before @code{I} to a new sequence. 2400Return this new sequence. 2401@end deftypefn 2402 2403@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @ 2404gimple stmt, bool update_eh_info) 2405Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO} 2406is true, the exception handling information of the original 2407statement is moved to the new statement. 2408@end deftypefn 2409 2410@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @ 2411gimple stmt, enum gsi_iterator_update mode) 2412Insert statement @code{STMT} before the statement pointed-to by iterator 2413@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE} 2414specifies how to update iterator @code{I} after insertion (see enum 2415@code{gsi_iterator_update}). 2416@end deftypefn 2417 2418@deftypefn {GIMPLE function} void gsi_insert_seq_before (gimple_stmt_iterator *i, @ 2419gimple_seq seq, enum gsi_iterator_update mode) 2420Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}. 2421@end deftypefn 2422 2423@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @ 2424gimple stmt, enum gsi_iterator_update mode) 2425Insert statement @code{STMT} after the statement pointed-to by iterator 2426@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE} 2427specifies how to update iterator @code{I} after insertion (see enum 2428@code{gsi_iterator_update}). 2429@end deftypefn 2430 2431@deftypefn {GIMPLE function} void gsi_insert_seq_after (gimple_stmt_iterator *i, @ 2432gimple_seq seq, enum gsi_iterator_update mode) 2433Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}. 2434@end deftypefn 2435 2436@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt) 2437Finds iterator for @code{STMT}. 2438@end deftypefn 2439 2440@deftypefn {GIMPLE function} void gsi_move_after (gimple_stmt_iterator *from, @ 2441gimple_stmt_iterator *to) 2442Move the statement at @code{FROM} so it comes right after the statement 2443at @code{TO}. 2444@end deftypefn 2445 2446@deftypefn {GIMPLE function} void gsi_move_before (gimple_stmt_iterator *from, @ 2447gimple_stmt_iterator *to) 2448Move the statement at @code{FROM} so it comes right before the statement 2449at @code{TO}. 2450@end deftypefn 2451 2452@deftypefn {GIMPLE function} void gsi_move_to_bb_end (gimple_stmt_iterator *from, @ 2453basic_block bb) 2454Move the statement at @code{FROM} to the end of basic block @code{BB}. 2455@end deftypefn 2456 2457@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt) 2458Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is 2459made until a call to @code{gsi_commit_edge_inserts}() is made. 2460@end deftypefn 2461 2462@deftypefn {GIMPLE function} void gsi_insert_seq_on_edge (edge e, gimple_seq seq) 2463Add the sequence of statements in @code{SEQ} to the pending list of edge 2464@code{E}. No actual insertion is made until a call to 2465@code{gsi_commit_edge_inserts}() is made. 2466@end deftypefn 2467 2468@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt) 2469Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new 2470block has to be created, it is returned. 2471@end deftypefn 2472 2473@deftypefn {GIMPLE function} void gsi_commit_one_edge_insert (edge e, basic_block *new_bb) 2474Commit insertions pending at edge @code{E}. If a new block is created, 2475set @code{NEW_BB} to this block, otherwise set it to @code{NULL}. 2476@end deftypefn 2477 2478@deftypefn {GIMPLE function} void gsi_commit_edge_inserts (void) 2479This routine will commit all pending edge insertions, creating 2480any new basic blocks which are necessary. 2481@end deftypefn 2482 2483 2484@node Adding a new GIMPLE statement code 2485@section Adding a new GIMPLE statement code 2486@cindex Adding a new GIMPLE statement code 2487 2488The first step in adding a new GIMPLE statement code, is 2489modifying the file @code{gimple.def}, which contains all the GIMPLE 2490codes. Then you must add a corresponding structure, and an entry 2491in @code{union gimple_statement_d}, both of which are located in 2492@code{gimple.h}. This in turn, will require you to add a corresponding 2493@code{GTY} tag in @code{gsstruct.def}, and code to handle this tag in 2494@code{gss_for_code} which is located in @code{gimple.c}. 2495 2496In order for the garbage collector to know the size of the 2497structure you created in @code{gimple.h}, you need to add a case to 2498handle your new GIMPLE statement in @code{gimple_size} which is located 2499in @code{gimple.c}. 2500 2501You will probably want to create a function to build the new 2502gimple statement in @code{gimple.c}. The function should be called 2503@code{gimple_build_@var{new-tuple-name}}, and should return the new tuple 2504of type gimple. 2505 2506If your new statement requires accessors for any members or 2507operands it may have, put simple inline accessors in 2508@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a 2509corresponding prototype in @code{gimple.h}. 2510 2511 2512@node Statement and operand traversals 2513@section Statement and operand traversals 2514@cindex Statement and operand traversals 2515 2516There are two functions available for walking statements and 2517sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq}, 2518accordingly, and a third function for walking the operands in a 2519statement: @code{walk_gimple_op}. 2520 2521@deftypefn {GIMPLE function} tree walk_gimple_stmt (gimple_stmt_iterator *gsi, @ 2522 walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) 2523This function is used to walk the current statement in @code{GSI}, 2524optionally using traversal state stored in @code{WI}. If @code{WI} is @code{NULL}, no 2525state is kept during the traversal. 2526 2527The callback @code{CALLBACK_STMT} is called. If @code{CALLBACK_STMT} returns 2528true, it means that the callback function has handled all the 2529operands of the statement and it is not necessary to walk its 2530operands. 2531 2532If @code{CALLBACK_STMT} is @code{NULL} or it returns false, @code{CALLBACK_OP} is 2533called on each operand of the statement via @code{walk_gimple_op}. If 2534@code{walk_gimple_op} returns non-@code{NULL} for any operand, the remaining 2535operands are not scanned. 2536 2537The return value is that returned by the last call to 2538@code{walk_gimple_op}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is specified. 2539@end deftypefn 2540 2541 2542@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @ 2543 walk_tree_fn callback_op, struct walk_stmt_info *wi) 2544Use this function to walk the operands of statement @code{STMT}. Every 2545operand is walked via @code{walk_tree} with optional state information 2546in @code{WI}. 2547 2548@code{CALLBACK_OP} is called on each operand of @code{STMT} via @code{walk_tree}. 2549Additional parameters to @code{walk_tree} must be stored in @code{WI}. For 2550each operand @code{OP}, @code{walk_tree} is called as: 2551 2552@smallexample 2553walk_tree (&@code{OP}, @code{CALLBACK_OP}, @code{WI}, @code{PSET}) 2554@end smallexample 2555 2556If @code{CALLBACK_OP} returns non-@code{NULL} for an operand, the remaining 2557operands are not scanned. The return value is that returned by 2558the last call to @code{walk_tree}, or @code{NULL_TREE} if no @code{CALLBACK_OP} is 2559specified. 2560@end deftypefn 2561 2562 2563@deftypefn {GIMPLE function} tree walk_gimple_seq (gimple_seq seq, @ 2564 walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) 2565This function walks all the statements in the sequence @code{SEQ} 2566calling @code{walk_gimple_stmt} on each one. @code{WI} is as in 2567@code{walk_gimple_stmt}. If @code{walk_gimple_stmt} returns non-@code{NULL}, the walk 2568is stopped and the value returned. Otherwise, all the statements 2569are walked and @code{NULL_TREE} returned. 2570@end deftypefn 2571