llvm/docs/GlobalISel/GenericOpcode.rst

   1
   2 .. _gmir-opcodes:
   3
   4 Generic Opcodes
   5 ===============
   6
   7 .. contents::
   8    :local:
   9
  10 .. note::
  11
  12   This documentation does not yet fully account for vectors. Many of the
  13   scalar/integer/floating-point operations can also take vectors.
  14
  15 Constants
  16 ---------
  17
  18 G_IMPLICIT_DEF
  19 ^^^^^^^^^^^^^^
  20
  21 An undefined value.
  22
  23 .. code-block:: none
  24
  25   %0:_(s32) = G_IMPLICIT_DEF
  26
  27 G_CONSTANT
  28 ^^^^^^^^^^
  29
  30 An integer constant.
  31
  32 .. code-block:: none
  33
  34   %0:_(s32) = G_CONSTANT i32 1
  35
  36 G_FCONSTANT
  37 ^^^^^^^^^^^
  38
  39 A floating point constant.
  40
  41 .. code-block:: none
  42
  43   %0:_(s32) = G_FCONSTANT float 1.0
  44
  45 G_FRAME_INDEX
  46 ^^^^^^^^^^^^^
  47
  48 The address of an object in the stack frame.
  49
  50 .. code-block:: none
  51
  52   %1:_(p0) = G_FRAME_INDEX %stack.0.ptr0
  53
  54 G_GLOBAL_VALUE
  55 ^^^^^^^^^^^^^^
  56
  57 The address of a global value.
  58
  59 .. code-block:: none
  60
  61   %0(p0) = G_GLOBAL_VALUE @var_local
  62
  63 G_BLOCK_ADDR
  64 ^^^^^^^^^^^^
  65
  66 The address of a basic block.
  67
  68 .. code-block:: none
  69
  70   %0:_(p0) = G_BLOCK_ADDR blockaddress(@test_blockaddress, %ir-block.block)
  71
  72 Integer Extension and Truncation
  73 --------------------------------
  74
  75 G_ANYEXT
  76 ^^^^^^^^
  77
  78 Extend the underlying scalar type of an operation, leaving the high bits
  79 unspecified.
  80
  81 .. code-block:: none
  82
  83   %1:_(s32) = G_ANYEXT %0:_(s16)
  84
  85 G_SEXT
  86 ^^^^^^
  87
  88 Sign extend the underlying scalar type of an operation, copying the sign bit
  89 into the newly-created space.
  90
  91 .. code-block:: none
  92
  93   %1:_(s32) = G_SEXT %0:_(s16)
  94
  95 G_SEXT_INREG
  96 ^^^^^^^^^^^^
  97
  98 Sign extend the value from an arbitrary bit position, copying the sign bit
  99 into all bits above it. This is equivalent to a shl + ashr pair with an
 100 appropriate shift amount. $sz is an immediate (MachineOperand::isImm()
 101 returns true) to allow targets to have some bitwidths legal and others
 102 lowered. This opcode is particularly useful if the target has sign-extension
 103 instructions that are cheaper than the constituent shifts as the optimizer is
 104 able to make decisions on whether it's better to hang on to the G_SEXT_INREG
 105 or to lower it and optimize the individual shifts.
 106
 107 .. code-block:: none
 108
 109   %1:_(s32) = G_SEXT_INREG %0:_(s32), 16
 110
 111 G_ZEXT
 112 ^^^^^^
 113
 114 Zero extend the underlying scalar type of an operation, putting zero bits
 115 into the newly-created space.
 116
 117 .. code-block:: none
 118
 119   %1:_(s32) = G_ZEXT %0:_(s16)
 120
 121 G_TRUNC
 122 ^^^^^^^
 123
 124 Truncate the underlying scalar type of an operation. This is equivalent to
 125 G_EXTRACT for scalar types, but acts elementwise on vectors.
 126
 127 .. code-block:: none
 128
 129   %1:_(s16) = G_TRUNC %0:_(s32)
 130
 131 Type Conversions
 132 ----------------
 133
 134 G_INTTOPTR
 135 ^^^^^^^^^^
 136
 137 Convert an integer to a pointer.
 138
 139 .. code-block:: none
 140
 141   %1:_(p0) = G_INTTOPTR %0:_(s32)
 142
 143 G_PTRTOINT
 144 ^^^^^^^^^^
 145
 146 Convert a pointer to an integer.
 147
 148 .. code-block:: none
 149
 150   %1:_(s32) = G_PTRTOINT %0:_(p0)
 151
 152 G_BITCAST
 153 ^^^^^^^^^
 154
 155 Reinterpret a value as a new type. This is usually done without
 156 changing any bits but this is not always the case due a subtlety in the
 157 definition of the :ref:`LLVM-IR Bitcast Instruction <i_bitcast>`. It
 158 is allowed to bitcast between pointers with the same size, but
 159 different address spaces.
 160
 161 .. code-block:: none
 162
 163   %1:_(s64) = G_BITCAST %0:_(<2 x s32>)
 164
 165 G_ADDRSPACE_CAST
 166 ^^^^^^^^^^^^^^^^
 167
 168 Convert a pointer to an address space to a pointer to another address space.
 169
 170 .. code-block:: none
 171
 172   %1:_(p1) = G_ADDRSPACE_CAST %0:_(p0)
 173
 174 .. caution::
 175
 176   :ref:`i_addrspacecast` doesn't mention what happens if the cast is simply
 177   invalid (i.e. if the address spaces are disjoint).
 178
 179 Scalar Operations
 180 -----------------
 181
 182 G_EXTRACT
 183 ^^^^^^^^^
 184
 185 Extract a register of the specified size, starting from the block given by
 186 index. This will almost certainly be mapped to sub-register COPYs after
 187 register banks have been selected.
 188
 189 .. code-block:: none
 190
 191   %3:_(s32) = G_EXTRACT %2:_(s64), 32
 192
 193 G_INSERT
 194 ^^^^^^^^
 195
 196 Insert a smaller register into a larger one at the specified bit-index.
 197
 198 .. code-block:: none
 199
 200   %2:_(s64) = G_INSERT %0:(_s64), %1:_(s32), 0
 201
 202 G_MERGE_VALUES
 203 ^^^^^^^^^^^^^^
 204
 205 Concatenate multiple registers of the same size into a wider register.
 206 The input operands are always ordered from lowest bits to highest:
 207
 208 .. code-block:: none
 209
 210   %0:(s32) = G_MERGE_VALUES %bits_0_7:(s8), %bits_8_15:(s8),
 211                             %bits_16_23:(s8), %bits_24_31:(s8)
 212
 213 G_UNMERGE_VALUES
 214 ^^^^^^^^^^^^^^^^
 215
 216 Extract multiple registers of the specified size, starting from blocks given by
 217 indexes. This will almost certainly be mapped to sub-register COPYs after
 218 register banks have been selected.
 219 The output operands are always ordered from lowest bits to highest:
 220
 221 .. code-block:: none
 222
 223   %bits_0_7:(s8), %bits_8_15:(s8),
 224       %bits_16_23:(s8), %bits_24_31:(s8) = G_UNMERGE_VALUES %0:(s32)
 225
 226 G_BSWAP
 227 ^^^^^^^
 228
 229 Reverse the order of the bytes in a scalar.
 230
 231 .. code-block:: none
 232
 233   %1:_(s32) = G_BSWAP %0:_(s32)
 234
 235 G_BITREVERSE
 236 ^^^^^^^^^^^^
 237
 238 Reverse the order of the bits in a scalar.
 239
 240 .. code-block:: none
 241
 242   %1:_(s32) = G_BITREVERSE %0:_(s32)
 243
 244 G_SBFX, G_UBFX
 245 ^^^^^^^^^^^^^^
 246
 247 Extract a range of bits from a register.
 248
 249 The source operands are registers as follows:
 250
 251 - Source
 252 - The least-significant bit for the extraction
 253 - The width of the extraction
 254
 255 The least-significant bit (lsb) and width operands are in the range:
 256
 257 ::
 258
 259       0 <= lsb < lsb + width <= source bitwidth, where all values are unsigned
 260
 261 G_SBFX sign-extends the result, while G_UBFX zero-extends the result.
 262
 263 .. code-block:: none
 264
 265   ; Extract 5 bits starting at bit 1 from %x and store them in %a.
 266   ; Sign-extend the result.
 267   ;
 268   ; Example:
 269   ; %x = 0...0000[10110]1 ---> %a = 1...111111[10110]
 270   %lsb_one = G_CONSTANT i32 1
 271   %width_five = G_CONSTANT i32 5
 272   %a:_(s32) = G_SBFX %x, %lsb_one, %width_five
 273
 274   ; Extract 3 bits starting at bit 2 from %x and store them in %b. Zero-extend
 275   ; the result.
 276   ;
 277   ; Example:
 278   ; %x = 1...11111[100]11 ---> %b = 0...00000[100]
 279   %lsb_two = G_CONSTANT i32 2
 280   %width_three = G_CONSTANT i32 3
 281   %b:_(s32) = G_UBFX %x, %lsb_two, %width_three
 282
 283 Integer Operations
 284 -------------------
 285
 286 G_ADD, G_SUB, G_MUL, G_AND, G_OR, G_XOR, G_SDIV, G_UDIV, G_SREM, G_UREM
 287 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 288
 289 These each perform their respective integer arithmetic on a scalar.
 290
 291 .. code-block:: none
 292
 293   %dst:_(s32) = G_ADD %src0:_(s32), %src1:_(s32)
 294
 295 The above exmaple adds %src1 to %src0 and stores the result in %dst.
 296
 297 G_SDIVREM, G_UDIVREM
 298 ^^^^^^^^^^^^^^^^^^^^
 299
 300 Perform integer division and remainder thereby producing two results.
 301
 302 .. code-block:: none
 303
 304   %div:_(s32), %rem:_(s32) = G_SDIVREM %0:_(s32), %1:_(s32)
 305
 306 G_SADDSAT, G_UADDSAT, G_SSUBSAT, G_USUBSAT, G_SSHLSAT, G_USHLSAT
 307 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 308
 309 Signed and unsigned addition, subtraction and left shift with saturation.
 310
 311 .. code-block:: none
 312
 313   %2:_(s32) = G_SADDSAT %0:_(s32), %1:_(s32)
 314
 315 G_SHL, G_LSHR, G_ASHR
 316 ^^^^^^^^^^^^^^^^^^^^^
 317
 318 Shift the bits of a scalar left or right inserting zeros (sign-bit for G_ASHR).
 319
 320 G_ROTR, G_ROTL
 321 ^^^^^^^^^^^^^^
 322
 323 Rotate the bits right (G_ROTR) or left (G_ROTL).
 324
 325 G_ICMP
 326 ^^^^^^
 327
 328 Perform integer comparison producing non-zero (true) or zero (false). It's
 329 target specific whether a true value is 1, ~0U, or some other non-zero value.
 330
 331 G_SELECT
 332 ^^^^^^^^
 333
 334 Select between two values depending on a zero/non-zero value.
 335
 336 .. code-block:: none
 337
 338   %5:_(s32) = G_SELECT %4(s1), %6, %2
 339
 340 G_PTR_ADD
 341 ^^^^^^^^^
 342
 343 Add a scalar offset in addressible units to a pointer. Addressible units are
 344 typically bytes but this may vary between targets.
 345
 346 .. code-block:: none
 347
 348   %1:_(p0) = G_PTR_ADD %0:_(p0), %1:_(s32)
 349
 350 .. caution::
 351
 352   There are currently no in-tree targets that use this with addressable units
 353   not equal to 8 bit.
 354
 355 G_PTRMASK
 356 ^^^^^^^^^^
 357
 358 Zero out an arbitrary mask of bits of a pointer. The mask type must be
 359 an integer, and the number of vector elements must match for all
 360 operands. This corresponds to `i_intr_llvm_ptrmask`.
 361
 362 .. code-block:: none
 363
 364   %2:_(p0) = G_PTRMASK %0, %1
 365
 366 G_SMIN, G_SMAX, G_UMIN, G_UMAX
 367 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 368
 369 Take the minimum/maximum of two values.
 370
 371 .. code-block:: none
 372
 373   %5:_(s32) = G_SMIN %6, %2
 374
 375 G_ABS
 376 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 377
 378 Take the absolute value of a signed integer. The absolute value of the minimum
 379 negative value (e.g. the 8-bit value `0x80`) is defined to be itself.
 380
 381 .. code-block:: none
 382
 383   %1:_(s32) = G_ABS %0
 384
 385 G_UADDO, G_SADDO, G_USUBO, G_SSUBO, G_SMULO, G_UMULO
 386 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 387
 388 Perform the requested arithmetic and produce a carry output in addition to the
 389 normal result.
 390
 391 .. code-block:: none
 392
 393   %3:_(s32), %4:_(s1) = G_UADDO %0, %1
 394
 395 G_UADDE, G_SADDE, G_USUBE, G_SSUBE
 396 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 397
 398 Perform the requested arithmetic and consume a carry input in addition to the
 399 normal input. Also produce a carry output in addition to the normal result.
 400
 401 .. code-block:: none
 402
 403   %4:_(s32), %5:_(s1) = G_UADDE %0, %1, %3:_(s1)
 404
 405 G_UMULH, G_SMULH
 406 ^^^^^^^^^^^^^^^^
 407
 408 Multiply two numbers at twice the incoming bit width (signed) and return
 409 the high half of the result.
 410
 411 .. code-block:: none
 412
 413   %3:_(s32) = G_UMULH %0, %1
 414
 415 G_CTLZ, G_CTTZ, G_CTPOP
 416 ^^^^^^^^^^^^^^^^^^^^^^^
 417
 418 Count leading zeros, trailing zeros, or number of set bits.
 419
 420 .. code-block:: none
 421
 422   %2:_(s33) = G_CTLZ_ZERO_UNDEF %1
 423   %2:_(s33) = G_CTTZ_ZERO_UNDEF %1
 424   %2:_(s33) = G_CTPOP %1
 425
 426 G_CTLZ_ZERO_UNDEF, G_CTTZ_ZERO_UNDEF
 427 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 428
 429 Count leading zeros or trailing zeros. If the value is zero then the result is
 430 undefined.
 431
 432 .. code-block:: none
 433
 434   %2:_(s33) = G_CTLZ_ZERO_UNDEF %1
 435   %2:_(s33) = G_CTTZ_ZERO_UNDEF %1
 436
 437 Floating Point Operations
 438 -------------------------
 439
 440 G_FCMP
 441 ^^^^^^
 442
 443 Perform floating point comparison producing non-zero (true) or zero
 444 (false). It's target specific whether a true value is 1, ~0U, or some other
 445 non-zero value.
 446
 447 G_FNEG
 448 ^^^^^^
 449
 450 Floating point negation.
 451
 452 G_FPEXT
 453 ^^^^^^^
 454
 455 Convert a floating point value to a larger type.
 456
 457 G_FPTRUNC
 458 ^^^^^^^^^
 459
 460 Convert a floating point value to a narrower type.
 461
 462 G_FPTOSI, G_FPTOUI, G_SITOFP, G_UITOFP
 463 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 464
 465 Convert between integer and floating point.
 466
 467 G_FABS
 468 ^^^^^^
 469
 470 Take the absolute value of a floating point value.
 471
 472 G_FCOPYSIGN
 473 ^^^^^^^^^^^
 474
 475 Copy the value of the first operand, replacing the sign bit with that of the
 476 second operand.
 477
 478 G_FCANONICALIZE
 479 ^^^^^^^^^^^^^^^
 480
 481 See :ref:`i_intr_llvm_canonicalize`.
 482
 483 G_FMINNUM
 484 ^^^^^^^^^
 485
 486 Perform floating-point minimum on two values.
 487
 488 In the case where a single input is a NaN (either signaling or quiet),
 489 the non-NaN input is returned.
 490
 491 The return value of (FMINNUM 0.0, -0.0) could be either 0.0 or -0.0.
 492
 493 G_FMAXNUM
 494 ^^^^^^^^^
 495
 496 Perform floating-point maximum on two values.
 497
 498 In the case where a single input is a NaN (either signaling or quiet),
 499 the non-NaN input is returned.
 500
 501 The return value of (FMAXNUM 0.0, -0.0) could be either 0.0 or -0.0.
 502
 503 G_FMINNUM_IEEE
 504 ^^^^^^^^^^^^^^
 505
 506 Perform floating-point minimum on two values, following the IEEE-754 2008
 507 definition. This differs from FMINNUM in the handling of signaling NaNs. If one
 508 input is a signaling NaN, returns a quiet NaN.
 509
 510 G_FMAXNUM_IEEE
 511 ^^^^^^^^^^^^^^
 512
 513 Perform floating-point maximum on two values, following the IEEE-754 2008
 514 definition. This differs from FMAXNUM in the handling of signaling NaNs. If one
 515 input is a signaling NaN, returns a quiet NaN.
 516
 517 G_FMINIMUM
 518 ^^^^^^^^^^
 519
 520 NaN-propagating minimum that also treat -0.0 as less than 0.0. While
 521 FMINNUM_IEEE follow IEEE 754-2008 semantics, FMINIMUM follows IEEE 754-2018
 522 draft semantics.
 523
 524 G_FMAXIMUM
 525 ^^^^^^^^^^
 526
 527 NaN-propagating maximum that also treat -0.0 as less than 0.0. While
 528 FMAXNUM_IEEE follow IEEE 754-2008 semantics, FMAXIMUM follows IEEE 754-2018
 529 draft semantics.
 530
 531 G_FADD, G_FSUB, G_FMUL, G_FDIV, G_FREM
 532 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 533
 534 Perform the specified floating point arithmetic.
 535
 536 G_FMA
 537 ^^^^^
 538
 539 Perform a fused multiply add (i.e. without the intermediate rounding step).
 540
 541 G_FMAD
 542 ^^^^^^
 543
 544 Perform a non-fused multiply add (i.e. with the intermediate rounding step).
 545
 546 G_FPOW
 547 ^^^^^^
 548
 549 Raise the first operand to the power of the second.
 550
 551 G_FEXP, G_FEXP2
 552 ^^^^^^^^^^^^^^^
 553
 554 Calculate the base-e or base-2 exponential of a value
 555
 556 G_FLOG, G_FLOG2, G_FLOG10
 557 ^^^^^^^^^^^^^^^^^^^^^^^^^
 558
 559 Calculate the base-e, base-2, or base-10 respectively.
 560
 561 G_FCEIL, G_FCOS, G_FSIN, G_FSQRT, G_FFLOOR, G_FRINT, G_FNEARBYINT
 562 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 563
 564 These correspond to the standard C functions of the same name.
 565
 566 G_INTRINSIC_TRUNC
 567 ^^^^^^^^^^^^^^^^^
 568
 569 Returns the operand rounded to the nearest integer not larger in magnitude than the operand.
 570
 571 G_INTRINSIC_ROUND
 572 ^^^^^^^^^^^^^^^^^
 573
 574 Returns the operand rounded to the nearest integer.
 575
 576 G_LROUND, G_LLROUND
 577 ^^^^^^^^^^^^^^^^^^^
 578
 579 Returns the source operand rounded to the nearest integer with ties away from
 580 zero.
 581
 582 See the LLVM LangRef entry on '``llvm.lround.*'`` for details on behaviour.
 583
 584 .. code-block:: none
 585
 586   %rounded_32:_(s32) = G_LROUND %round_me:_(s64)
 587   %rounded_64:_(s64) = G_LLROUND %round_me:_(s64)
 588
 589 Vector Specific Operations
 590 --------------------------
 591
 592 G_CONCAT_VECTORS
 593 ^^^^^^^^^^^^^^^^
 594
 595 Concatenate two vectors to form a longer vector.
 596
 597 G_BUILD_VECTOR, G_BUILD_VECTOR_TRUNC
 598 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 599
 600 Create a vector from multiple scalar registers. No implicit
 601 conversion is performed (i.e. the result element type must be the
 602 same as all source operands)
 603
 604 The _TRUNC version truncates the larger operand types to fit the
 605 destination vector elt type.
 606
 607 G_INSERT_VECTOR_ELT
 608 ^^^^^^^^^^^^^^^^^^^
 609
 610 Insert an element into a vector
 611
 612 G_EXTRACT_VECTOR_ELT
 613 ^^^^^^^^^^^^^^^^^^^^
 614
 615 Extract an element from a vector
 616
 617 G_SHUFFLE_VECTOR
 618 ^^^^^^^^^^^^^^^^
 619
 620 Concatenate two vectors and shuffle the elements according to the mask operand.
 621 The mask operand should be an IR Constant which exactly matches the
 622 corresponding mask for the IR shufflevector instruction.
 623
 624 Vector Reduction Operations
 625 ---------------------------
 626
 627 These operations represent horizontal vector reduction, producing a scalar result.
 628
 629 G_VECREDUCE_SEQ_FADD, G_VECREDUCE_SEQ_FMUL
 630 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 631
 632 The SEQ variants perform reductions in sequential order. The first operand is
 633 an initial scalar accumulator value, and the second operand is the vector to reduce.
 634
 635 G_VECREDUCE_FADD, G_VECREDUCE_FMUL
 636 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 637
 638 These reductions are relaxed variants which may reduce the elements in any order.
 639
 640 G_VECREDUCE_FMAX, G_VECREDUCE_FMIN
 641 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 642
 643 FMIN/FMAX nodes can have flags, for NaN/NoNaN variants.
 644
 645 G_ISNAN
 646 ^^^^^^^
 647
 648 GlobalISel-equivalent of the '``llvm.isnan``' intrinsic.
 649
 650 Returns a 1-bit scalar or vector of 1-bit scalar values. The result's contents
 651 represent whether or not the source value is NaN.
 652
 653 .. code-block:: none
 654
 655   %is_nan:_(s1) = G_ISNAN %check_me_for_nan
 656
 657 Integer/bitwise reductions
 658 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 659
 660 * G_VECREDUCE_ADD
 661 * G_VECREDUCE_MUL
 662 * G_VECREDUCE_AND
 663 * G_VECREDUCE_OR
 664 * G_VECREDUCE_XOR
 665 * G_VECREDUCE_SMAX
 666 * G_VECREDUCE_SMIN
 667 * G_VECREDUCE_UMAX
 668 * G_VECREDUCE_UMIN
 669
 670 Integer reductions may have a result type larger than the vector element type.
 671 However, the reduction is performed using the vector element type and the value
 672 in the top bits is unspecified.
 673
 674 Memory Operations
 675 -----------------
 676
 677 G_LOAD, G_SEXTLOAD, G_ZEXTLOAD
 678 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 679
 680 Generic load. Expects a MachineMemOperand in addition to explicit
 681 operands. If the result size is larger than the memory size, the
 682 high bits are undefined, sign-extended, or zero-extended respectively.
 683
 684 Only G_LOAD is valid if the result is a vector type. If the result is larger
 685 than the memory size, the high elements are undefined (i.e. this is not a
 686 per-element, vector anyextload)
 687
 688 G_INDEXED_LOAD
 689 ^^^^^^^^^^^^^^
 690
 691 Generic indexed load. Combines a GEP with a load. $newaddr is set to $base + $offset.
 692 If $am is 0 (post-indexed), then the value is loaded from $base; if $am is 1 (pre-indexed)
 693 then the value is loaded from $newaddr.
 694
 695 G_INDEXED_SEXTLOAD
 696 ^^^^^^^^^^^^^^^^^^
 697
 698 Same as G_INDEXED_LOAD except that the load performed is sign-extending, as with G_SEXTLOAD.
 699
 700 G_INDEXED_ZEXTLOAD
 701 ^^^^^^^^^^^^^^^^^^
 702
 703 Same as G_INDEXED_LOAD except that the load performed is zero-extending, as with G_ZEXTLOAD.
 704
 705 G_STORE
 706 ^^^^^^^
 707
 708 Generic store. Expects a MachineMemOperand in addition to explicit
 709 operands. If the stored value size is greater than the memory size,
 710 the high bits are implicitly truncated. If this is a vector store, the
 711 high elements are discarded (i.e. this does not function as a per-lane
 712 vector, truncating store)
 713
 714 G_INDEXED_STORE
 715 ^^^^^^^^^^^^^^^
 716
 717 Combines a store with a GEP. See description of G_INDEXED_LOAD for indexing behaviour.
 718
 719 G_ATOMIC_CMPXCHG_WITH_SUCCESS
 720 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 721
 722 Generic atomic cmpxchg with internal success check. Expects a
 723 MachineMemOperand in addition to explicit operands.
 724
 725 G_ATOMIC_CMPXCHG
 726 ^^^^^^^^^^^^^^^^
 727
 728 Generic atomic cmpxchg. Expects a MachineMemOperand in addition to explicit
 729 operands.
 730
 731 G_ATOMICRMW_XCHG, G_ATOMICRMW_ADD, G_ATOMICRMW_SUB, G_ATOMICRMW_AND, G_ATOMICRMW_NAND, G_ATOMICRMW_OR, G_ATOMICRMW_XOR, G_ATOMICRMW_MAX, G_ATOMICRMW_MIN, G_ATOMICRMW_UMAX, G_ATOMICRMW_UMIN, G_ATOMICRMW_FADD, G_ATOMICRMW_FSUB
 732 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 733
 734 Generic atomicrmw. Expects a MachineMemOperand in addition to explicit
 735 operands.
 736
 737 G_FENCE
 738 ^^^^^^^
 739
 740 .. caution::
 741
 742   I couldn't find any documentation on this at the time of writing.
 743
 744 G_MEMCPY
 745 ^^^^^^^^
 746
 747 Generic memcpy. Expects two MachineMemOperands covering the store and load
 748 respectively, in addition to explicit operands.
 749
 750 G_MEMCPY_INLINE
 751 ^^^^^^^^^^^^^^^
 752
 753 Generic inlined memcpy. Like G_MEMCPY, but it is guaranteed that this version
 754 will not be lowered as a call to an external function. Currently the size
 755 operand is required to evaluate as a constant (not an immediate), though that is
 756 expected to change when llvm.memcpy.inline is taught to support dynamic sizes.
 757
 758 G_MEMMOVE
 759 ^^^^^^^^^
 760
 761 Generic memmove. Similar to G_MEMCPY, but the source and destination memory
 762 ranges are allowed to overlap.
 763
 764 G_MEMSET
 765 ^^^^^^^^
 766
 767 Generic memset. Expects a MachineMemOperand in addition to explicit operands.
 768
 769 G_BZERO
 770 ^^^^^^^
 771
 772 Generic bzero. Expects a MachineMemOperand in addition to explicit operands.
 773
 774 Control Flow
 775 ------------
 776
 777 G_PHI
 778 ^^^^^
 779
 780 Implement the φ node in the SSA graph representing the function.
 781
 782 .. code-block:: none
 783
 784   %dst(s8) = G_PHI %src1(s8), %bb.<id1>, %src2(s8), %bb.<id2>
 785
 786 G_BR
 787 ^^^^
 788
 789 Unconditional branch
 790
 791 .. code-block:: none
 792
 793   G_BR %bb.<id>
 794
 795 G_BRCOND
 796 ^^^^^^^^
 797
 798 Conditional branch
 799
 800 .. code-block:: none
 801
 802   G_BRCOND %condition, %basicblock.<id>
 803
 804 G_BRINDIRECT
 805 ^^^^^^^^^^^^
 806
 807 Indirect branch
 808
 809 .. code-block:: none
 810
 811   G_BRINDIRECT %src(p0)
 812
 813 G_BRJT
 814 ^^^^^^
 815
 816 Indirect branch to jump table entry
 817
 818 .. code-block:: none
 819
 820   G_BRJT %ptr(p0), %jti, %idx(s64)
 821
 822 G_JUMP_TABLE
 823 ^^^^^^^^^^^^
 824
 825 .. caution::
 826
 827   I found no documentation for this instruction at the time of writing.
 828
 829 G_INTRINSIC, G_INTRINSIC_W_SIDE_EFFECTS
 830 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 831
 832 Call an intrinsic
 833
 834 The _W_SIDE_EFFECTS version is considered to have unknown side-effects and
 835 as such cannot be reordered across other side-effecting instructions.
 836
 837 .. note::
 838
 839   Unlike SelectionDAG, there is no _VOID variant. Both of these are permitted
 840   to have zero, one, or multiple results.
 841
 842 Variadic Arguments
 843 ------------------
 844
 845 G_VASTART
 846 ^^^^^^^^^
 847
 848 .. caution::
 849
 850   I found no documentation for this instruction at the time of writing.
 851
 852 G_VAARG
 853 ^^^^^^^
 854
 855 .. caution::
 856
 857   I found no documentation for this instruction at the time of writing.
 858
 859 Other Operations
 860 ----------------
 861
 862 G_DYN_STACKALLOC
 863 ^^^^^^^^^^^^^^^^
 864
 865 Dynamically realigns the stack pointer to the specified size and alignment.
 866 An alignment value of `0` or `1` means no specific alignment.
 867
 868 .. code-block:: none
 869
 870   %8:_(p0) = G_DYN_STACKALLOC %7(s64), 32
 871
 872 Optimization Hints
 873 ------------------
 874
 875 These instructions do not correspond to any target instructions. They act as
 876 hints for various combines.
 877
 878 G_ASSERT_SEXT, G_ASSERT_ZEXT
 879 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 880
 881 This signifies that the contents of a register were previously extended from a
 882 smaller type.
 883
 884 The smaller type is denoted using an immediate operand. For scalars, this is the
 885 width of the entire smaller type. For vectors, this is the width of the smaller
 886 element type.
 887
 888 .. code-block:: none
 889
 890   %x_was_zexted:_(s32) = G_ASSERT_ZEXT %x(s32), 16
 891   %y_was_zexted:_(<2 x s32>) = G_ASSERT_ZEXT %y(<2 x s32>), 16
 892
 893   %z_was_sexted:_(s32) = G_ASSERT_SEXT %z(s32), 8
 894
 895 G_ASSERT_SEXT and G_ASSERT_ZEXT act like copies, albeit with some restrictions.
 896
 897 The source and destination registers must
 898
 899 - Be virtual
 900 - Belong to the same register class
 901 - Belong to the same register bank
 902
 903 It should always be safe to
 904
 905 - Look through the source register
 906 - Replace the destination register with the source register