SelectionDAGDumper.cpp Source File (original) (raw)

31#include "llvm/Config/llvm-config.h"

48#include

49#include

51using namespace llvm;

55 cl::desc("Display more information when dumping selection "

56 "DAG nodes."));

60 default:

62 return "<>";

64 if (G)

68 return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";

69 }

70 if (G) {

73 return Name;

76 if (Name) return Name;

77 return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";

78 }

82#ifndef NDEBUG

84#endif

85 case ISD::PREFETCH: return "Prefetch";

86 case ISD::MEMBARRIER: return "MemBarrier";

87 case ISD::ATOMIC_FENCE: return "AtomicFence";

88 case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";

89 case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";

90 case ISD::ATOMIC_SWAP: return "AtomicSwap";

91 case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";

92 case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";

93 case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";

94 case ISD::ATOMIC_LOAD_CLR: return "AtomicLoadClr";

95 case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";

96 case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";

97 case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";

98 case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";

99 case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";

100 case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";

101 case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";

102 case ISD::ATOMIC_LOAD_FADD: return "AtomicLoadFAdd";

103 case ISD::ATOMIC_LOAD_FSUB: return "AtomicLoadFSub";

104 case ISD::ATOMIC_LOAD_FMIN: return "AtomicLoadFMin";

105 case ISD::ATOMIC_LOAD_FMAX: return "AtomicLoadFMax";

106 case ISD::ATOMIC_LOAD_FMINIMUM: return "AtomicLoadFMinimum";

107 case ISD::ATOMIC_LOAD_FMAXIMUM: return "AtomicLoadFMaximum";

108 case ISD::ATOMIC_LOAD_UINC_WRAP:

109 return "AtomicLoadUIncWrap";

110 case ISD::ATOMIC_LOAD_UDEC_WRAP:

111 return "AtomicLoadUDecWrap";

112 case ISD::ATOMIC_LOAD_USUB_COND:

113 return "AtomicLoadUSubCond";

114 case ISD::ATOMIC_LOAD_USUB_SAT:

115 return "AtomicLoadUSubSat";

116 case ISD::ATOMIC_LOAD: return "AtomicLoad";

117 case ISD::ATOMIC_STORE: return "AtomicStore";

118 case ISD::PCMARKER: return "PCMarker";

119 case ISD::READCYCLECOUNTER: return "ReadCycleCounter";

120 case ISD::READSTEADYCOUNTER: return "ReadSteadyCounter";

121 case ISD::SRCVALUE: return "SrcValue";

122 case ISD::MDNODE_SDNODE: return "MDNode";

129

136 return "OpaqueConstant";

137 return "Constant";

144 case ISD::JUMP_TABLE_DEBUG_INFO:

145 return "JUMP_TABLE_DEBUG_INFO";

169 if (IID < Intrinsic::num_intrinsics)

171 if ()

172 return "Unknown intrinsic";

174 }

175

179 return "OpaqueTargetConstant";

180 return "TargetConstant";

181

191

196 case ISD::VSCALE: return "vscale";

198 case ISD::INLINEASM: return "inlineasm";

199 case ISD::INLINEASM_BR: return "inlineasm_br";

200 case ISD::EH_LABEL: return "eh_label";

201 case ISD::ANNOTATION_LABEL: return "annotation_label";

202 case ISD::HANDLENODE: return "handlenode";

203

204

205 case ISD::FABS: return "fabs";

206 case ISD::FMINNUM: return "fminnum";

208 case ISD::FMAXNUM: return "fmaxnum";

210 case ISD::FMINNUM_IEEE: return "fminnum_ieee";

211 case ISD::FMAXNUM_IEEE: return "fmaxnum_ieee";

212 case ISD::FMINIMUM: return "fminimum";

214 case ISD::FMAXIMUM: return "fmaximum";

216 case ISD::FMINIMUMNUM: return "fminimumnum";

217 case ISD::FMAXIMUMNUM: return "fmaximumnum";

218 case ISD::FNEG: return "fneg";

219 case ISD::FSQRT: return "fsqrt";

221 case ISD::FCBRT: return "fcbrt";

222 case ISD::FSIN: return "fsin";

224 case ISD::FCOS: return "fcos";

226 case ISD::FSINCOS: return "fsincos";

227 case ISD::FSINCOSPI: return "fsincospi";

228 case ISD::FMODF: return "fmodf";

229 case ISD::FTAN: return "ftan";

231 case ISD::FASIN: return "fasin";

233 case ISD::FACOS: return "facos";

235 case ISD::FATAN: return "fatan";

237 case ISD::FATAN2: return "fatan2";

239 case ISD::FSINH: return "fsinh";

241 case ISD::FCOSH: return "fcosh";

243 case ISD::FTANH: return "ftanh";

245 case ISD::FTRUNC: return "ftrunc";

247 case ISD::FFLOOR: return "ffloor";

249 case ISD::FCEIL: return "fceil";

251 case ISD::FRINT: return "frint";

253 case ISD::FNEARBYINT: return "fnearbyint";

255 case ISD::FROUND: return "fround";

257 case ISD::FROUNDEVEN: return "froundeven";

259 case ISD::FEXP: return "fexp";

261 case ISD::FEXP2: return "fexp2";

263 case ISD::FEXP10: return "fexp10";

264 case ISD::FLOG: return "flog";

266 case ISD::FLOG2: return "flog2";

268 case ISD::FLOG10: return "flog10";

270

271

273 case ISD::PTRADD: return "ptradd";

293 case ISD::OR: return "or";

320 case ISD::FPOW: return "fpow";

328

329 case ISD::FLDEXP: return "fldexp";

331 case ISD::FFREXP: return "ffrexp";

332 case ISD::FPOWI: return "fpowi";

374

381

386

391

392

406 case ISD::FP_EXTEND: return "fp_extend";

408

419 case ISD::BITCAST: return "bitcast";

420 case ISD::ADDRSPACECAST: return "addrspacecast";

421 case ISD::FP16_TO_FP: return "fp16_to_fp";

422 case ISD::STRICT_FP16_TO_FP: return "strict_fp16_to_fp";

423 case ISD::FP_TO_FP16: return "fp_to_fp16";

424 case ISD::STRICT_FP_TO_FP16: return "strict_fp_to_fp16";

425 case ISD::BF16_TO_FP: return "bf16_to_fp";

426 case ISD::STRICT_BF16_TO_FP: return "strict_bf16_to_fp";

427 case ISD::FP_TO_BF16: return "fp_to_bf16";

428 case ISD::STRICT_FP_TO_BF16: return "strict_fp_to_bf16";

429 case ISD::LROUND: return "lround";

431 case ISD::LLROUND: return "llround";

433 case ISD::LRINT: return "lrint";

435 case ISD::LLRINT: return "llrint";

437

438

439 case ISD::BR: return "br";

440 case ISD::BRIND: return "brind";

441 case ISD::BR_JT: return "br_jt";

442 case ISD::BRCOND: return "brcond";

443 case ISD::BR_CC: return "br_cc";

444 case ISD::CALLSEQ_START: return "callseq_start";

445 case ISD::CALLSEQ_END: return "callseq_end";

446

447

448 case ISD::CATCHRET: return "catchret";

449 case ISD::CLEANUPRET: return "cleanupret";

450

451

452 case ISD::LOAD: return "load";

453 case ISD::STORE: return "store";

454 case ISD::MLOAD: return "masked_load";

455 case ISD::MSTORE: return "masked_store";

456 case ISD::MGATHER: return "masked_gather";

457 case ISD::MSCATTER: return "masked_scatter";

459 case ISD::VAARG: return "vaarg";

460 case ISD::VACOPY: return "vacopy";

461 case ISD::VAEND: return "vaend";

462 case ISD::VASTART: return "vastart";

463 case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";

466 case ISD::STACKSAVE: return "stacksave";

467 case ISD::STACKRESTORE: return "stackrestore";

468 case ISD::TRAP: return "trap";

469 case ISD::DEBUGTRAP: return "debugtrap";

470 case ISD::UBSANTRAP: return "ubsantrap";

471 case ISD::LIFETIME_START: return "lifetime.start";

472 case ISD::LIFETIME_END: return "lifetime.end";

473 case ISD::FAKE_USE:

474 return "fake_use";

475 case ISD::RELOC_NONE:

476 return "reloc_none";

477 case ISD::PSEUDO_PROBE:

478 return "pseudoprobe";

479 case ISD::GC_TRANSITION_START: return "gc_transition.start";

480 case ISD::GC_TRANSITION_END: return "gc_transition.end";

481 case ISD::GET_DYNAMIC_AREA_OFFSET: return "get.dynamic.area.offset";

483 case ISD::PREALLOCATED_SETUP:

484 return "call_setup";

485 case ISD::PREALLOCATED_ARG:

486 return "call_alloc";

487

488

490 case ISD::SET_ROUNDING: return "set_rounding";

491 case ISD::GET_FPENV: return "get_fpenv";

492 case ISD::SET_FPENV: return "set_fpenv";

493 case ISD::RESET_FPENV: return "reset_fpenv";

494 case ISD::GET_FPENV_MEM: return "get_fpenv_mem";

495 case ISD::SET_FPENV_MEM: return "set_fpenv_mem";

496 case ISD::GET_FPMODE: return "get_fpmode";

497 case ISD::SET_FPMODE: return "set_fpmode";

498 case ISD::RESET_FPMODE: return "reset_fpmode";

499

500

501 case ISD::CONVERGENCECTRL_ANCHOR: return "convergencectrl_anchor";

502 case ISD::CONVERGENCECTRL_ENTRY: return "convergencectrl_entry";

503 case ISD::CONVERGENCECTRL_LOOP: return "convergencectrl_loop";

504 case ISD::CONVERGENCECTRL_GLUE: return "convergencectrl_glue";

505

506

516

517

518 case ISD::INIT_TRAMPOLINE: return "init_trampoline";

519 case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";

520

521

522

532

541

548

553 }

554 case ISD::VECREDUCE_FADD: return "vecreduce_fadd";

555 case ISD::VECREDUCE_SEQ_FADD: return "vecreduce_seq_fadd";

556 case ISD::VECREDUCE_FMUL: return "vecreduce_fmul";

557 case ISD::VECREDUCE_SEQ_FMUL: return "vecreduce_seq_fmul";

558 case ISD::VECREDUCE_ADD: return "vecreduce_add";

559 case ISD::VECREDUCE_MUL: return "vecreduce_mul";

560 case ISD::VECREDUCE_AND: return "vecreduce_and";

561 case ISD::VECREDUCE_OR: return "vecreduce_or";

562 case ISD::VECREDUCE_XOR: return "vecreduce_xor";

563 case ISD::VECREDUCE_SMAX: return "vecreduce_smax";

564 case ISD::VECREDUCE_SMIN: return "vecreduce_smin";

565 case ISD::VECREDUCE_UMAX: return "vecreduce_umax";

566 case ISD::VECREDUCE_UMIN: return "vecreduce_umin";

567 case ISD::VECREDUCE_FMAX: return "vecreduce_fmax";

568 case ISD::VECREDUCE_FMIN: return "vecreduce_fmin";

569 case ISD::VECREDUCE_FMAXIMUM: return "vecreduce_fmaximum";

570 case ISD::VECREDUCE_FMINIMUM: return "vecreduce_fminimum";

571 case ISD::STACKMAP:

572 return "stackmap";

573 case ISD::PATCHPOINT:

574 return "patchpoint";

576 return "clear_cache";

577

578 case ISD::EXPERIMENTAL_VECTOR_HISTOGRAM:

579 return "histogram";

580

581 case ISD::VECTOR_FIND_LAST_ACTIVE:

582 return "find_last_active";

583

584 case ISD::GET_ACTIVE_LANE_MASK:

585 return "get_active_lane_mask";

586

587 case ISD::PARTIAL_REDUCE_UMLA:

588 return "partial_reduce_umla";

589 case ISD::PARTIAL_REDUCE_SMLA:

590 return "partial_reduce_smla";

591 case ISD::PARTIAL_REDUCE_SUMLA:

592 return "partial_reduce_sumla";

593 case ISD::PARTIAL_REDUCE_FMLA:

594 return "partial_reduce_fmla";

596 return "loop_dep_war";

598 return "loop_dep_raw";

599

600

601#define BEGIN_REGISTER_VP_SDNODE(SDID, LEGALARG, NAME, ...) \

602 case ISD::SDID: \

603 return #NAME;

604#include "llvm/IR/VPIntrinsics.def"

605 }

606}

607

609 switch (AM) {

610 default: return "";

615 }

616}

617

620#ifndef NDEBUG

625 };

626 OS.changeColor(Color[Node.PersistentId % std::size(Color)]);

627 OS << 't' << Node.PersistentId;

629#else

630 OS << (const void*)&Node;

631#endif

632 });

633}

634

635

641 if (MF)

644 MMO.print(OS, MST, SSNs, Ctx, MFI, TII);

645}

646

649 if (G) {

653 G->getSubtarget().getInstrInfo(), *G->getContext());

654 }

655

657 return printMemOperand(OS, MMO, nullptr, nullptr,

658 nullptr, nullptr, Ctx);

659}

660

661#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

663

668#endif

669

671 for (unsigned i = 0, e = getNumValues(); i != e; ++i) {

672 if (i) OS << ",";

674 OS << "ch";

675 else

677 }

678}

679

682 OS << " nuw";

683

685 OS << " nsw";

686

688 OS << " exact";

689

690 if (getFlags().hasDisjoint())

691 OS << " disjoint";

692

693 if (getFlags().hasSameSign())

694 OS << " samesign";

695

696 if (getFlags().hasInBounds())

697 OS << " inbounds";

698

700 OS << " nneg";

701

703 OS << " nnan";

704

706 OS << " ninf";

707

708 if (getFlags().hasNoSignedZeros())

709 OS << " nsz";

710

711 if (getFlags().hasAllowReciprocal())

712 OS << " arcp";

713

714 if (getFlags().hasAllowContract())

715 OS << " contract";

716

717 if (getFlags().hasApproximateFuncs())

718 OS << " afn";

719

720 if (getFlags().hasAllowReassociation())

721 OS << " reassoc";

722

723 if (getFlags().hasNoFPExcept())

724 OS << " nofpexcept";

725

727 if (!MN->memoperands_empty()) {

728 OS << "<";

729 OS << "Mem:";

731 e = MN->memoperands_end(); i != e; ++i) {

733 if (std::next(i) != e)

734 OS << " ";

735 }

736 OS << ">";

737 }

740 OS << "<";

741 for (unsigned i = 0, e = ValueList[0].getVectorNumElements(); i != e; ++i) {

742 int Idx = SVN->getMaskElt(i);

743 if (i) OS << ",";

744 if (Idx < 0)

745 OS << "u";

746 else

747 OS << Idx;

748 }

749 OS << ">";

751 OS << '<' << CSDN->getAPIntValue() << '>';

754 OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';

756 OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';

757 else {

758 OS << "<APFloat(";

759 CSDN->getValueAPF().bitcastToAPInt().print(OS, false);

760 OS << ")>";

761 }

764 int64_t offset = GADN->getOffset();

765 OS << '<';

766 GADN->getGlobal()->printAsOperand(OS);

767 OS << '>';

768 if (offset > 0)

769 OS << " + " << offset;

770 else

771 OS << " " << offset;

772 if (unsigned int TF = GADN->getTargetFlags())

773 OS << " [TF=" << TF << ']';

775 OS << "<" << FIDN->getIndex() << ">";

777 OS << "<" << JTDN->getIndex() << ">";

778 if (unsigned int TF = JTDN->getTargetFlags())

779 OS << " [TF=" << TF << ']';

781 int offset = CP->getOffset();

782 if (CP->isMachineConstantPoolEntry())

783 OS << "<" << *CP->getMachineCPVal() << ">";

784 else

785 OS << "<" << *CP->getConstVal() << ">";

786 if (offset > 0)

787 OS << " + " << offset;

788 else

789 OS << " " << offset;

790 if (unsigned int TF = CP->getTargetFlags())

791 OS << " [TF=" << TF << ']';

793 OS << "<" << TI->getIndex() << '+' << TI->getOffset() << ">";

794 if (unsigned TF = TI->getTargetFlags())

795 OS << " [TF=" << TF << ']';

797 OS << "<";

798 const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();

799 if (LBB)

800 OS << LBB->getName() << " ";

801 OS << (const void*)BBDN->getBasicBlock() << ">";

803 OS << ' ' << printReg(R->getReg(),

804 G ? G->getSubtarget().getRegisterInfo() : nullptr);

807 OS << "'" << ES->getSymbol() << "'";

808 if (unsigned int TF = ES->getTargetFlags())

809 OS << " [TF=" << TF << ']';

811 if (M->getValue())

812 OS << "<" << M->getValue() << ">";

813 else

814 OS << "";

816 if (MD->getMD())

817 OS << "<" << MD->getMD() << ">";

818 else

819 OS << "";

821 OS << ":" << N->getVT();

822 }

824 OS << "<";

825

827

828 bool doExt = true;

829 switch (LD->getExtensionType()) {

830 default: doExt = false; break;

834 }

835 if (doExt)

836 OS << " from " << LD->getMemoryVT();

837

839 if (*AM)

840 OS << ", " << AM;

841

842 OS << ">";

844 OS << "<";

846

847 if (ST->isTruncatingStore())

848 OS << ", trunc to " << ST->getMemoryVT();

849

851 if (*AM)

852 OS << ", " << AM;

853

854 OS << ">";

856 OS << "<";

857

859

860 bool doExt = true;

861 switch (MLd->getExtensionType()) {

862 default: doExt = false; break;

866 }

867 if (doExt)

868 OS << " from " << MLd->getMemoryVT();

869

871 if (*AM)

872 OS << ", " << AM;

873

874 if (MLd->isExpandingLoad())

875 OS << ", expanding";

876

877 OS << ">";

879 OS << "<";

881

882 if (MSt->isTruncatingStore())

883 OS << ", trunc to " << MSt->getMemoryVT();

884

886 if (*AM)

887 OS << ", " << AM;

888

889 if (MSt->isCompressingStore())

890 OS << ", compressing";

891

892 OS << ">";

894 OS << "<";

896

897 bool doExt = true;

898 switch (MGather->getExtensionType()) {

899 default: doExt = false; break;

903 }

904 if (doExt)

905 OS << " from " << MGather->getMemoryVT();

906

907 auto Signed = MGather->isIndexSigned() ? "signed" : "unsigned";

908 auto Scaled = MGather->isIndexScaled() ? "scaled" : "unscaled";

909 OS << ", " << Signed << " " << Scaled << " offset";

910

911 OS << ">";

913 OS << "<";

915

916 if (MScatter->isTruncatingStore())

917 OS << ", trunc to " << MScatter->getMemoryVT();

918

919 auto Signed = MScatter->isIndexSigned() ? "signed" : "unsigned";

920 auto Scaled = MScatter->isIndexScaled() ? "scaled" : "unscaled";

921 OS << ", " << Signed << " " << Scaled << " offset";

922

923 OS << ">";

925 OS << "<";

928 if (A->getOpcode() == ISD::ATOMIC_LOAD) {

929 bool doExt = true;

930 switch (A->getExtensionType()) {

931 default: doExt = false; break;

935 }

936 if (doExt)

937 OS << " from " << A->getMemoryVT();

938 }

939 OS << ">";

942 int64_t offset = BA->getOffset();

943 OS << "<";

944 BA->getBlockAddress()->getFunction()->printAsOperand(OS, false);

945 OS << ", ";

946 BA->getBlockAddress()->getBasicBlock()->printAsOperand(OS, false);

947 OS << ">";

948 if (offset > 0)

949 OS << " + " << offset;

950 else

951 OS << " " << offset;

952 if (unsigned int TF = BA->getTargetFlags())

953 OS << " [TF=" << TF << ']';

956 OS << '['

957 << ASC->getSrcAddressSpace()

958 << " -> "

959 << ASC->getDestAddressSpace()

960 << ']';

962 OS << '<' << AA->getAlign().value() << '>';

963 }

964

967 OS << " [ORD=" << Order << ']';

968

970 OS << " [ID=" << getNodeId() << ']';

973

974 if (G && ->GetDbgValues(this).empty()) {

975 OS << " [NoOfDbgValues=" << G->GetDbgValues(this).size() << ']';

976 for (SDDbgValue *Dbg : G->GetDbgValues(this))

977 if (!Dbg->isInvalidated())

978 Dbg->print(OS);

980 OS << " [NoOfDbgValues>0]";

981

982 if (const auto *MD = G ? G->getPCSections(this) : nullptr) {

983 OS << " [pcsections ";

984 MD->printAsOperand(OS, G->getMachineFunction().getFunction().getParent());

985 OS << ']';

986 }

987

988 if (MDNode *MMRA = G ? G->getMMRAMetadata(this) : nullptr) {

989 OS << " [mmra ";

990 MMRA->printAsOperand(OS,

991 G->getMachineFunction().getFunction().getParent());

992 OS << ']';

993 }

994 }

995}

996

998 OS << " DbgVal(Order=" << getOrder() << ')';

1000 OS << "(Invalidated)";

1002 OS << "(Emitted)";

1003 OS << "(";

1004 bool Comma = false;

1006 if (Comma)

1007 OS << ", ";

1008 switch (Op.getKind()) {

1010 if (Op.getSDNode())

1011 OS << "SDNODE=" << PrintNodeId(*Op.getSDNode()) << ':' << Op.getResNo();

1012 else

1013 OS << "SDNODE";

1014 break;

1016 OS << "CONST";

1017 break;

1019 OS << "FRAMEIX=" << Op.getFrameIx();

1020 break;

1022 OS << "VREG=" << printReg(Op.getVReg());

1023 break;

1024 }

1025 Comma = true;

1026 }

1027 OS << ")";

1028 if (isIndirect()) OS << "(Indirect)";

1030 OS << "(Variadic)";

1031 OS << ":\"" << Var->getName() << '"';

1032#ifndef NDEBUG

1033 if (Expr->getNumElements())

1034 Expr->dump();

1035#endif

1036}

1037

1038#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

1041 return;

1043 dbgs() << "\n";

1044}

1045#endif

1046

1047

1048

1050

1051

1053 return false;

1055 return false;

1056 return Node.getNumOperands() == 0;

1057}

1058

1059#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

1061 for (const SDValue &Op : N->op_values()) {

1063 continue;

1064 if (Op.getNode()->hasOneUse())

1066 }

1067

1069 N->dump(G);

1070}

1071

1073 dbgs() << "SelectionDAG has " << AllNodes.size() << " nodes:\n";

1074

1075 auto dumpEachNode = [this](const SDNode &N) {

1079 };

1080

1081 if (Sorted) {

1083 SortedNodes.reserve(AllNodes.size());

1085 for (const SDNode *N : SortedNodes)

1086 dumpEachNode(*N);

1087 } else {

1089 dumpEachNode(N);

1090 }

1091

1093 dbgs() << "\n";

1094

1097 dbgs() << "SDDbgValues:\n";

1099 Dbg->dump();

1101 dbgs() << "Byval SDDbgValues:\n";

1103 Dbg->dump();

1104 }

1105 dbgs() << "\n";

1106}

1107#endif

1108

1115

1118 if ( Value .getNode()) {

1119 OS << "";

1120 return false;

1121 }

1122

1124 OS << Value->getOperationName(G) << ':';

1125 Value->print_types(OS, G);

1126 Value->print_details(OS, G);

1127 return true;

1128 }

1129

1131 if (unsigned RN = Value.getResNo())

1132 OS << ':' << RN;

1133 return false;

1134}

1135

1136#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

1138

1141 if (!once.insert(N).second)

1142 return;

1143

1144

1146 N->printr(OS, G);

1147

1148

1149 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {

1150 if (i) OS << ",";

1151 OS << " ";

1152

1153 const SDValue Op = N->getOperand(i);

1155 if (printedInline)

1157 }

1158

1159 OS << "\n";

1160

1161

1162 for (const SDValue &Op : N->op_values())

1164}

1165

1170

1175#endif

1176

1180 if (depth == 0)

1181 return;

1182

1184

1185 N->print(OS, G);

1186

1187 for (const SDValue &Op : N->op_values()) {

1188

1189 if (Op.getValueType() == MVT::Other)

1190 continue;

1191

1193 continue;

1194 OS << '\n';

1196 }

1197}

1198

1200 unsigned depth) const {

1202}

1203

1208

1209#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

1214

1219#endif

1220

1223

1225 OS << " # D:1";

1226 for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {

1227 if (i) OS << ", "; else OS << " ";

1229 }

1231 OS << ", ";

1232 DL.print(OS);

1233 }

1234}

const TargetInstrInfo & TII

This file declares a class to represent arbitrary precision floating point values and provide a varie...

This file implements a class to represent arbitrary precision integral constant values and operations...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

This file contains the declarations for the subclasses of Constant, which represent the different fla...

static bool hasNoSignedWrap(BinaryOperator &I)

static bool hasNoUnsignedWrap(BinaryOperator &I)

This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...

static Printable PrintNodeId(const SDNode &Node)

Definition SelectionDAGDumper.cpp:618

SmallPtrSet< const SDNode *, 32 > VisitedSDNodeSet

Definition SelectionDAGDumper.cpp:1137

static cl::opt< bool > VerboseDAGDumping("dag-dump-verbose", cl::Hidden, cl::desc("Display more information when dumping selection " "DAG nodes."))

static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)

Definition SelectionDAGDumper.cpp:1116

static bool shouldPrintInline(const SDNode &Node, const SelectionDAG *G)

Return true if this node is so simple that we should just print it inline if it appears as an operand...

Definition SelectionDAGDumper.cpp:1049

static void DumpNodesr(raw_ostream &OS, const SDNode *N, unsigned indent, const SelectionDAG *G, VisitedSDNodeSet &once)

Definition SelectionDAGDumper.cpp:1139

static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO, const MachineFunction *MF, const Module *M, const MachineFrameInfo *MFI, const TargetInstrInfo *TII, LLVMContext &Ctx)

Definition SelectionDAGDumper.cpp:636

static void DumpNodes(const SDNode *N, unsigned indent, const SelectionDAG *G)

Definition SelectionDAGDumper.cpp:1060

static void printrWithDepthHelper(raw_ostream &OS, const SDNode *N, const SelectionDAG *G, unsigned depth, unsigned indent)

Definition SelectionDAGDumper.cpp:1177

This file defines the SmallPtrSet class.

This file describes how to lower LLVM code to machine code.

static const fltSemantics & IEEEsingle()

static const fltSemantics & IEEEdouble()

Module * getParent()

Get the module that this global value is contained inside of...

This is an important class for using LLVM in a threaded context.

This class is used to represent ISD::LOAD nodes.

The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.

MachineFrameInfo & getFrameInfo()

getFrameInfo - Return the frame info object for the current function.

Function & getFunction()

Return the LLVM function that this machine code represents.

A description of a memory reference used in the backend.

LLVM_ABI void print(raw_ostream &OS, ModuleSlotTracker &MST, SmallVectorImpl< StringRef > &SSNs, const LLVMContext &Context, const MachineFrameInfo *MFI, const TargetInstrInfo *TII) const

Support for operator<<.

An SDNode that represents everything that will be needed to construct a MachineInstr.

ArrayRef< MachineMemOperand * >::const_iterator mmo_iterator

This class is used to represent an MLOAD node.

This class is used to represent an MSTORE node.

This is an abstract virtual class for memory operations.

Manage lifetime of a slot tracker for printing IR.

void incorporateFunction(const Function &F)

Incorporate the given function.

A Module instance is used to store all the information related to an LLVM module.

Simple wrapper around std::function<void(raw_ostream&)>.

Holds the information for a single machine location through SDISel; either an SDNode,...

@ VREG

Value is a virtual register.

@ FRAMEIX

Value is contents of a stack location.

@ SDNODE

Value is the result of an expression.

@ CONST

Value is a constant.

Holds the information from a dbg_value node through SDISel.

LLVM_DUMP_METHOD void print(raw_ostream &OS) const

Definition SelectionDAGDumper.cpp:997

unsigned getOrder() const

Returns the SDNodeOrder.

LLVM_DUMP_METHOD void dump() const

Definition SelectionDAGDumper.cpp:1039

bool isInvalidated() const

ArrayRef< SDDbgOperand > getLocationOps() const

bool isIndirect() const

Returns whether this is an indirect value.

Represents one node in the SelectionDAG.

bool isMachineOpcode() const

Test if this node has a post-isel opcode, directly corresponding to a MachineInstr opcode.

LLVM_ABI void dumprFull(const SelectionDAG *G=nullptr) const

printrFull to dbgs().

Definition SelectionDAGDumper.cpp:1215

int getNodeId() const

Return the unique node id.

LLVM_ABI void dump() const

Dump this node, for debugging.

Definition SelectionDAGDumper.cpp:662

unsigned getOpcode() const

Return the SelectionDAG opcode value for this node.

static LLVM_ABI const char * getIndexedModeName(ISD::MemIndexedMode AM)

Definition SelectionDAGDumper.cpp:608

unsigned getIROrder() const

Return the node ordering.

bool getHasDebugValue() const

LLVM_ABI void dumpr() const

Dump (recursively) this node and its use-def subgraph.

Definition SelectionDAGDumper.cpp:1166

SDNodeFlags getFlags() const

LLVM_ABI std::string getOperationName(const SelectionDAG *G=nullptr) const

Return the opcode of this operation for printing.

Definition SelectionDAGDumper.cpp:58

LLVM_ABI void printrFull(raw_ostream &O, const SelectionDAG *G=nullptr) const

Print a SelectionDAG node and all children down to the leaves.

Definition SelectionDAGDumper.cpp:1204

friend class SelectionDAG

LLVM_ABI void printr(raw_ostream &OS, const SelectionDAG *G=nullptr) const

Definition SelectionDAGDumper.cpp:1109

uint64_t getAsZExtVal() const

Helper method returns the zero-extended integer value of a ConstantSDNode.

unsigned getNumValues() const

Return the number of values defined/returned by this operator.

unsigned getNumOperands() const

Return the number of values used by this operation.

unsigned getMachineOpcode() const

This may only be called if isMachineOpcode returns true.

const SDValue & getOperand(unsigned Num) const

LLVM_ABI void print(raw_ostream &OS, const SelectionDAG *G=nullptr) const

Definition SelectionDAGDumper.cpp:1221

const DebugLoc & getDebugLoc() const

Return the source location info.

LLVM_ABI void printrWithDepth(raw_ostream &O, const SelectionDAG *G=nullptr, unsigned depth=100) const

Print a SelectionDAG node and children up to depth "depth." The given SelectionDAG allows target-spec...

Definition SelectionDAGDumper.cpp:1199

LLVM_ABI void dumprWithDepth(const SelectionDAG *G=nullptr, unsigned depth=100) const

printrWithDepth to dbgs().

Definition SelectionDAGDumper.cpp:1211

EVT getValueType(unsigned ResNo) const

Return the type of a specified result.

LLVM_ABI void print_details(raw_ostream &OS, const SelectionDAG *G) const

Definition SelectionDAGDumper.cpp:680

LLVM_ABI void print_types(raw_ostream &OS, const SelectionDAG *G) const

Definition SelectionDAGDumper.cpp:670

Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.

Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process...

virtual const char * getTargetNodeName(unsigned Opcode) const

Returns the name of the given target-specific opcode, suitable for debug printing.

This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...

const SDValue & getRoot() const

Return the root tag of the SelectionDAG.

SDDbgInfo::DbgIterator ByvalParmDbgEnd() const

SDDbgInfo::DbgIterator ByvalParmDbgBegin() const

LLVM_ABI void dump(bool Sorted=false) const

Dump the textual format of this DAG.

Definition SelectionDAGDumper.cpp:1072

SDDbgInfo::DbgIterator DbgEnd() const

SDDbgInfo::DbgIterator DbgBegin() const

iterator_range< allnodes_iterator > allnodes()

LLVM_ABI SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDUse > Ops)

Gets or creates the specified node.

LLVM_ABI void getTopologicallyOrderedNodes(SmallVectorImpl< const SDNode * > &SortedNodes) const

Get all the nodes in their topological order without modifying any states.

This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction...

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

void reserve(size_type N)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

An SDNode that holds an arbitrary LLVM IR Value.

This class is used to represent ISD::STORE nodes.

std::string str() const

str - Get the contents as an std::string.

Completely target-dependent object reference.

TargetInstrInfo - Interface to description of machine instruction set.

This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...

virtual const char * getTargetNodeName(unsigned Opcode) const

This method returns the name of a target specific DAG node.

This class is used to represent EVT's, which are used to parameterize some operations.

LLVM Value Representation.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

This class implements an extremely fast bulk output stream that can only output to a stream.

virtual raw_ostream & changeColor(enum Colors Color, bool Bold=false, bool BG=false)

Changes the foreground color of text that will be output from this point forward.

virtual raw_ostream & resetColor()

Resets the colors to terminal defaults.

static constexpr Colors BLACK

static constexpr Colors GREEN

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

static constexpr Colors BLUE

static constexpr Colors RED

static constexpr Colors MAGENTA

static constexpr Colors YELLOW

static constexpr Colors CYAN

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Abstract Attribute helper functions.

@ SETCC

SetCC operator - This evaluates to a true value iff the condition is true.

@ MERGE_VALUES

MERGE_VALUES - This node takes multiple discrete operands and returns them all as its individual resu...

@ STRICT_FSETCC

STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used for floating-point operands only.

@ DELETED_NODE

DELETED_NODE - This is an illegal value that is used to catch errors.

@ POISON

POISON - A poison node.

@ LOOP_DEPENDENCE_RAW_MASK

@ EH_SJLJ_LONGJMP

OUTCHAIN = EH_SJLJ_LONGJMP(INCHAIN, buffer) This corresponds to the eh.sjlj.longjmp intrinsic.

@ FGETSIGN

INT = FGETSIGN(FP) - Return the sign bit of the specified floating point value as an integer 0/1 valu...

@ SMUL_LOHI

SMUL_LOHI/UMUL_LOHI - Multiply two integers of type iN, producing a signed/unsigned value of type i[2...

@ INSERT_SUBVECTOR

INSERT_SUBVECTOR(VECTOR1, VECTOR2, IDX) - Returns a vector with VECTOR2 inserted into VECTOR1.

@ BSWAP

Byte Swap and Counting operators.

@ SMULFIX

RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point multiplication on 2 integers with the same...

@ ADDC

Carry-setting nodes for multiple precision addition and subtraction.

@ FRAME_TO_ARGS_OFFSET

FRAME_TO_ARGS_OFFSET - This node represents offset from frame pointer to first (possible) on-stack ar...

@ FMAD

FMAD - Perform a * b + c, while getting the same result as the separately rounded operations.

@ ADD

Simple integer binary arithmetic operators.

@ SMULFIXSAT

Same as the corresponding unsaturated fixed point instructions, but the result is clamped between the...

@ ANY_EXTEND

ANY_EXTEND - Used for integer types. The high bits are undefined.

@ FMA

FMA - Perform a * b + c with no intermediate rounding step.

@ INTRINSIC_VOID

OUTCHAIN = INTRINSIC_VOID(INCHAIN, INTRINSICID, arg1, arg2, ...) This node represents a target intrin...

@ EH_SJLJ_SETUP_DISPATCH

OUTCHAIN = EH_SJLJ_SETUP_DISPATCH(INCHAIN) The target initializes the dispatch table here.

@ SINT_TO_FP

[SU]INT_TO_FP - These operators convert integers (whose interpreted sign depends on the first letter)...

@ CONCAT_VECTORS

CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of vector type with the same length ...

@ FADD

Simple binary floating point operators.

@ ABS

ABS - Determine the unsigned absolute value of a signed integer value of the same bitwidth.

@ SIGN_EXTEND_VECTOR_INREG

SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register sign-extension of the low ...

@ SDIVREM

SDIVREM/UDIVREM - Divide two integers and produce both a quotient and remainder result.

@ FMULADD

FMULADD - Performs a * b + c, with, or without, intermediate rounding.

@ FPTRUNC_ROUND

FPTRUNC_ROUND - This corresponds to the fptrunc_round intrinsic.

@ BUILD_PAIR

BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.

@ SDIVFIX

RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on 2 integers with the same width...

@ STRICT_FSQRT

Constrained versions of libm-equivalent floating point intrinsics.

@ BUILTIN_OP_END

BUILTIN_OP_END - This must be the last enum value in this list.

@ EH_RETURN

OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents 'eh_return' gcc dwarf builtin,...

@ SIGN_EXTEND

Conversion operators.

@ AVGCEILS

AVGCEILS/AVGCEILU - Rounding averaging add - Add two integers using an integer of type i[N+2],...

@ SCALAR_TO_VECTOR

SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a scalar value into element 0 of the...

@ ADDROFRETURNADDR

ADDROFRETURNADDR - Represents the llvm.addressofreturnaddress intrinsic.

@ CTTZ_ZERO_UNDEF

Bit counting operators with an undefined result for zero inputs.

@ TargetIndex

TargetIndex - Like a constant pool entry, but with completely target-dependent semantics.

@ SETCCCARRY

Like SetCC, ops #0 and #1 are the LHS and RHS operands to compare, but op #2 is a boolean indicating ...

@ SSUBO

Same for subtraction.

@ VECTOR_INTERLEAVE

VECTOR_INTERLEAVE(VEC1, VEC2, ...) - Returns N vectors from N input vectors, where N is the factor to...

@ STEP_VECTOR

STEP_VECTOR(IMM) - Returns a scalable vector whose lanes are comprised of a linear sequence of unsign...

@ FCANONICALIZE

Returns platform specific canonical encoding of a floating point number.

@ IS_FPCLASS

Performs a check of floating point class property, defined by IEEE-754.

@ SSUBSAT

RESULT = [US]SUBSAT(LHS, RHS) - Perform saturation subtraction on 2 integers with the same bit width ...

@ SELECT

Select(COND, TRUEVAL, FALSEVAL).

@ UNDEF

UNDEF - An undefined node.

@ EXTRACT_ELEMENT

EXTRACT_ELEMENT - This is used to get the lower or upper (determined by a Constant,...

@ SPLAT_VECTOR

SPLAT_VECTOR(VAL) - Returns a vector with the scalar value VAL duplicated in all lanes.

@ AssertAlign

AssertAlign - These nodes record if a register contains a value that has a known alignment and the tr...

@ BasicBlock

Various leaf nodes.

@ CopyFromReg

CopyFromReg - This node indicates that the input value is a virtual or physical register that is defi...

@ SADDO

RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.

@ TargetGlobalAddress

TargetGlobalAddress - Like GlobalAddress, but the DAG does no folding or anything else with this node...

@ GET_ROUNDING

Returns current rounding mode: -1 Undefined 0 Round to 0 1 Round to nearest, ties to even 2 Round to ...

@ MULHU

MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing an unsigned/signed value of...

@ SHL

Shift and rotation operations.

@ AssertNoFPClass

AssertNoFPClass - These nodes record if a register contains a float value that is known to be not som...

@ VECTOR_SHUFFLE

VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.

@ PtrAuthGlobalAddress

A ptrauth constant.

@ EXTRACT_SUBVECTOR

EXTRACT_SUBVECTOR(VECTOR, IDX) - Returns a subvector from VECTOR.

@ EntryToken

EntryToken - This is the marker used to indicate the start of a region.

@ READ_REGISTER

READ_REGISTER, WRITE_REGISTER - This node represents llvm.register on the DAG, which implements the n...

@ EXTRACT_VECTOR_ELT

EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR identified by the (potentially...

@ CopyToReg

CopyToReg - This node has three operands: a chain, a register number to set to this value,...

@ ZERO_EXTEND

ZERO_EXTEND - Used for integer types, zeroing the new bits.

@ SELECT_CC

Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...

@ LOCAL_RECOVER

LOCAL_RECOVER - Represents the llvm.localrecover intrinsic.

@ SSHLSAT

RESULT = [US]SHLSAT(LHS, RHS) - Perform saturation left shift.

@ SMULO

Same for multiplication.

@ ANY_EXTEND_VECTOR_INREG

ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register any-extension of the low la...

@ SIGN_EXTEND_INREG

SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...

@ SMIN

[US]{MIN/MAX} - Binary minimum or maximum of signed or unsigned integers.

@ VECTOR_REVERSE

VECTOR_REVERSE(VECTOR) - Returns a vector, of the same type as VECTOR, whose elements are shuffled us...

@ SDIVFIXSAT

Same as the corresponding unsaturated fixed point instructions, but the result is clamped between the...

@ GLOBAL_OFFSET_TABLE

The address of the GOT.

@ VSELECT

Select with a vector condition (op #0) and two vector operands (ops #1 and #2), returning a vector re...

@ UADDO_CARRY

Carry-using nodes for multiple precision addition and subtraction.

@ STRICT_SINT_TO_FP

STRICT_[US]INT_TO_FP - Convert a signed or unsigned integer to a floating point value.

@ EH_DWARF_CFA

EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical Frame Address (CFA),...

@ FRAMEADDR

FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and llvm.returnaddress on the DAG.

@ STRICT_FP_ROUND

X = STRICT_FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision ...

@ STRICT_FP_TO_SINT

STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.

@ FP_TO_SINT

FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.

@ TargetConstant

TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification,...

@ STRICT_FP_EXTEND

X = STRICT_FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.

@ AND

Bitwise operators - logical and, logical or, logical xor.

@ INTRINSIC_WO_CHAIN

RESULT = INTRINSIC_WO_CHAIN(INTRINSICID, arg1, arg2, ...) This node represents a target intrinsic fun...

@ SCMP

[US]CMP - 3-way comparison of signed or unsigned integers.

@ CARRY_FALSE

CARRY_FALSE - This node is used when folding other nodes, like ADDC/SUBC, which indicate the carry re...

@ AVGFLOORS

AVGFLOORS/AVGFLOORU - Averaging add - Add two integers using an integer of type i[N+1],...

@ ADDE

Carry-using nodes for multiple precision addition and subtraction.

@ STRICT_FADD

Constrained versions of the binary floating point operators.

@ SPLAT_VECTOR_PARTS

SPLAT_VECTOR_PARTS(SCALAR1, SCALAR2, ...) - Returns a vector with the scalar values joined together a...

@ FREEZE

FREEZE - FREEZE(VAL) returns an arbitrary value if VAL is UNDEF (or is evaluated to UNDEF),...

@ INSERT_VECTOR_ELT

INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element at IDX replaced with VAL.

@ TokenFactor

TokenFactor - This node takes multiple tokens as input and produces a single token result.

@ VECTOR_SPLICE

VECTOR_SPLICE(VEC1, VEC2, IMM) - Returns a subvector of the same type as VEC1/VEC2 from CONCAT_VECTOR...

@ FP_ROUND

X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision of the ...

@ VECTOR_COMPRESS

VECTOR_COMPRESS(Vec, Mask, Passthru) consecutively place vector elements based on mask e....

@ SPONENTRY

SPONENTRY - Represents the llvm.sponentry intrinsic.

@ ZERO_EXTEND_VECTOR_INREG

ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register zero-extension of the low ...

@ FP_TO_SINT_SAT

FP_TO_[US]INT_SAT - Convert floating point value in operand 0 to a signed or unsigned scalar integer ...

@ EH_SJLJ_SETJMP

RESULT, OUTCHAIN = EH_SJLJ_SETJMP(INCHAIN, buffer) This corresponds to the eh.sjlj....

@ TRUNCATE

TRUNCATE - Completely drop the high bits.

@ SHL_PARTS

SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded integer shift operations.

@ AssertSext

AssertSext, AssertZext - These nodes record if a register contains a value that has already been zero...

@ FCOPYSIGN

FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.

@ SADDSAT

RESULT = [US]ADDSAT(LHS, RHS) - Perform saturation addition on 2 integers with the same bit width (W)...

@ VECTOR_DEINTERLEAVE

VECTOR_DEINTERLEAVE(VEC1, VEC2, ...) - Returns N vectors from N input vectors, where N is the factor ...

@ TRUNCATE_SSAT_S

TRUNCATE_[SU]SAT_[SU] - Truncate for saturated operand [SU] located in middle, prefix for SAT means i...

@ ABDS

ABDS/ABDU - Absolute difference - Return the absolute difference between two numbers interpreted as s...

@ SADDO_CARRY

Carry-using overflow-aware nodes for multiple precision addition and subtraction.

@ INTRINSIC_W_CHAIN

RESULT,OUTCHAIN = INTRINSIC_W_CHAIN(INCHAIN, INTRINSICID, arg1, ...) This node represents a target in...

@ BUILD_VECTOR

BUILD_VECTOR(ELT0, ELT1, ELT2, ELT3,...) - Return a fixed-width vector with the specified,...

@ LOOP_DEPENDENCE_WAR_MASK

Set rounding mode.

MemIndexedMode

MemIndexedMode enum - This enum defines the load / store indexed addressing modes.

LLVM_ABI StringRef getBaseName(ID id)

Return the LLVM name for an intrinsic, without encoded types for overloading, such as "llvm....

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

std::string utostr(uint64_t X, bool isNeg=false)

decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

DWARFExpression::Operation Op

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

LLVM_ABI Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)

Prints virtual and physical registers with or without a TRI instance.

LLVM_ABI std::string getEVTString() const

This function returns value type as a string, e.g. "i32".