[llvm] [SelectionDAG] Table-drive fixed operation names (PR #202841)
David Zbarsky via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 19 19:54:34 PDT 2026
https://github.com/dzbarsky updated https://github.com/llvm/llvm-project/pull/202841
>From f51bca54e7bd020b847ab7aa3d4bd3db13fa814d Mon Sep 17 00:00:00 2001
From: David Zbarsky <dzbarsky at gmail.com>
Date: Tue, 9 Jun 2026 23:33:09 -0400
Subject: [PATCH] [SelectionDAG] Table-drive fixed operation names
Move fixed built-in SelectionDAG operation names from getOperationName into one generated byte blob with dense uint16_t offsets and uint8_t lengths. Keep node-dependent and target-specific cases in the switch. The constant tables contain no pointers and compile-time assertions cover the offset, length, layout, and table ranges.
SelectionDAGDumper.cpp.o shrinks by 36,544 bytes, including 13,828 bytes of __text, and has 1,281 fewer relocations. A matched Release opt link shrinks by 16,320 bytes unstripped and 16,512 bytes stripped; used __TEXT contents shrink by 11,821 bytes and dynamic fixups are unchanged.
An exhaustive unit test verifies all 424 fixed mappings. A generated 200-function AArch64 corpus produces byte-identical assembly. Fixed-name lookup including std::string construction is 53-57% faster for sequential and shuffled opcode orders.
---
.../CodeGen/SelectionDAGOperationNames.def | 437 ++++++++++++
.../SelectionDAG/SelectionDAGDumper.cpp | 655 ++++--------------
llvm/unittests/CodeGen/CMakeLists.txt | 1 +
.../CodeGen/SelectionDAGOperationNameTest.cpp | 30 +
4 files changed, 597 insertions(+), 526 deletions(-)
create mode 100644 llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def
create mode 100644 llvm/unittests/CodeGen/SelectionDAGOperationNameTest.cpp
diff --git a/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def b/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def
new file mode 100644
index 0000000000000..2d51db60a665b
--- /dev/null
+++ b/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def
@@ -0,0 +1,437 @@
+//===- SelectionDAGOperationNames.def - Built-in DAG names -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Fixed display names for built-in SelectionDAG operations. Dynamic names and
+// operations requiring node-specific handling remain in
+// SDNode::getOperationName.
+//
+//===----------------------------------------------------------------------===//
+DAG_NODE_NAME(PREFETCH, "Prefetch")
+DAG_NODE_NAME(MEMBARRIER, "MemBarrier")
+DAG_NODE_NAME(ATOMIC_FENCE, "AtomicFence")
+DAG_NODE_NAME(ATOMIC_CMP_SWAP, "AtomicCmpSwap")
+DAG_NODE_NAME(ATOMIC_CMP_SWAP_WITH_SUCCESS, "AtomicCmpSwapWithSuccess")
+DAG_NODE_NAME(ATOMIC_SWAP, "AtomicSwap")
+DAG_NODE_NAME(ATOMIC_LOAD_ADD, "AtomicLoadAdd")
+DAG_NODE_NAME(ATOMIC_LOAD_SUB, "AtomicLoadSub")
+DAG_NODE_NAME(ATOMIC_LOAD_AND, "AtomicLoadAnd")
+DAG_NODE_NAME(ATOMIC_LOAD_CLR, "AtomicLoadClr")
+DAG_NODE_NAME(ATOMIC_LOAD_OR, "AtomicLoadOr")
+DAG_NODE_NAME(ATOMIC_LOAD_XOR, "AtomicLoadXor")
+DAG_NODE_NAME(ATOMIC_LOAD_NAND, "AtomicLoadNand")
+DAG_NODE_NAME(ATOMIC_LOAD_MIN, "AtomicLoadMin")
+DAG_NODE_NAME(ATOMIC_LOAD_MAX, "AtomicLoadMax")
+DAG_NODE_NAME(ATOMIC_LOAD_UMIN, "AtomicLoadUMin")
+DAG_NODE_NAME(ATOMIC_LOAD_UMAX, "AtomicLoadUMax")
+DAG_NODE_NAME(ATOMIC_LOAD_FADD, "AtomicLoadFAdd")
+DAG_NODE_NAME(ATOMIC_LOAD_FSUB, "AtomicLoadFSub")
+DAG_NODE_NAME(ATOMIC_LOAD_FMIN, "AtomicLoadFMin")
+DAG_NODE_NAME(ATOMIC_LOAD_FMAX, "AtomicLoadFMax")
+DAG_NODE_NAME(ATOMIC_LOAD_FMINIMUM, "AtomicLoadFMinimum")
+DAG_NODE_NAME(ATOMIC_LOAD_FMAXIMUM, "AtomicLoadFMaximum")
+DAG_NODE_NAME(ATOMIC_LOAD_UINC_WRAP, "AtomicLoadUIncWrap")
+DAG_NODE_NAME(ATOMIC_LOAD_UDEC_WRAP, "AtomicLoadUDecWrap")
+DAG_NODE_NAME(ATOMIC_LOAD_USUB_COND, "AtomicLoadUSubCond")
+DAG_NODE_NAME(ATOMIC_LOAD_USUB_SAT, "AtomicLoadUSubSat")
+DAG_NODE_NAME(ATOMIC_LOAD, "AtomicLoad")
+DAG_NODE_NAME(ATOMIC_STORE, "AtomicStore")
+DAG_NODE_NAME(PCMARKER, "PCMarker")
+DAG_NODE_NAME(READCYCLECOUNTER, "ReadCycleCounter")
+DAG_NODE_NAME(READSTEADYCOUNTER, "ReadSteadyCounter")
+DAG_NODE_NAME(SRCVALUE, "SrcValue")
+DAG_NODE_NAME(MDNODE_SDNODE, "MDNode")
+DAG_NODE_NAME(EntryToken, "EntryToken")
+DAG_NODE_NAME(TokenFactor, "TokenFactor")
+DAG_NODE_NAME(AssertSext, "AssertSext")
+DAG_NODE_NAME(AssertZext, "AssertZext")
+DAG_NODE_NAME(AssertNoFPClass, "AssertNoFPClass")
+DAG_NODE_NAME(AssertAlign, "AssertAlign")
+DAG_NODE_NAME(BasicBlock, "BasicBlock")
+DAG_NODE_NAME(VALUETYPE, "ValueType")
+DAG_NODE_NAME(Register, "Register")
+DAG_NODE_NAME(RegisterMask, "RegisterMask")
+DAG_NODE_NAME(ConstantFP, "ConstantFP")
+DAG_NODE_NAME(GlobalAddress, "GlobalAddress")
+DAG_NODE_NAME(GlobalTLSAddress, "GlobalTLSAddress")
+DAG_NODE_NAME(PtrAuthGlobalAddress, "PtrAuthGlobalAddress")
+DAG_NODE_NAME(FrameIndex, "FrameIndex")
+DAG_NODE_NAME(JumpTable, "JumpTable")
+DAG_NODE_NAME(JUMP_TABLE_DEBUG_INFO, "JUMP_TABLE_DEBUG_INFO")
+DAG_NODE_NAME(GLOBAL_OFFSET_TABLE, "GLOBAL_OFFSET_TABLE")
+DAG_NODE_NAME(RETURNADDR, "RETURNADDR")
+DAG_NODE_NAME(ADDROFRETURNADDR, "ADDROFRETURNADDR")
+DAG_NODE_NAME(FRAMEADDR, "FRAMEADDR")
+DAG_NODE_NAME(SPONENTRY, "SPONENTRY")
+DAG_NODE_NAME(STACKADDRESS, "STACKADDRESS")
+DAG_NODE_NAME(LOCAL_RECOVER, "LOCAL_RECOVER")
+DAG_NODE_NAME(READ_REGISTER, "READ_REGISTER")
+DAG_NODE_NAME(WRITE_REGISTER, "WRITE_REGISTER")
+DAG_NODE_NAME(FRAME_TO_ARGS_OFFSET, "FRAME_TO_ARGS_OFFSET")
+DAG_NODE_NAME(EH_DWARF_CFA, "EH_DWARF_CFA")
+DAG_NODE_NAME(EH_RETURN, "EH_RETURN")
+DAG_NODE_NAME(EH_SJLJ_SETJMP, "EH_SJLJ_SETJMP")
+DAG_NODE_NAME(EH_SJLJ_LONGJMP, "EH_SJLJ_LONGJMP")
+DAG_NODE_NAME(EH_SJLJ_SETUP_DISPATCH, "EH_SJLJ_SETUP_DISPATCH")
+DAG_NODE_NAME(ConstantPool, "ConstantPool")
+DAG_NODE_NAME(TargetIndex, "TargetIndex")
+DAG_NODE_NAME(ExternalSymbol, "ExternalSymbol")
+DAG_NODE_NAME(BlockAddress, "BlockAddress")
+DAG_NODE_NAME(BUILD_VECTOR, "BUILD_VECTOR")
+DAG_NODE_NAME(TargetConstantFP, "TargetConstantFP")
+DAG_NODE_NAME(TargetGlobalAddress, "TargetGlobalAddress")
+DAG_NODE_NAME(TargetGlobalTLSAddress, "TargetGlobalTLSAddress")
+DAG_NODE_NAME(TargetFrameIndex, "TargetFrameIndex")
+DAG_NODE_NAME(TargetJumpTable, "TargetJumpTable")
+DAG_NODE_NAME(TargetConstantPool, "TargetConstantPool")
+DAG_NODE_NAME(TargetExternalSymbol, "TargetExternalSymbol")
+DAG_NODE_NAME(MCSymbol, "MCSymbol")
+DAG_NODE_NAME(TargetBlockAddress, "TargetBlockAddress")
+DAG_NODE_NAME(CopyToReg, "CopyToReg")
+DAG_NODE_NAME(CopyFromReg, "CopyFromReg")
+DAG_NODE_NAME(UNDEF, "undef")
+DAG_NODE_NAME(POISON, "poison")
+DAG_NODE_NAME(VSCALE, "vscale")
+DAG_NODE_NAME(MERGE_VALUES, "merge_values")
+DAG_NODE_NAME(INLINEASM, "inlineasm")
+DAG_NODE_NAME(INLINEASM_BR, "inlineasm_br")
+DAG_NODE_NAME(EH_LABEL, "eh_label")
+DAG_NODE_NAME(ANNOTATION_LABEL, "annotation_label")
+DAG_NODE_NAME(HANDLENODE, "handlenode")
+DAG_NODE_NAME(FABS, "fabs")
+DAG_NODE_NAME(FMINNUM, "fminnum")
+DAG_NODE_NAME(STRICT_FMINNUM, "strict_fminnum")
+DAG_NODE_NAME(FMAXNUM, "fmaxnum")
+DAG_NODE_NAME(STRICT_FMAXNUM, "strict_fmaxnum")
+DAG_NODE_NAME(FMINNUM_IEEE, "fminnum_ieee")
+DAG_NODE_NAME(FMAXNUM_IEEE, "fmaxnum_ieee")
+DAG_NODE_NAME(FMINIMUM, "fminimum")
+DAG_NODE_NAME(STRICT_FMINIMUM, "strict_fminimum")
+DAG_NODE_NAME(FMAXIMUM, "fmaximum")
+DAG_NODE_NAME(STRICT_FMAXIMUM, "strict_fmaximum")
+DAG_NODE_NAME(FMINIMUMNUM, "fminimumnum")
+DAG_NODE_NAME(FMAXIMUMNUM, "fmaximumnum")
+DAG_NODE_NAME(FNEG, "fneg")
+DAG_NODE_NAME(FSQRT, "fsqrt")
+DAG_NODE_NAME(STRICT_FSQRT, "strict_fsqrt")
+DAG_NODE_NAME(FCBRT, "fcbrt")
+DAG_NODE_NAME(FSIN, "fsin")
+DAG_NODE_NAME(STRICT_FSIN, "strict_fsin")
+DAG_NODE_NAME(FCOS, "fcos")
+DAG_NODE_NAME(STRICT_FCOS, "strict_fcos")
+DAG_NODE_NAME(FSINCOS, "fsincos")
+DAG_NODE_NAME(FSINCOSPI, "fsincospi")
+DAG_NODE_NAME(FMODF, "fmodf")
+DAG_NODE_NAME(FTAN, "ftan")
+DAG_NODE_NAME(STRICT_FTAN, "strict_ftan")
+DAG_NODE_NAME(FASIN, "fasin")
+DAG_NODE_NAME(STRICT_FASIN, "strict_fasin")
+DAG_NODE_NAME(FACOS, "facos")
+DAG_NODE_NAME(STRICT_FACOS, "strict_facos")
+DAG_NODE_NAME(FATAN, "fatan")
+DAG_NODE_NAME(STRICT_FATAN, "strict_fatan")
+DAG_NODE_NAME(FATAN2, "fatan2")
+DAG_NODE_NAME(STRICT_FATAN2, "strict_fatan2")
+DAG_NODE_NAME(FSINH, "fsinh")
+DAG_NODE_NAME(STRICT_FSINH, "strict_fsinh")
+DAG_NODE_NAME(FCOSH, "fcosh")
+DAG_NODE_NAME(STRICT_FCOSH, "strict_fcosh")
+DAG_NODE_NAME(FTANH, "ftanh")
+DAG_NODE_NAME(STRICT_FTANH, "strict_ftanh")
+DAG_NODE_NAME(FTRUNC, "ftrunc")
+DAG_NODE_NAME(STRICT_FTRUNC, "strict_ftrunc")
+DAG_NODE_NAME(FFLOOR, "ffloor")
+DAG_NODE_NAME(STRICT_FFLOOR, "strict_ffloor")
+DAG_NODE_NAME(FCEIL, "fceil")
+DAG_NODE_NAME(STRICT_FCEIL, "strict_fceil")
+DAG_NODE_NAME(FRINT, "frint")
+DAG_NODE_NAME(STRICT_FRINT, "strict_frint")
+DAG_NODE_NAME(FNEARBYINT, "fnearbyint")
+DAG_NODE_NAME(STRICT_FNEARBYINT, "strict_fnearbyint")
+DAG_NODE_NAME(FROUND, "fround")
+DAG_NODE_NAME(STRICT_FROUND, "strict_fround")
+DAG_NODE_NAME(FROUNDEVEN, "froundeven")
+DAG_NODE_NAME(STRICT_FROUNDEVEN, "strict_froundeven")
+DAG_NODE_NAME(FEXP, "fexp")
+DAG_NODE_NAME(STRICT_FEXP, "strict_fexp")
+DAG_NODE_NAME(FEXP2, "fexp2")
+DAG_NODE_NAME(STRICT_FEXP2, "strict_fexp2")
+DAG_NODE_NAME(FEXP10, "fexp10")
+DAG_NODE_NAME(FLOG, "flog")
+DAG_NODE_NAME(STRICT_FLOG, "strict_flog")
+DAG_NODE_NAME(FLOG2, "flog2")
+DAG_NODE_NAME(STRICT_FLOG2, "strict_flog2")
+DAG_NODE_NAME(FLOG10, "flog10")
+DAG_NODE_NAME(STRICT_FLOG10, "strict_flog10")
+DAG_NODE_NAME(ADD, "add")
+DAG_NODE_NAME(PTRADD, "ptradd")
+DAG_NODE_NAME(SUB, "sub")
+DAG_NODE_NAME(MUL, "mul")
+DAG_NODE_NAME(MULHU, "mulhu")
+DAG_NODE_NAME(MULHS, "mulhs")
+DAG_NODE_NAME(AVGFLOORU, "avgflooru")
+DAG_NODE_NAME(AVGFLOORS, "avgfloors")
+DAG_NODE_NAME(AVGCEILU, "avgceilu")
+DAG_NODE_NAME(AVGCEILS, "avgceils")
+DAG_NODE_NAME(ABDS, "abds")
+DAG_NODE_NAME(ABDU, "abdu")
+DAG_NODE_NAME(SDIV, "sdiv")
+DAG_NODE_NAME(UDIV, "udiv")
+DAG_NODE_NAME(SREM, "srem")
+DAG_NODE_NAME(UREM, "urem")
+DAG_NODE_NAME(SMUL_LOHI, "smul_lohi")
+DAG_NODE_NAME(UMUL_LOHI, "umul_lohi")
+DAG_NODE_NAME(SDIVREM, "sdivrem")
+DAG_NODE_NAME(UDIVREM, "udivrem")
+DAG_NODE_NAME(AND, "and")
+DAG_NODE_NAME(OR, "or")
+DAG_NODE_NAME(XOR, "xor")
+DAG_NODE_NAME(SHL, "shl")
+DAG_NODE_NAME(SRA, "sra")
+DAG_NODE_NAME(SRL, "srl")
+DAG_NODE_NAME(ROTL, "rotl")
+DAG_NODE_NAME(ROTR, "rotr")
+DAG_NODE_NAME(FSHL, "fshl")
+DAG_NODE_NAME(FSHR, "fshr")
+DAG_NODE_NAME(CLMUL, "clmul")
+DAG_NODE_NAME(CLMULR, "clmulr")
+DAG_NODE_NAME(CLMULH, "clmulh")
+DAG_NODE_NAME(PEXT, "pext")
+DAG_NODE_NAME(PDEP, "pdep")
+DAG_NODE_NAME(FADD, "fadd")
+DAG_NODE_NAME(STRICT_FADD, "strict_fadd")
+DAG_NODE_NAME(FSUB, "fsub")
+DAG_NODE_NAME(STRICT_FSUB, "strict_fsub")
+DAG_NODE_NAME(FMUL, "fmul")
+DAG_NODE_NAME(STRICT_FMUL, "strict_fmul")
+DAG_NODE_NAME(FDIV, "fdiv")
+DAG_NODE_NAME(STRICT_FDIV, "strict_fdiv")
+DAG_NODE_NAME(FMA, "fma")
+DAG_NODE_NAME(STRICT_FMA, "strict_fma")
+DAG_NODE_NAME(FMAD, "fmad")
+DAG_NODE_NAME(FMULADD, "fmuladd")
+DAG_NODE_NAME(FREM, "frem")
+DAG_NODE_NAME(STRICT_FREM, "strict_frem")
+DAG_NODE_NAME(FCOPYSIGN, "fcopysign")
+DAG_NODE_NAME(FGETSIGN, "fgetsign")
+DAG_NODE_NAME(FCANONICALIZE, "fcanonicalize")
+DAG_NODE_NAME(IS_FPCLASS, "is_fpclass")
+DAG_NODE_NAME(FPOW, "fpow")
+DAG_NODE_NAME(STRICT_FPOW, "strict_fpow")
+DAG_NODE_NAME(SMIN, "smin")
+DAG_NODE_NAME(SMAX, "smax")
+DAG_NODE_NAME(UMIN, "umin")
+DAG_NODE_NAME(UMAX, "umax")
+DAG_NODE_NAME(SCMP, "scmp")
+DAG_NODE_NAME(UCMP, "ucmp")
+DAG_NODE_NAME(FLDEXP, "fldexp")
+DAG_NODE_NAME(STRICT_FLDEXP, "strict_fldexp")
+DAG_NODE_NAME(FFREXP, "ffrexp")
+DAG_NODE_NAME(FPOWI, "fpowi")
+DAG_NODE_NAME(STRICT_FPOWI, "strict_fpowi")
+DAG_NODE_NAME(SETCC, "setcc")
+DAG_NODE_NAME(SETCCCARRY, "setcccarry")
+DAG_NODE_NAME(STRICT_FSETCC, "strict_fsetcc")
+DAG_NODE_NAME(STRICT_FSETCCS, "strict_fsetccs")
+DAG_NODE_NAME(FPTRUNC_ROUND, "fptrunc_round")
+DAG_NODE_NAME(SELECT, "select")
+DAG_NODE_NAME(VSELECT, "vselect")
+DAG_NODE_NAME(SELECT_CC, "select_cc")
+DAG_NODE_NAME(INSERT_VECTOR_ELT, "insert_vector_elt")
+DAG_NODE_NAME(EXTRACT_VECTOR_ELT, "extract_vector_elt")
+DAG_NODE_NAME(CONCAT_VECTORS, "concat_vectors")
+DAG_NODE_NAME(INSERT_SUBVECTOR, "insert_subvector")
+DAG_NODE_NAME(EXTRACT_SUBVECTOR, "extract_subvector")
+DAG_NODE_NAME(VECTOR_DEINTERLEAVE, "vector_deinterleave")
+DAG_NODE_NAME(VECTOR_INTERLEAVE, "vector_interleave")
+DAG_NODE_NAME(SCALAR_TO_VECTOR, "scalar_to_vector")
+DAG_NODE_NAME(VECTOR_SHUFFLE, "vector_shuffle")
+DAG_NODE_NAME(VECTOR_SPLICE_LEFT, "vector_splice_left")
+DAG_NODE_NAME(VECTOR_SPLICE_RIGHT, "vector_splice_right")
+DAG_NODE_NAME(SPLAT_VECTOR, "splat_vector")
+DAG_NODE_NAME(SPLAT_VECTOR_PARTS, "splat_vector_parts")
+DAG_NODE_NAME(VECTOR_REVERSE, "vector_reverse")
+DAG_NODE_NAME(STEP_VECTOR, "step_vector")
+DAG_NODE_NAME(CARRY_FALSE, "carry_false")
+DAG_NODE_NAME(ADDC, "addc")
+DAG_NODE_NAME(ADDE, "adde")
+DAG_NODE_NAME(UADDO_CARRY, "uaddo_carry")
+DAG_NODE_NAME(SADDO_CARRY, "saddo_carry")
+DAG_NODE_NAME(SADDO, "saddo")
+DAG_NODE_NAME(UADDO, "uaddo")
+DAG_NODE_NAME(SSUBO, "ssubo")
+DAG_NODE_NAME(USUBO, "usubo")
+DAG_NODE_NAME(SMULO, "smulo")
+DAG_NODE_NAME(UMULO, "umulo")
+DAG_NODE_NAME(SUBC, "subc")
+DAG_NODE_NAME(SUBE, "sube")
+DAG_NODE_NAME(USUBO_CARRY, "usubo_carry")
+DAG_NODE_NAME(SSUBO_CARRY, "ssubo_carry")
+DAG_NODE_NAME(SHL_PARTS, "shl_parts")
+DAG_NODE_NAME(SRA_PARTS, "sra_parts")
+DAG_NODE_NAME(SRL_PARTS, "srl_parts")
+DAG_NODE_NAME(SADDSAT, "saddsat")
+DAG_NODE_NAME(UADDSAT, "uaddsat")
+DAG_NODE_NAME(SSUBSAT, "ssubsat")
+DAG_NODE_NAME(USUBSAT, "usubsat")
+DAG_NODE_NAME(SSHLSAT, "sshlsat")
+DAG_NODE_NAME(USHLSAT, "ushlsat")
+DAG_NODE_NAME(SMULFIX, "smulfix")
+DAG_NODE_NAME(SMULFIXSAT, "smulfixsat")
+DAG_NODE_NAME(UMULFIX, "umulfix")
+DAG_NODE_NAME(UMULFIXSAT, "umulfixsat")
+DAG_NODE_NAME(SDIVFIX, "sdivfix")
+DAG_NODE_NAME(SDIVFIXSAT, "sdivfixsat")
+DAG_NODE_NAME(UDIVFIX, "udivfix")
+DAG_NODE_NAME(UDIVFIXSAT, "udivfixsat")
+DAG_NODE_NAME(SIGN_EXTEND, "sign_extend")
+DAG_NODE_NAME(ZERO_EXTEND, "zero_extend")
+DAG_NODE_NAME(ANY_EXTEND, "any_extend")
+DAG_NODE_NAME(SIGN_EXTEND_INREG, "sign_extend_inreg")
+DAG_NODE_NAME(ANY_EXTEND_VECTOR_INREG, "any_extend_vector_inreg")
+DAG_NODE_NAME(SIGN_EXTEND_VECTOR_INREG, "sign_extend_vector_inreg")
+DAG_NODE_NAME(ZERO_EXTEND_VECTOR_INREG, "zero_extend_vector_inreg")
+DAG_NODE_NAME(TRUNCATE, "truncate")
+DAG_NODE_NAME(TRUNCATE_SSAT_S, "truncate_ssat_s")
+DAG_NODE_NAME(TRUNCATE_SSAT_U, "truncate_ssat_u")
+DAG_NODE_NAME(TRUNCATE_USAT_U, "truncate_usat_u")
+DAG_NODE_NAME(FP_ROUND, "fp_round")
+DAG_NODE_NAME(STRICT_FP_ROUND, "strict_fp_round")
+DAG_NODE_NAME(FP_EXTEND, "fp_extend")
+DAG_NODE_NAME(STRICT_FP_EXTEND, "strict_fp_extend")
+DAG_NODE_NAME(SINT_TO_FP, "sint_to_fp")
+DAG_NODE_NAME(STRICT_SINT_TO_FP, "strict_sint_to_fp")
+DAG_NODE_NAME(UINT_TO_FP, "uint_to_fp")
+DAG_NODE_NAME(STRICT_UINT_TO_FP, "strict_uint_to_fp")
+DAG_NODE_NAME(FP_TO_SINT, "fp_to_sint")
+DAG_NODE_NAME(STRICT_FP_TO_SINT, "strict_fp_to_sint")
+DAG_NODE_NAME(FP_TO_UINT, "fp_to_uint")
+DAG_NODE_NAME(STRICT_FP_TO_UINT, "strict_fp_to_uint")
+DAG_NODE_NAME(FP_TO_SINT_SAT, "fp_to_sint_sat")
+DAG_NODE_NAME(FP_TO_UINT_SAT, "fp_to_uint_sat")
+DAG_NODE_NAME(BITCAST, "bitcast")
+DAG_NODE_NAME(ADDRSPACECAST, "addrspacecast")
+DAG_NODE_NAME(FP16_TO_FP, "fp16_to_fp")
+DAG_NODE_NAME(STRICT_FP16_TO_FP, "strict_fp16_to_fp")
+DAG_NODE_NAME(FP_TO_FP16, "fp_to_fp16")
+DAG_NODE_NAME(STRICT_FP_TO_FP16, "strict_fp_to_fp16")
+DAG_NODE_NAME(BF16_TO_FP, "bf16_to_fp")
+DAG_NODE_NAME(STRICT_BF16_TO_FP, "strict_bf16_to_fp")
+DAG_NODE_NAME(FP_TO_BF16, "fp_to_bf16")
+DAG_NODE_NAME(STRICT_FP_TO_BF16, "strict_fp_to_bf16")
+DAG_NODE_NAME(CONVERT_FROM_ARBITRARY_FP, "convert_from_arbitrary_fp")
+DAG_NODE_NAME(CONVERT_TO_ARBITRARY_FP, "convert_to_arbitrary_fp")
+DAG_NODE_NAME(LROUND, "lround")
+DAG_NODE_NAME(STRICT_LROUND, "strict_lround")
+DAG_NODE_NAME(LLROUND, "llround")
+DAG_NODE_NAME(STRICT_LLROUND, "strict_llround")
+DAG_NODE_NAME(LRINT, "lrint")
+DAG_NODE_NAME(STRICT_LRINT, "strict_lrint")
+DAG_NODE_NAME(LLRINT, "llrint")
+DAG_NODE_NAME(STRICT_LLRINT, "strict_llrint")
+DAG_NODE_NAME(BR, "br")
+DAG_NODE_NAME(BRIND, "brind")
+DAG_NODE_NAME(BR_JT, "br_jt")
+DAG_NODE_NAME(BRCOND, "brcond")
+DAG_NODE_NAME(BR_CC, "br_cc")
+DAG_NODE_NAME(CALLSEQ_START, "callseq_start")
+DAG_NODE_NAME(CALLSEQ_END, "callseq_end")
+DAG_NODE_NAME(CATCHRET, "catchret")
+DAG_NODE_NAME(CLEANUPRET, "cleanupret")
+DAG_NODE_NAME(LOAD, "load")
+DAG_NODE_NAME(STORE, "store")
+DAG_NODE_NAME(MLOAD, "masked_load")
+DAG_NODE_NAME(MSTORE, "masked_store")
+DAG_NODE_NAME(MGATHER, "masked_gather")
+DAG_NODE_NAME(MSCATTER, "masked_scatter")
+DAG_NODE_NAME(VECTOR_COMPRESS, "vector_compress")
+DAG_NODE_NAME(VAARG, "vaarg")
+DAG_NODE_NAME(VACOPY, "vacopy")
+DAG_NODE_NAME(VAEND, "vaend")
+DAG_NODE_NAME(VASTART, "vastart")
+DAG_NODE_NAME(DYNAMIC_STACKALLOC, "dynamic_stackalloc")
+DAG_NODE_NAME(EXTRACT_ELEMENT, "extract_element")
+DAG_NODE_NAME(BUILD_PAIR, "build_pair")
+DAG_NODE_NAME(STACKSAVE, "stacksave")
+DAG_NODE_NAME(STACKRESTORE, "stackrestore")
+DAG_NODE_NAME(TRAP, "trap")
+DAG_NODE_NAME(DEBUGTRAP, "debugtrap")
+DAG_NODE_NAME(UBSANTRAP, "ubsantrap")
+DAG_NODE_NAME(LIFETIME_START, "lifetime.start")
+DAG_NODE_NAME(LIFETIME_END, "lifetime.end")
+DAG_NODE_NAME(FAKE_USE, "fake_use")
+DAG_NODE_NAME(RELOC_NONE, "reloc_none")
+DAG_NODE_NAME(COND_LOOP, "cond_loop")
+DAG_NODE_NAME(PSEUDO_PROBE, "pseudoprobe")
+DAG_NODE_NAME(GC_TRANSITION_START, "gc_transition.start")
+DAG_NODE_NAME(GC_TRANSITION_END, "gc_transition.end")
+DAG_NODE_NAME(GET_DYNAMIC_AREA_OFFSET, "get.dynamic.area.offset")
+DAG_NODE_NAME(FREEZE, "freeze")
+DAG_NODE_NAME(PREALLOCATED_SETUP, "call_setup")
+DAG_NODE_NAME(PREALLOCATED_ARG, "call_alloc")
+DAG_NODE_NAME(GET_ROUNDING, "get_rounding")
+DAG_NODE_NAME(SET_ROUNDING, "set_rounding")
+DAG_NODE_NAME(GET_FPENV, "get_fpenv")
+DAG_NODE_NAME(SET_FPENV, "set_fpenv")
+DAG_NODE_NAME(RESET_FPENV, "reset_fpenv")
+DAG_NODE_NAME(GET_FPENV_MEM, "get_fpenv_mem")
+DAG_NODE_NAME(SET_FPENV_MEM, "set_fpenv_mem")
+DAG_NODE_NAME(GET_FPMODE, "get_fpmode")
+DAG_NODE_NAME(SET_FPMODE, "set_fpmode")
+DAG_NODE_NAME(RESET_FPMODE, "reset_fpmode")
+DAG_NODE_NAME(CONVERGENCECTRL_ANCHOR, "convergencectrl_anchor")
+DAG_NODE_NAME(CONVERGENCECTRL_ENTRY, "convergencectrl_entry")
+DAG_NODE_NAME(CONVERGENCECTRL_LOOP, "convergencectrl_loop")
+DAG_NODE_NAME(CONVERGENCECTRL_GLUE, "convergencectrl_glue")
+DAG_NODE_NAME(ABS, "abs")
+DAG_NODE_NAME(ABS_MIN_POISON, "abs_min_poison")
+DAG_NODE_NAME(BITREVERSE, "bitreverse")
+DAG_NODE_NAME(BSWAP, "bswap")
+DAG_NODE_NAME(CTPOP, "ctpop")
+DAG_NODE_NAME(CTTZ, "cttz")
+DAG_NODE_NAME(CTTZ_ZERO_POISON, "cttz_zero_poison")
+DAG_NODE_NAME(CTLZ, "ctlz")
+DAG_NODE_NAME(CTLZ_ZERO_POISON, "ctlz_zero_poison")
+DAG_NODE_NAME(CTLS, "ctls")
+DAG_NODE_NAME(PARITY, "parity")
+DAG_NODE_NAME(INIT_TRAMPOLINE, "init_trampoline")
+DAG_NODE_NAME(ADJUST_TRAMPOLINE, "adjust_trampoline")
+DAG_NODE_NAME(VECREDUCE_FADD, "vecreduce_fadd")
+DAG_NODE_NAME(VECREDUCE_SEQ_FADD, "vecreduce_seq_fadd")
+DAG_NODE_NAME(VECREDUCE_FMUL, "vecreduce_fmul")
+DAG_NODE_NAME(VECREDUCE_SEQ_FMUL, "vecreduce_seq_fmul")
+DAG_NODE_NAME(VECREDUCE_ADD, "vecreduce_add")
+DAG_NODE_NAME(VECREDUCE_MUL, "vecreduce_mul")
+DAG_NODE_NAME(VECREDUCE_AND, "vecreduce_and")
+DAG_NODE_NAME(VECREDUCE_OR, "vecreduce_or")
+DAG_NODE_NAME(VECREDUCE_XOR, "vecreduce_xor")
+DAG_NODE_NAME(VECREDUCE_SMAX, "vecreduce_smax")
+DAG_NODE_NAME(VECREDUCE_SMIN, "vecreduce_smin")
+DAG_NODE_NAME(VECREDUCE_UMAX, "vecreduce_umax")
+DAG_NODE_NAME(VECREDUCE_UMIN, "vecreduce_umin")
+DAG_NODE_NAME(VECREDUCE_FMAX, "vecreduce_fmax")
+DAG_NODE_NAME(VECREDUCE_FMIN, "vecreduce_fmin")
+DAG_NODE_NAME(VECREDUCE_FMAXIMUM, "vecreduce_fmaximum")
+DAG_NODE_NAME(VECREDUCE_FMINIMUM, "vecreduce_fminimum")
+DAG_NODE_NAME(STACKMAP, "stackmap")
+DAG_NODE_NAME(PATCHPOINT, "patchpoint")
+DAG_NODE_NAME(CLEAR_CACHE, "clear_cache")
+DAG_NODE_NAME(EXPERIMENTAL_VECTOR_HISTOGRAM, "histogram")
+DAG_NODE_NAME(CTTZ_ELTS, "cttz_elts")
+DAG_NODE_NAME(CTTZ_ELTS_ZERO_POISON, "cttz_elts_zero_poison")
+DAG_NODE_NAME(VECTOR_FIND_LAST_ACTIVE, "find_last_active")
+DAG_NODE_NAME(GET_ACTIVE_LANE_MASK, "get_active_lane_mask")
+DAG_NODE_NAME(PARTIAL_REDUCE_UMLA, "partial_reduce_umla")
+DAG_NODE_NAME(PARTIAL_REDUCE_SMLA, "partial_reduce_smla")
+DAG_NODE_NAME(PARTIAL_REDUCE_SUMLA, "partial_reduce_sumla")
+DAG_NODE_NAME(PARTIAL_REDUCE_FMLA, "partial_reduce_fmla")
+DAG_NODE_NAME(LOOP_DEPENDENCE_WAR_MASK, "loop_dep_war")
+DAG_NODE_NAME(LOOP_DEPENDENCE_RAW_MASK, "loop_dep_raw")
+DAG_NODE_NAME(MASKED_UDIV, "masked_udiv")
+DAG_NODE_NAME(MASKED_SDIV, "masked_sdiv")
+DAG_NODE_NAME(MASKED_UREM, "masked_urem")
+DAG_NODE_NAME(MASKED_SREM, "masked_srem")
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
index a00d7555f15f6..1456778e20172 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
@@ -45,8 +45,12 @@
#include "llvm/Support/Printable.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
+#include <array>
+#include <cstddef>
#include <cstdint>
#include <iterator>
+#include <limits>
+#include <type_traits>
using namespace llvm;
@@ -59,113 +63,99 @@ static cl::opt<bool>
PrintSDNodeAddrs("print-sdnode-addrs", cl::Hidden,
cl::desc("Print addresses of SDNodes when dumping"));
+namespace {
+
+// Keep the names in one byte blob so the constant table has no pointers or
+// relocations. Dense integer tables map built-in opcodes to the blob.
+struct FixedOperationNameData {
+#define DAG_NODE_NAME(OPCODE, NAME) char OPCODE[sizeof(NAME)];
+#include "llvm/CodeGen/SelectionDAGOperationNames.def"
+#undef DAG_NODE_NAME
+};
+
+constexpr FixedOperationNameData FixedOperationNames = {
+#define DAG_NODE_NAME(OPCODE, NAME) NAME,
+#include "llvm/CodeGen/SelectionDAGOperationNames.def"
+#undef DAG_NODE_NAME
+};
+
+static_assert(sizeof(FixedOperationNames) <=
+ std::numeric_limits<uint16_t>::max());
+static_assert(alignof(FixedOperationNameData) == alignof(char));
+static_assert(std::is_standard_layout_v<FixedOperationNameData>);
+
+#define DAG_NODE_NAME(OPCODE, NAME) \
+ static_assert(ISD::OPCODE < ISD::BUILTIN_OP_END); \
+ static_assert(sizeof(NAME) - 1 <= std::numeric_limits<uint8_t>::max());
+#include "llvm/CodeGen/SelectionDAGOperationNames.def"
+#undef DAG_NODE_NAME
+
+template <typename ValueType, bool StoreLengths>
+constexpr std::array<ValueType, ISD::BUILTIN_OP_END>
+makeFixedOperationNameTable() {
+ std::array<ValueType, ISD::BUILTIN_OP_END> Result{};
+#define DAG_NODE_NAME(OPCODE, NAME) \
+ Result[ISD::OPCODE] = static_cast<ValueType>( \
+ StoreLengths ? sizeof(NAME) - 1 \
+ : offsetof(FixedOperationNameData, OPCODE));
+#include "llvm/CodeGen/SelectionDAGOperationNames.def"
+#undef DAG_NODE_NAME
+ return Result;
+}
+
+constexpr auto FixedOperationNameOffsets =
+ makeFixedOperationNameTable<uint16_t, false>();
+constexpr auto FixedOperationNameLengths =
+ makeFixedOperationNameTable<uint8_t, true>();
+static_assert(sizeof(FixedOperationNameOffsets) ==
+ ISD::BUILTIN_OP_END * sizeof(uint16_t));
+static_assert(sizeof(FixedOperationNameLengths) ==
+ ISD::BUILTIN_OP_END * sizeof(uint8_t));
+
+} // namespace
+
std::string SDNode::getOperationName(const SelectionDAG *G) const {
- switch (getOpcode()) {
+ const unsigned Opcode = getOpcode();
+ if (Opcode < FixedOperationNameLengths.size()) {
+ const uint8_t Length = FixedOperationNameLengths[Opcode];
+ if (Length != 0) {
+ const char *Names = reinterpret_cast<const char *>(&FixedOperationNames);
+ return std::string(Names + FixedOperationNameOffsets[Opcode], Length);
+ }
+ }
+
+ switch (Opcode) {
default:
- if (getOpcode() < ISD::BUILTIN_OP_END)
+ if (Opcode < ISD::BUILTIN_OP_END)
return "<<Unknown DAG Node>>";
if (isMachineOpcode()) {
if (G)
if (const TargetInstrInfo *TII = G->getSubtarget().getInstrInfo())
if (getMachineOpcode() < TII->getNumOpcodes())
return std::string(TII->getName(getMachineOpcode()));
- return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";
+ return "<<Unknown Machine Node #" + utostr(Opcode) + ">>";
}
if (G) {
const SelectionDAGTargetInfo &TSI = G->getSelectionDAGInfo();
- if (const char *Name = TSI.getTargetNodeName(getOpcode()))
+ if (const char *Name = TSI.getTargetNodeName(Opcode))
return Name;
const TargetLowering &TLI = G->getTargetLoweringInfo();
- const char *Name = TLI.getTargetNodeName(getOpcode());
- if (Name) return Name;
- return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";
+ const char *Name = TLI.getTargetNodeName(Opcode);
+ if (Name)
+ return Name;
+ return "<<Unknown Target Node #" + utostr(Opcode) + ">>";
}
- return "<<Unknown Node #" + utostr(getOpcode()) + ">>";
+ return "<<Unknown Node #" + utostr(Opcode) + ">>";
- // clang-format off
#ifndef NDEBUG
- case ISD::DELETED_NODE: return "<<Deleted Node!>>";
+ case ISD::DELETED_NODE:
+ return "<<Deleted Node!>>";
#endif
- case ISD::PREFETCH: return "Prefetch";
- case ISD::MEMBARRIER: return "MemBarrier";
- case ISD::ATOMIC_FENCE: return "AtomicFence";
- case ISD::ATOMIC_CMP_SWAP: return "AtomicCmpSwap";
- case ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS: return "AtomicCmpSwapWithSuccess";
- case ISD::ATOMIC_SWAP: return "AtomicSwap";
- case ISD::ATOMIC_LOAD_ADD: return "AtomicLoadAdd";
- case ISD::ATOMIC_LOAD_SUB: return "AtomicLoadSub";
- case ISD::ATOMIC_LOAD_AND: return "AtomicLoadAnd";
- case ISD::ATOMIC_LOAD_CLR: return "AtomicLoadClr";
- case ISD::ATOMIC_LOAD_OR: return "AtomicLoadOr";
- case ISD::ATOMIC_LOAD_XOR: return "AtomicLoadXor";
- case ISD::ATOMIC_LOAD_NAND: return "AtomicLoadNand";
- case ISD::ATOMIC_LOAD_MIN: return "AtomicLoadMin";
- case ISD::ATOMIC_LOAD_MAX: return "AtomicLoadMax";
- case ISD::ATOMIC_LOAD_UMIN: return "AtomicLoadUMin";
- case ISD::ATOMIC_LOAD_UMAX: return "AtomicLoadUMax";
- case ISD::ATOMIC_LOAD_FADD: return "AtomicLoadFAdd";
- case ISD::ATOMIC_LOAD_FSUB: return "AtomicLoadFSub";
- case ISD::ATOMIC_LOAD_FMIN: return "AtomicLoadFMin";
- case ISD::ATOMIC_LOAD_FMAX: return "AtomicLoadFMax";
- case ISD::ATOMIC_LOAD_FMINIMUM: return "AtomicLoadFMinimum";
- case ISD::ATOMIC_LOAD_FMAXIMUM: return "AtomicLoadFMaximum";
- case ISD::ATOMIC_LOAD_UINC_WRAP:
- return "AtomicLoadUIncWrap";
- case ISD::ATOMIC_LOAD_UDEC_WRAP:
- return "AtomicLoadUDecWrap";
- case ISD::ATOMIC_LOAD_USUB_COND:
- return "AtomicLoadUSubCond";
- case ISD::ATOMIC_LOAD_USUB_SAT:
- return "AtomicLoadUSubSat";
- case ISD::ATOMIC_LOAD: return "AtomicLoad";
- case ISD::ATOMIC_STORE: return "AtomicStore";
- case ISD::PCMARKER: return "PCMarker";
- case ISD::READCYCLECOUNTER: return "ReadCycleCounter";
- case ISD::READSTEADYCOUNTER: return "ReadSteadyCounter";
- case ISD::SRCVALUE: return "SrcValue";
- case ISD::MDNODE_SDNODE: return "MDNode";
- case ISD::EntryToken: return "EntryToken";
- case ISD::TokenFactor: return "TokenFactor";
- case ISD::AssertSext: return "AssertSext";
- case ISD::AssertZext: return "AssertZext";
- case ISD::AssertNoFPClass: return "AssertNoFPClass";
- case ISD::AssertAlign: return "AssertAlign";
-
- case ISD::BasicBlock: return "BasicBlock";
- case ISD::VALUETYPE: return "ValueType";
- case ISD::Register: return "Register";
- case ISD::RegisterMask: return "RegisterMask";
+
case ISD::Constant:
if (cast<ConstantSDNode>(this)->isOpaque())
return "OpaqueConstant";
return "Constant";
- case ISD::ConstantFP: return "ConstantFP";
- case ISD::GlobalAddress: return "GlobalAddress";
- case ISD::GlobalTLSAddress: return "GlobalTLSAddress";
- case ISD::PtrAuthGlobalAddress: return "PtrAuthGlobalAddress";
- case ISD::FrameIndex: return "FrameIndex";
- case ISD::JumpTable: return "JumpTable";
- case ISD::JUMP_TABLE_DEBUG_INFO:
- return "JUMP_TABLE_DEBUG_INFO";
- case ISD::GLOBAL_OFFSET_TABLE: return "GLOBAL_OFFSET_TABLE";
- case ISD::RETURNADDR: return "RETURNADDR";
- case ISD::ADDROFRETURNADDR: return "ADDROFRETURNADDR";
- case ISD::FRAMEADDR: return "FRAMEADDR";
- case ISD::SPONENTRY: return "SPONENTRY";
- case ISD::STACKADDRESS: return "STACKADDRESS";
- case ISD::LOCAL_RECOVER: return "LOCAL_RECOVER";
- case ISD::READ_REGISTER: return "READ_REGISTER";
- case ISD::WRITE_REGISTER: return "WRITE_REGISTER";
- case ISD::FRAME_TO_ARGS_OFFSET: return "FRAME_TO_ARGS_OFFSET";
- case ISD::EH_DWARF_CFA: return "EH_DWARF_CFA";
- case ISD::EH_RETURN: return "EH_RETURN";
- case ISD::EH_SJLJ_SETJMP: return "EH_SJLJ_SETJMP";
- case ISD::EH_SJLJ_LONGJMP: return "EH_SJLJ_LONGJMP";
- case ISD::EH_SJLJ_SETUP_DISPATCH: return "EH_SJLJ_SETUP_DISPATCH";
- case ISD::ConstantPool: return "ConstantPool";
- case ISD::TargetIndex: return "TargetIndex";
- case ISD::ExternalSymbol: return "ExternalSymbol";
- case ISD::BlockAddress: return "BlockAddress";
case ISD::INTRINSIC_WO_CHAIN:
case ISD::INTRINSIC_VOID:
case ISD::INTRINSIC_W_CHAIN: {
@@ -178,454 +168,67 @@ std::string SDNode::getOperationName(const SelectionDAG *G) const {
llvm_unreachable("Invalid intrinsic ID");
}
- case ISD::BUILD_VECTOR: return "BUILD_VECTOR";
case ISD::TargetConstant:
if (cast<ConstantSDNode>(this)->isOpaque())
return "OpaqueTargetConstant";
return "TargetConstant";
- case ISD::TargetConstantFP: return "TargetConstantFP";
- case ISD::TargetGlobalAddress: return "TargetGlobalAddress";
- case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress";
- case ISD::TargetFrameIndex: return "TargetFrameIndex";
- case ISD::TargetJumpTable: return "TargetJumpTable";
- case ISD::TargetConstantPool: return "TargetConstantPool";
- case ISD::TargetExternalSymbol: return "TargetExternalSymbol";
- case ISD::MCSymbol: return "MCSymbol";
- case ISD::TargetBlockAddress: return "TargetBlockAddress";
-
- case ISD::CopyToReg: return "CopyToReg";
- case ISD::CopyFromReg: return "CopyFromReg";
- case ISD::UNDEF: return "undef";
- case ISD::POISON: return "poison";
- case ISD::VSCALE: return "vscale";
- case ISD::MERGE_VALUES: return "merge_values";
- case ISD::INLINEASM: return "inlineasm";
- case ISD::INLINEASM_BR: return "inlineasm_br";
- case ISD::EH_LABEL: return "eh_label";
- case ISD::ANNOTATION_LABEL: return "annotation_label";
- case ISD::HANDLENODE: return "handlenode";
-
- // Unary operators
- case ISD::FABS: return "fabs";
- case ISD::FMINNUM: return "fminnum";
- case ISD::STRICT_FMINNUM: return "strict_fminnum";
- case ISD::FMAXNUM: return "fmaxnum";
- case ISD::STRICT_FMAXNUM: return "strict_fmaxnum";
- case ISD::FMINNUM_IEEE: return "fminnum_ieee";
- case ISD::FMAXNUM_IEEE: return "fmaxnum_ieee";
- case ISD::FMINIMUM: return "fminimum";
- case ISD::STRICT_FMINIMUM: return "strict_fminimum";
- case ISD::FMAXIMUM: return "fmaximum";
- case ISD::STRICT_FMAXIMUM: return "strict_fmaximum";
- case ISD::FMINIMUMNUM: return "fminimumnum";
- case ISD::FMAXIMUMNUM: return "fmaximumnum";
- case ISD::FNEG: return "fneg";
- case ISD::FSQRT: return "fsqrt";
- case ISD::STRICT_FSQRT: return "strict_fsqrt";
- case ISD::FCBRT: return "fcbrt";
- case ISD::FSIN: return "fsin";
- case ISD::STRICT_FSIN: return "strict_fsin";
- case ISD::FCOS: return "fcos";
- case ISD::STRICT_FCOS: return "strict_fcos";
- case ISD::FSINCOS: return "fsincos";
- case ISD::FSINCOSPI: return "fsincospi";
- case ISD::FMODF: return "fmodf";
- case ISD::FTAN: return "ftan";
- case ISD::STRICT_FTAN: return "strict_ftan";
- case ISD::FASIN: return "fasin";
- case ISD::STRICT_FASIN: return "strict_fasin";
- case ISD::FACOS: return "facos";
- case ISD::STRICT_FACOS: return "strict_facos";
- case ISD::FATAN: return "fatan";
- case ISD::STRICT_FATAN: return "strict_fatan";
- case ISD::FATAN2: return "fatan2";
- case ISD::STRICT_FATAN2: return "strict_fatan2";
- case ISD::FSINH: return "fsinh";
- case ISD::STRICT_FSINH: return "strict_fsinh";
- case ISD::FCOSH: return "fcosh";
- case ISD::STRICT_FCOSH: return "strict_fcosh";
- case ISD::FTANH: return "ftanh";
- case ISD::STRICT_FTANH: return "strict_ftanh";
- case ISD::FTRUNC: return "ftrunc";
- case ISD::STRICT_FTRUNC: return "strict_ftrunc";
- case ISD::FFLOOR: return "ffloor";
- case ISD::STRICT_FFLOOR: return "strict_ffloor";
- case ISD::FCEIL: return "fceil";
- case ISD::STRICT_FCEIL: return "strict_fceil";
- case ISD::FRINT: return "frint";
- case ISD::STRICT_FRINT: return "strict_frint";
- case ISD::FNEARBYINT: return "fnearbyint";
- case ISD::STRICT_FNEARBYINT: return "strict_fnearbyint";
- case ISD::FROUND: return "fround";
- case ISD::STRICT_FROUND: return "strict_fround";
- case ISD::FROUNDEVEN: return "froundeven";
- case ISD::STRICT_FROUNDEVEN: return "strict_froundeven";
- case ISD::FEXP: return "fexp";
- case ISD::STRICT_FEXP: return "strict_fexp";
- case ISD::FEXP2: return "fexp2";
- case ISD::STRICT_FEXP2: return "strict_fexp2";
- case ISD::FEXP10: return "fexp10";
- case ISD::FLOG: return "flog";
- case ISD::STRICT_FLOG: return "strict_flog";
- case ISD::FLOG2: return "flog2";
- case ISD::STRICT_FLOG2: return "strict_flog2";
- case ISD::FLOG10: return "flog10";
- case ISD::STRICT_FLOG10: return "strict_flog10";
-
- // Binary operators
- case ISD::ADD: return "add";
- case ISD::PTRADD: return "ptradd";
- case ISD::SUB: return "sub";
- case ISD::MUL: return "mul";
- case ISD::MULHU: return "mulhu";
- case ISD::MULHS: return "mulhs";
- case ISD::AVGFLOORU: return "avgflooru";
- case ISD::AVGFLOORS: return "avgfloors";
- case ISD::AVGCEILU: return "avgceilu";
- case ISD::AVGCEILS: return "avgceils";
- case ISD::ABDS: return "abds";
- case ISD::ABDU: return "abdu";
- case ISD::SDIV: return "sdiv";
- case ISD::UDIV: return "udiv";
- case ISD::SREM: return "srem";
- case ISD::UREM: return "urem";
- case ISD::SMUL_LOHI: return "smul_lohi";
- case ISD::UMUL_LOHI: return "umul_lohi";
- case ISD::SDIVREM: return "sdivrem";
- case ISD::UDIVREM: return "udivrem";
- case ISD::AND: return "and";
- case ISD::OR: return "or";
- case ISD::XOR: return "xor";
- case ISD::SHL: return "shl";
- case ISD::SRA: return "sra";
- case ISD::SRL: return "srl";
- case ISD::ROTL: return "rotl";
- case ISD::ROTR: return "rotr";
- case ISD::FSHL: return "fshl";
- case ISD::FSHR: return "fshr";
- case ISD::CLMUL: return "clmul";
- case ISD::CLMULR: return "clmulr";
- case ISD::CLMULH: return "clmulh";
- case ISD::PEXT: return "pext";
- case ISD::PDEP: return "pdep";
- case ISD::FADD: return "fadd";
- case ISD::STRICT_FADD: return "strict_fadd";
- case ISD::FSUB: return "fsub";
- case ISD::STRICT_FSUB: return "strict_fsub";
- case ISD::FMUL: return "fmul";
- case ISD::STRICT_FMUL: return "strict_fmul";
- case ISD::FDIV: return "fdiv";
- case ISD::STRICT_FDIV: return "strict_fdiv";
- case ISD::FMA: return "fma";
- case ISD::STRICT_FMA: return "strict_fma";
- case ISD::FMAD: return "fmad";
- case ISD::FMULADD: return "fmuladd";
- case ISD::FREM: return "frem";
- case ISD::STRICT_FREM: return "strict_frem";
- case ISD::FCOPYSIGN: return "fcopysign";
- case ISD::FGETSIGN: return "fgetsign";
- case ISD::FCANONICALIZE: return "fcanonicalize";
- case ISD::IS_FPCLASS: return "is_fpclass";
- case ISD::FPOW: return "fpow";
- case ISD::STRICT_FPOW: return "strict_fpow";
- case ISD::SMIN: return "smin";
- case ISD::SMAX: return "smax";
- case ISD::UMIN: return "umin";
- case ISD::UMAX: return "umax";
- case ISD::SCMP: return "scmp";
- case ISD::UCMP: return "ucmp";
-
- case ISD::FLDEXP: return "fldexp";
- case ISD::STRICT_FLDEXP: return "strict_fldexp";
- case ISD::FFREXP: return "ffrexp";
- case ISD::FPOWI: return "fpowi";
- case ISD::STRICT_FPOWI: return "strict_fpowi";
- case ISD::SETCC: return "setcc";
- case ISD::SETCCCARRY: return "setcccarry";
- case ISD::STRICT_FSETCC: return "strict_fsetcc";
- case ISD::STRICT_FSETCCS: return "strict_fsetccs";
- case ISD::FPTRUNC_ROUND: return "fptrunc_round";
- case ISD::SELECT: return "select";
- case ISD::VSELECT: return "vselect";
- case ISD::SELECT_CC: return "select_cc";
- case ISD::INSERT_VECTOR_ELT: return "insert_vector_elt";
- case ISD::EXTRACT_VECTOR_ELT: return "extract_vector_elt";
- case ISD::CONCAT_VECTORS: return "concat_vectors";
- case ISD::INSERT_SUBVECTOR: return "insert_subvector";
- case ISD::EXTRACT_SUBVECTOR: return "extract_subvector";
- case ISD::VECTOR_DEINTERLEAVE: return "vector_deinterleave";
- case ISD::VECTOR_INTERLEAVE: return "vector_interleave";
- case ISD::SCALAR_TO_VECTOR: return "scalar_to_vector";
- case ISD::VECTOR_SHUFFLE: return "vector_shuffle";
- case ISD::VECTOR_SPLICE_LEFT: return "vector_splice_left";
- case ISD::VECTOR_SPLICE_RIGHT: return "vector_splice_right";
- case ISD::SPLAT_VECTOR: return "splat_vector";
- case ISD::SPLAT_VECTOR_PARTS: return "splat_vector_parts";
- case ISD::VECTOR_REVERSE: return "vector_reverse";
- case ISD::STEP_VECTOR: return "step_vector";
- case ISD::CARRY_FALSE: return "carry_false";
- case ISD::ADDC: return "addc";
- case ISD::ADDE: return "adde";
- case ISD::UADDO_CARRY: return "uaddo_carry";
- case ISD::SADDO_CARRY: return "saddo_carry";
- case ISD::SADDO: return "saddo";
- case ISD::UADDO: return "uaddo";
- case ISD::SSUBO: return "ssubo";
- case ISD::USUBO: return "usubo";
- case ISD::SMULO: return "smulo";
- case ISD::UMULO: return "umulo";
- case ISD::SUBC: return "subc";
- case ISD::SUBE: return "sube";
- case ISD::USUBO_CARRY: return "usubo_carry";
- case ISD::SSUBO_CARRY: return "ssubo_carry";
- case ISD::SHL_PARTS: return "shl_parts";
- case ISD::SRA_PARTS: return "sra_parts";
- case ISD::SRL_PARTS: return "srl_parts";
-
- case ISD::SADDSAT: return "saddsat";
- case ISD::UADDSAT: return "uaddsat";
- case ISD::SSUBSAT: return "ssubsat";
- case ISD::USUBSAT: return "usubsat";
- case ISD::SSHLSAT: return "sshlsat";
- case ISD::USHLSAT: return "ushlsat";
-
- case ISD::SMULFIX: return "smulfix";
- case ISD::SMULFIXSAT: return "smulfixsat";
- case ISD::UMULFIX: return "umulfix";
- case ISD::UMULFIXSAT: return "umulfixsat";
-
- case ISD::SDIVFIX: return "sdivfix";
- case ISD::SDIVFIXSAT: return "sdivfixsat";
- case ISD::UDIVFIX: return "udivfix";
- case ISD::UDIVFIXSAT: return "udivfixsat";
-
- // Conversion operators.
- case ISD::SIGN_EXTEND: return "sign_extend";
- case ISD::ZERO_EXTEND: return "zero_extend";
- case ISD::ANY_EXTEND: return "any_extend";
- case ISD::SIGN_EXTEND_INREG: return "sign_extend_inreg";
- case ISD::ANY_EXTEND_VECTOR_INREG: return "any_extend_vector_inreg";
- case ISD::SIGN_EXTEND_VECTOR_INREG: return "sign_extend_vector_inreg";
- case ISD::ZERO_EXTEND_VECTOR_INREG: return "zero_extend_vector_inreg";
- case ISD::TRUNCATE: return "truncate";
- case ISD::TRUNCATE_SSAT_S: return "truncate_ssat_s";
- case ISD::TRUNCATE_SSAT_U: return "truncate_ssat_u";
- case ISD::TRUNCATE_USAT_U: return "truncate_usat_u";
- case ISD::FP_ROUND: return "fp_round";
- case ISD::STRICT_FP_ROUND: return "strict_fp_round";
- case ISD::FP_EXTEND: return "fp_extend";
- case ISD::STRICT_FP_EXTEND: return "strict_fp_extend";
-
- case ISD::SINT_TO_FP: return "sint_to_fp";
- case ISD::STRICT_SINT_TO_FP: return "strict_sint_to_fp";
- case ISD::UINT_TO_FP: return "uint_to_fp";
- case ISD::STRICT_UINT_TO_FP: return "strict_uint_to_fp";
- case ISD::FP_TO_SINT: return "fp_to_sint";
- case ISD::STRICT_FP_TO_SINT: return "strict_fp_to_sint";
- case ISD::FP_TO_UINT: return "fp_to_uint";
- case ISD::STRICT_FP_TO_UINT: return "strict_fp_to_uint";
- case ISD::FP_TO_SINT_SAT: return "fp_to_sint_sat";
- case ISD::FP_TO_UINT_SAT: return "fp_to_uint_sat";
- case ISD::BITCAST: return "bitcast";
- case ISD::ADDRSPACECAST: return "addrspacecast";
- case ISD::FP16_TO_FP: return "fp16_to_fp";
- case ISD::STRICT_FP16_TO_FP: return "strict_fp16_to_fp";
- case ISD::FP_TO_FP16: return "fp_to_fp16";
- case ISD::STRICT_FP_TO_FP16: return "strict_fp_to_fp16";
- case ISD::BF16_TO_FP: return "bf16_to_fp";
- case ISD::STRICT_BF16_TO_FP: return "strict_bf16_to_fp";
- case ISD::FP_TO_BF16: return "fp_to_bf16";
- case ISD::STRICT_FP_TO_BF16: return "strict_fp_to_bf16";
- case ISD::CONVERT_FROM_ARBITRARY_FP: return "convert_from_arbitrary_fp";
- case ISD::CONVERT_TO_ARBITRARY_FP: return "convert_to_arbitrary_fp";
- case ISD::LROUND: return "lround";
- case ISD::STRICT_LROUND: return "strict_lround";
- case ISD::LLROUND: return "llround";
- case ISD::STRICT_LLROUND: return "strict_llround";
- case ISD::LRINT: return "lrint";
- case ISD::STRICT_LRINT: return "strict_lrint";
- case ISD::LLRINT: return "llrint";
- case ISD::STRICT_LLRINT: return "strict_llrint";
-
- // Control flow instructions
- case ISD::BR: return "br";
- case ISD::BRIND: return "brind";
- case ISD::BR_JT: return "br_jt";
- case ISD::BRCOND: return "brcond";
- case ISD::BR_CC: return "br_cc";
- case ISD::CALLSEQ_START: return "callseq_start";
- case ISD::CALLSEQ_END: return "callseq_end";
-
- // EH instructions
- case ISD::CATCHRET: return "catchret";
- case ISD::CLEANUPRET: return "cleanupret";
-
- // Other operators
- case ISD::LOAD: return "load";
- case ISD::STORE: return "store";
- case ISD::MLOAD: return "masked_load";
- case ISD::MSTORE: return "masked_store";
- case ISD::MGATHER: return "masked_gather";
- case ISD::MSCATTER: return "masked_scatter";
- case ISD::VECTOR_COMPRESS: return "vector_compress";
- case ISD::VAARG: return "vaarg";
- case ISD::VACOPY: return "vacopy";
- case ISD::VAEND: return "vaend";
- case ISD::VASTART: return "vastart";
- case ISD::DYNAMIC_STACKALLOC: return "dynamic_stackalloc";
- case ISD::EXTRACT_ELEMENT: return "extract_element";
- case ISD::BUILD_PAIR: return "build_pair";
- case ISD::STACKSAVE: return "stacksave";
- case ISD::STACKRESTORE: return "stackrestore";
- case ISD::TRAP: return "trap";
- case ISD::DEBUGTRAP: return "debugtrap";
- case ISD::UBSANTRAP: return "ubsantrap";
- case ISD::LIFETIME_START: return "lifetime.start";
- case ISD::LIFETIME_END: return "lifetime.end";
- case ISD::FAKE_USE:
- return "fake_use";
- case ISD::RELOC_NONE:
- return "reloc_none";
- case ISD::COND_LOOP:
- return "cond_loop";
- case ISD::PSEUDO_PROBE:
- return "pseudoprobe";
- case ISD::GC_TRANSITION_START: return "gc_transition.start";
- case ISD::GC_TRANSITION_END: return "gc_transition.end";
- case ISD::GET_DYNAMIC_AREA_OFFSET: return "get.dynamic.area.offset";
- case ISD::FREEZE: return "freeze";
- case ISD::PREALLOCATED_SETUP:
- return "call_setup";
- case ISD::PREALLOCATED_ARG:
- return "call_alloc";
-
- // Floating point environment manipulation
- case ISD::GET_ROUNDING: return "get_rounding";
- case ISD::SET_ROUNDING: return "set_rounding";
- case ISD::GET_FPENV: return "get_fpenv";
- case ISD::SET_FPENV: return "set_fpenv";
- case ISD::RESET_FPENV: return "reset_fpenv";
- case ISD::GET_FPENV_MEM: return "get_fpenv_mem";
- case ISD::SET_FPENV_MEM: return "set_fpenv_mem";
- case ISD::GET_FPMODE: return "get_fpmode";
- case ISD::SET_FPMODE: return "set_fpmode";
- case ISD::RESET_FPMODE: return "reset_fpmode";
-
- // Convergence control instructions
- case ISD::CONVERGENCECTRL_ANCHOR: return "convergencectrl_anchor";
- case ISD::CONVERGENCECTRL_ENTRY: return "convergencectrl_entry";
- case ISD::CONVERGENCECTRL_LOOP: return "convergencectrl_loop";
- case ISD::CONVERGENCECTRL_GLUE: return "convergencectrl_glue";
-
- // Bit manipulation
- case ISD::ABS: return "abs";
- case ISD::ABS_MIN_POISON: return "abs_min_poison";
- case ISD::BITREVERSE: return "bitreverse";
- case ISD::BSWAP: return "bswap";
- case ISD::CTPOP: return "ctpop";
- case ISD::CTTZ: return "cttz";
- case ISD::CTTZ_ZERO_POISON: return "cttz_zero_poison";
- case ISD::CTLZ: return "ctlz";
- case ISD::CTLZ_ZERO_POISON: return "ctlz_zero_poison";
- case ISD::CTLS: return "ctls";
- case ISD::PARITY: return "parity";
-
- // Trampolines
- case ISD::INIT_TRAMPOLINE: return "init_trampoline";
- case ISD::ADJUST_TRAMPOLINE: return "adjust_trampoline";
-
- // clang-format on
-
case ISD::CONDCODE:
switch (cast<CondCodeSDNode>(this)->get()) {
- default: llvm_unreachable("Unknown setcc condition!");
- case ISD::SETOEQ: return "setoeq";
- case ISD::SETOGT: return "setogt";
- case ISD::SETOGE: return "setoge";
- case ISD::SETOLT: return "setolt";
- case ISD::SETOLE: return "setole";
- case ISD::SETONE: return "setone";
-
- case ISD::SETO: return "seto";
- case ISD::SETUO: return "setuo";
- case ISD::SETUEQ: return "setueq";
- case ISD::SETUGT: return "setugt";
- case ISD::SETUGE: return "setuge";
- case ISD::SETULT: return "setult";
- case ISD::SETULE: return "setule";
- case ISD::SETUNE: return "setune";
-
- case ISD::SETEQ: return "seteq";
- case ISD::SETGT: return "setgt";
- case ISD::SETGE: return "setge";
- case ISD::SETLT: return "setlt";
- case ISD::SETLE: return "setle";
- case ISD::SETNE: return "setne";
-
- case ISD::SETTRUE: return "settrue";
- case ISD::SETTRUE2: return "settrue2";
- case ISD::SETFALSE: return "setfalse";
- case ISD::SETFALSE2: return "setfalse2";
+ default:
+ llvm_unreachable("Unknown setcc condition!");
+ case ISD::SETOEQ:
+ return "setoeq";
+ case ISD::SETOGT:
+ return "setogt";
+ case ISD::SETOGE:
+ return "setoge";
+ case ISD::SETOLT:
+ return "setolt";
+ case ISD::SETOLE:
+ return "setole";
+ case ISD::SETONE:
+ return "setone";
+
+ case ISD::SETO:
+ return "seto";
+ case ISD::SETUO:
+ return "setuo";
+ case ISD::SETUEQ:
+ return "setueq";
+ case ISD::SETUGT:
+ return "setugt";
+ case ISD::SETUGE:
+ return "setuge";
+ case ISD::SETULT:
+ return "setult";
+ case ISD::SETULE:
+ return "setule";
+ case ISD::SETUNE:
+ return "setune";
+
+ case ISD::SETEQ:
+ return "seteq";
+ case ISD::SETGT:
+ return "setgt";
+ case ISD::SETGE:
+ return "setge";
+ case ISD::SETLT:
+ return "setlt";
+ case ISD::SETLE:
+ return "setle";
+ case ISD::SETNE:
+ return "setne";
+
+ case ISD::SETTRUE:
+ return "settrue";
+ case ISD::SETTRUE2:
+ return "settrue2";
+ case ISD::SETFALSE:
+ return "setfalse";
+ case ISD::SETFALSE2:
+ return "setfalse2";
}
- case ISD::VECREDUCE_FADD: return "vecreduce_fadd";
- case ISD::VECREDUCE_SEQ_FADD: return "vecreduce_seq_fadd";
- case ISD::VECREDUCE_FMUL: return "vecreduce_fmul";
- case ISD::VECREDUCE_SEQ_FMUL: return "vecreduce_seq_fmul";
- case ISD::VECREDUCE_ADD: return "vecreduce_add";
- case ISD::VECREDUCE_MUL: return "vecreduce_mul";
- case ISD::VECREDUCE_AND: return "vecreduce_and";
- case ISD::VECREDUCE_OR: return "vecreduce_or";
- case ISD::VECREDUCE_XOR: return "vecreduce_xor";
- case ISD::VECREDUCE_SMAX: return "vecreduce_smax";
- case ISD::VECREDUCE_SMIN: return "vecreduce_smin";
- case ISD::VECREDUCE_UMAX: return "vecreduce_umax";
- case ISD::VECREDUCE_UMIN: return "vecreduce_umin";
- case ISD::VECREDUCE_FMAX: return "vecreduce_fmax";
- case ISD::VECREDUCE_FMIN: return "vecreduce_fmin";
- case ISD::VECREDUCE_FMAXIMUM: return "vecreduce_fmaximum";
- case ISD::VECREDUCE_FMINIMUM: return "vecreduce_fminimum";
- case ISD::STACKMAP:
- return "stackmap";
- case ISD::PATCHPOINT:
- return "patchpoint";
- case ISD::CLEAR_CACHE:
- return "clear_cache";
-
- case ISD::EXPERIMENTAL_VECTOR_HISTOGRAM:
- return "histogram";
-
- case ISD::CTTZ_ELTS:
- return "cttz_elts";
- case ISD::CTTZ_ELTS_ZERO_POISON:
- return "cttz_elts_zero_poison";
-
- case ISD::VECTOR_FIND_LAST_ACTIVE:
- return "find_last_active";
-
- case ISD::GET_ACTIVE_LANE_MASK:
- return "get_active_lane_mask";
-
- case ISD::PARTIAL_REDUCE_UMLA:
- return "partial_reduce_umla";
- case ISD::PARTIAL_REDUCE_SMLA:
- return "partial_reduce_smla";
- case ISD::PARTIAL_REDUCE_SUMLA:
- return "partial_reduce_sumla";
- case ISD::PARTIAL_REDUCE_FMLA:
- return "partial_reduce_fmla";
- case ISD::LOOP_DEPENDENCE_WAR_MASK:
- return "loop_dep_war";
- case ISD::LOOP_DEPENDENCE_RAW_MASK:
- return "loop_dep_raw";
- case ISD::MASKED_UDIV:
- return "masked_udiv";
- case ISD::MASKED_SDIV:
- return "masked_sdiv";
- case ISD::MASKED_UREM:
- return "masked_urem";
- case ISD::MASKED_SREM:
- return "masked_srem";
// Vector Predication
#define BEGIN_REGISTER_VP_SDNODE(SDID, LEGALARG, NAME, ...) \
diff --git a/llvm/unittests/CodeGen/CMakeLists.txt b/llvm/unittests/CodeGen/CMakeLists.txt
index 709017380fa4e..d84d88316bee4 100644
--- a/llvm/unittests/CodeGen/CMakeLists.txt
+++ b/llvm/unittests/CodeGen/CMakeLists.txt
@@ -47,6 +47,7 @@ add_llvm_unittest(CodeGenTests
SchedBoundary.cpp
SelectionDAGAddressAnalysisTest.cpp
SelectionDAGNodeConstructionTest.cpp
+ SelectionDAGOperationNameTest.cpp
SelectionDAGPatternMatchTest.cpp
TypeTraitsTest.cpp
TargetOptionsTest.cpp
diff --git a/llvm/unittests/CodeGen/SelectionDAGOperationNameTest.cpp b/llvm/unittests/CodeGen/SelectionDAGOperationNameTest.cpp
new file mode 100644
index 0000000000000..ec83d32ef52a6
--- /dev/null
+++ b/llvm/unittests/CodeGen/SelectionDAGOperationNameTest.cpp
@@ -0,0 +1,30 @@
+//===- SelectionDAGOperationNameTest.cpp ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/ISDOpcodes.h"
+#include "llvm/CodeGen/SelectionDAGNodes.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+class NamedSDNode : public SDNode {
+public:
+ explicit NamedSDNode(unsigned Opcode)
+ : SDNode(Opcode, 0, DebugLoc(), getSDVTList(MVT::Other)) {}
+};
+
+TEST(SelectionDAGOperationNameTest, FixedOperationNames) {
+#define DAG_NODE_NAME(OPCODE, NAME) \
+ EXPECT_EQ(NAME, NamedSDNode(ISD::OPCODE).getOperationName(nullptr));
+#include "llvm/CodeGen/SelectionDAGOperationNames.def"
+#undef DAG_NODE_NAME
+}
+
+} // namespace
More information about the llvm-commits
mailing list