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