[llvm] [SelectionDAG] Table-drive fixed operation names (PR #202841)

David Zbarsky via llvm-commits llvm-commits at lists.llvm.org
Sat Jul 11 10:20:00 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 1/2] [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

>From 97a8f1365ff0162c75e1ea385b1b352774ebde9b Mon Sep 17 00:00:00 2001
From: David Zbarsky <dzbarsky at gmail.com>
Date: Sat, 11 Jul 2026 12:44:59 -0400
Subject: [PATCH 2/2] [SelectionDAG] Simplify fixed operation name tables

Replace the separate offset and length tables with adjacent offsets. Add VP SDNode names to SelectionDAGOperationNames.def and remove the VP switch cases.

Relative to the previous branch tip, SelectionDAGDumper.cpp.o decreases by 6,000 bytes and 140 relocations. Release opt decreases by 64 bytes unstripped; stripped size and linked fixups are unchanged.
---
 .../CodeGen/SelectionDAGOperationNames.def    |  4 ++
 .../SelectionDAG/SelectionDAGDumper.cpp       | 69 +++++++------------
 2 files changed, 29 insertions(+), 44 deletions(-)

diff --git a/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def b/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def
index 2d51db60a665b..02e7c4960bf51 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def
+++ b/llvm/include/llvm/CodeGen/SelectionDAGOperationNames.def
@@ -435,3 +435,7 @@ 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")
+
+#define BEGIN_REGISTER_VP_SDNODE(SDID, LEGALARG, NAME, ...)                    \
+  DAG_NODE_NAME(SDID, #NAME)
+#include "llvm/IR/VPIntrinsics.def"
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
index 1456778e20172..d65e35a329ad5 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
@@ -50,7 +50,6 @@
 #include <cstdint>
 #include <iterator>
 #include <limits>
-#include <type_traits>
 
 using namespace llvm;
 
@@ -65,63 +64,51 @@ static cl::opt<bool>
 
 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)];
+constexpr size_t FixedOperationNamesSize = 0
+#define DAG_NODE_NAME(OPCODE, NAME) +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>);
+static_assert(FixedOperationNamesSize <= std::numeric_limits<uint16_t>::max());
 
+constexpr auto makeFixedOperationNameOffsets() {
+  std::array<uint16_t, ISD::BUILTIN_OP_END + 1> Result{};
+  std::array<uint16_t, ISD::BUILTIN_OP_END> Lengths{};
 #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());
+  Lengths[ISD::OPCODE] = sizeof(NAME);
 #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{};
+  for (size_t Opcode = 0; Opcode < Lengths.size(); ++Opcode)
+    Result[Opcode + 1] = Result[Opcode] + Lengths[Opcode];
+  return Result;
+}
+
+constexpr auto FixedOperationNameOffsets = makeFixedOperationNameOffsets();
+
+constexpr auto makeFixedOperationNames() {
+  std::array<char, FixedOperationNamesSize> Result{};
 #define DAG_NODE_NAME(OPCODE, NAME)                                            \
-  Result[ISD::OPCODE] = static_cast<ValueType>(                                \
-      StoreLengths ? sizeof(NAME) - 1                                          \
-                   : offsetof(FixedOperationNameData, OPCODE));
+  for (size_t I = 0; I < sizeof(NAME); ++I)                                    \
+    Result[FixedOperationNameOffsets[ISD::OPCODE] + I] = NAME[I];
 #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));
+constexpr auto FixedOperationNames = makeFixedOperationNames();
 
 } // namespace
 
 std::string SDNode::getOperationName(const SelectionDAG *G) const {
   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);
-    }
+  if (Opcode < ISD::BUILTIN_OP_END) {
+    const uint16_t Begin = FixedOperationNameOffsets[Opcode];
+    const uint16_t End = FixedOperationNameOffsets[Opcode + 1];
+    if (Begin != End)
+      return std::string(FixedOperationNames.data() + Begin, End - Begin - 1);
   }
 
   switch (Opcode) {
@@ -229,12 +216,6 @@ std::string SDNode::getOperationName(const SelectionDAG *G) const {
     case ISD::SETFALSE2:
       return "setfalse2";
     }
-
-    // Vector Predication
-#define BEGIN_REGISTER_VP_SDNODE(SDID, LEGALARG, NAME, ...)                    \
-  case ISD::SDID:                                                              \
-    return #NAME;
-#include "llvm/IR/VPIntrinsics.def"
   }
 }
 



More information about the llvm-commits mailing list