//==- ColossusISDOpcodeConstantsPrinter.cpp - Map opcodes to literal values -=//
//    Copyright (c) 2023 Graphcore Ltd. All Rights Reserved.
//     Licensed under the Apache License, Version 2.0 (the "License");
//     you may not use this file except in compliance with the License.
//     You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//     Unless required by applicable law or agreed to in writing, software
//     distributed under the License is distributed on an "AS IS" BASIS,
//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//     See the License for the specific language governing permissions and
//     limitations under the License.
// --- LLVM Exceptions to the Apache 2.0 License ----
//
// As an exception, if, as a result of your compiling your source code, portions
// of this Software are embedded into an Object form of such source code, you
// may redistribute such embedded portions in such Object form without complying
// with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
//
// In addition, if you combine or link compiled forms of this Software with
// software that is licensed under the GPLv2 ("Combined Software") and if a
// court of competent jurisdiction determines that the patent provision (Section
// 3), the indemnity provision (Section 9) or other Section of the License
// conflicts with the conditions of the GPLv2, you may retroactively and
// prospectively choose to deem waived or otherwise exclude such Section(s) of
// the License, but only in their entirety and only with respect to the Combined
// Software.
//
//===----------------------------------------------------------------------===//
//
// Output constexpr declaration initialized from the literal value of ISD enums
// or if an ISD name is given as parameter outputs the literal value of the
// corresponding ISD enum.
//
//===----------------------------------------------------------------------===//

#include "ColossusISDOpcodes.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/Path.h"
#include <iostream>

using namespace llvm;

#undef MAP
#define MAP(NAME, ISDNODE) {#ISDNODE, {#NAME, ISDNODE}}

const StringMap<std::pair<StringRef, int>> ISDNameConstantMapping = {
  // This list will need to be updated by hand if new nodes are introduced and
  // we want to use them with the sdag intrinsic nodes. Populating with all
  // nodes to begin with on the grounds that it's quicker to do the complete
  // set at once than to add them one at a time as required excluding
  // ISD::DELETED_NODE, ISD::BUILTIN_OP_END and ColossusISD::FIRST_NUMBER.

  // ColossusISD nodes
  MAP(ColossusISD_ADDR, ColossusISD::ADDR),
  MAP(ColossusISD_CALL, ColossusISD::CALL),
  MAP(ColossusISD_ICALL, ColossusISD::ICALL),
  MAP(ColossusISD_FRAME_TO_ARGS_OFFSET, ColossusISD::FRAME_TO_ARGS_OFFSET),
  MAP(ColossusISD_MEM_BARRIER, ColossusISD::MEM_BARRIER),
  MAP(ColossusISD_RTN, ColossusISD::RTN),
  MAP(ColossusISD_RTN_REG_HOLDER, ColossusISD::RTN_REG_HOLDER),
  MAP(ColossusISD_SETLR, ColossusISD::SETLR),
  MAP(ColossusISD_STACKSAVE, ColossusISD::STACKSAVE),
  MAP(ColossusISD_STACKRESTORE, ColossusISD::STACKRESTORE),
  MAP(ColossusISD_VERTEX_EXIT, ColossusISD::VERTEX_EXIT),
  MAP(ColossusISD_WRAPPER, ColossusISD::WRAPPER),
  MAP(ColossusISD_FNOT, ColossusISD::FNOT),
  MAP(ColossusISD_FAND, ColossusISD::FAND),
  MAP(ColossusISD_FOR, ColossusISD::FOR),
  MAP(ColossusISD_ANDC, ColossusISD::ANDC),
  MAP(ColossusISD_CONCAT_VECTORS, ColossusISD::CONCAT_VECTORS),
  MAP(ColossusISD_SORT4X16LO, ColossusISD::SORT4X16LO),
  MAP(ColossusISD_SORT4X16HI, ColossusISD::SORT4X16HI),
  MAP(ColossusISD_ROLL16, ColossusISD::ROLL16),
  MAP(ColossusISD_FCMP, ColossusISD::FCMP),
  MAP(ColossusISD_F32_TO_SINT, ColossusISD::F32_TO_SINT),
  MAP(ColossusISD_F32_TO_UINT, ColossusISD::F32_TO_UINT),
  MAP(ColossusISD_STRICT_F32_TO_SINT, ColossusISD::STRICT_F32_TO_SINT),
  MAP(ColossusISD_STRICT_F32_TO_UINT, ColossusISD::STRICT_F32_TO_UINT),
  MAP(COLOSSUSISD_STRICT_FCMPS, ColossusISD::STRICT_FCMPS),
  MAP(ColossusISD_SINT_TO_F32, ColossusISD::SINT_TO_F32),
  MAP(ColossusISD_UINT_TO_F32, ColossusISD::UINT_TO_F32),
  MAP(ColossusISD_F16ASV2F16, ColossusISD::F16ASV2F16),
  MAP(ColossusISD_V2F16ASF16, ColossusISD::V2F16ASF16),
  MAP(ColossusISD_FTANH, ColossusISD::FTANH),
  MAP(ColossusISD_FSIGMOID, ColossusISD::FSIGMOID),
  MAP(ColossusISD_FRSQRT, ColossusISD::FRSQRT),
  MAP(ColossusISD_STRICT_FRSQRT, ColossusISD::STRICT_FRSQRT),
  MAP(ColossusISD_CLOOP_BEGIN_VALUE, ColossusISD::CLOOP_BEGIN_VALUE),
  MAP(ColossusISD_CLOOP_BEGIN_TERMINATOR, ColossusISD::CLOOP_BEGIN_TERMINATOR),
  MAP(ColossusISD_CLOOP_END_VALUE, ColossusISD::CLOOP_END_VALUE),
  MAP(ColossusISD_CLOOP_END_BRANCH, ColossusISD::CLOOP_END_BRANCH),
  MAP(ColossusISD_CLOOP_GUARD_BRANCH, ColossusISD::CLOOP_GUARD_BRANCH),
  MAP(ColossusISD_SORT8X8LO, ColossusISD::SORT8X8LO),
  MAP(ColossusISD_SHUF8X8LO, ColossusISD::SHUF8X8LO),
  MAP(ColossusISD_SHUF8X8HI, ColossusISD::SHUF8X8HI),

  // Generic ISD nodes. Enumerated by running a macro across ISDOpcodes.h.
  MAP(ISD_DELETED_NODE, ISD::DELETED_NODE),
  MAP(ISD_EntryToken, ISD::EntryToken),
  MAP(ISD_TokenFactor, ISD::TokenFactor),
  MAP(ISD_AssertSext, ISD::AssertSext),
  MAP(ISD_AssertZext, ISD::AssertZext),
  MAP(ISD_BasicBlock, ISD::BasicBlock),
  MAP(ISD_VALUETYPE, ISD::VALUETYPE),
  MAP(ISD_CONDCODE, ISD::CONDCODE),
  MAP(ISD_Register, ISD::Register),
  MAP(ISD_RegisterMask, ISD::RegisterMask),
  MAP(ISD_Constant, ISD::Constant),
  MAP(ISD_ConstantFP, ISD::ConstantFP),
  MAP(ISD_GlobalAddress, ISD::GlobalAddress),
  MAP(ISD_GlobalTLSAddress, ISD::GlobalTLSAddress),
  MAP(ISD_FrameIndex, ISD::FrameIndex),
  MAP(ISD_JumpTable, ISD::JumpTable),
  MAP(ISD_ConstantPool, ISD::ConstantPool),
  MAP(ISD_ExternalSymbol, ISD::ExternalSymbol),
  MAP(ISD_BlockAddress, ISD::BlockAddress),
  MAP(ISD_GLOBAL_OFFSET_TABLE, ISD::GLOBAL_OFFSET_TABLE),
  MAP(ISD_FRAMEADDR, ISD::FRAMEADDR),
  MAP(ISD_RETURNADDR, ISD::RETURNADDR),
  MAP(ISD_ADDROFRETURNADDR, ISD::ADDROFRETURNADDR),
  MAP(ISD_SPONENTRY, ISD::SPONENTRY),
  MAP(ISD_LOCAL_RECOVER, ISD::LOCAL_RECOVER),
  MAP(ISD_READ_REGISTER, ISD::READ_REGISTER),
  MAP(ISD_WRITE_REGISTER, ISD::WRITE_REGISTER),
  MAP(ISD_FRAME_TO_ARGS_OFFSET, ISD::FRAME_TO_ARGS_OFFSET),
  MAP(ISD_EH_DWARF_CFA, ISD::EH_DWARF_CFA),
  MAP(ISD_EH_RETURN, ISD::EH_RETURN),
  MAP(ISD_EH_SJLJ_SETJMP, ISD::EH_SJLJ_SETJMP),
  MAP(ISD_EH_SJLJ_LONGJMP, ISD::EH_SJLJ_LONGJMP),
  MAP(ISD_EH_SJLJ_SETUP_DISPATCH, ISD::EH_SJLJ_SETUP_DISPATCH),
  MAP(ISD_TargetConstant, ISD::TargetConstant),
  MAP(ISD_TargetConstantFP, ISD::TargetConstantFP),
  MAP(ISD_TargetGlobalAddress, ISD::TargetGlobalAddress),
  MAP(ISD_TargetGlobalTLSAddress, ISD::TargetGlobalTLSAddress),
  MAP(ISD_TargetFrameIndex, ISD::TargetFrameIndex),
  MAP(ISD_TargetJumpTable, ISD::TargetJumpTable),
  MAP(ISD_TargetConstantPool, ISD::TargetConstantPool),
  MAP(ISD_TargetExternalSymbol, ISD::TargetExternalSymbol),
  MAP(ISD_TargetBlockAddress, ISD::TargetBlockAddress),
  MAP(ISD_MCSymbol, ISD::MCSymbol),
  MAP(ISD_TargetIndex, ISD::TargetIndex),
  MAP(ISD_INTRINSIC_WO_CHAIN, ISD::INTRINSIC_WO_CHAIN),
  MAP(ISD_INTRINSIC_W_CHAIN, ISD::INTRINSIC_W_CHAIN),
  MAP(ISD_INTRINSIC_VOID, ISD::INTRINSIC_VOID),
  MAP(ISD_CopyToReg, ISD::CopyToReg),
  MAP(ISD_CopyFromReg, ISD::CopyFromReg),
  MAP(ISD_UNDEF, ISD::UNDEF),
  MAP(ISD_EXTRACT_ELEMENT, ISD::EXTRACT_ELEMENT),
  MAP(ISD_BUILD_PAIR, ISD::BUILD_PAIR),
  MAP(ISD_MERGE_VALUES, ISD::MERGE_VALUES),
  MAP(ISD_ADD, ISD::ADD),
  MAP(ISD_SUB, ISD::SUB),
  MAP(ISD_MUL, ISD::MUL),
  MAP(ISD_SDIV, ISD::SDIV),
  MAP(ISD_UDIV, ISD::UDIV),
  MAP(ISD_SREM, ISD::SREM),
  MAP(ISD_UREM, ISD::UREM),
  MAP(ISD_SMUL_LOHI, ISD::SMUL_LOHI),
  MAP(ISD_UMUL_LOHI, ISD::UMUL_LOHI),
  MAP(ISD_SDIVREM, ISD::SDIVREM),
  MAP(ISD_UDIVREM, ISD::UDIVREM),
  MAP(ISD_CARRY_FALSE, ISD::CARRY_FALSE),
  MAP(ISD_ADDC, ISD::ADDC),
  MAP(ISD_SUBC, ISD::SUBC),
  MAP(ISD_ADDE, ISD::ADDE),
  MAP(ISD_SUBE, ISD::SUBE),
  MAP(ISD_ADDCARRY, ISD::ADDCARRY),
  MAP(ISD_SUBCARRY, ISD::SUBCARRY),
  MAP(ISD_SADDO, ISD::SADDO),
  MAP(ISD_UADDO, ISD::UADDO),
  MAP(ISD_SSUBO, ISD::SSUBO),
  MAP(ISD_USUBO, ISD::USUBO),
  MAP(ISD_SMULO, ISD::SMULO),
  MAP(ISD_UMULO, ISD::UMULO),
  MAP(ISD_SADDSAT, ISD::SADDSAT),
  MAP(ISD_UADDSAT, ISD::UADDSAT),
  MAP(ISD_SSUBSAT, ISD::SSUBSAT),
  MAP(ISD_USUBSAT, ISD::USUBSAT),
  MAP(ISD_SMULFIX, ISD::SMULFIX),
  MAP(ISD_UMULFIX, ISD::UMULFIX),
  MAP(ISD_SMULFIXSAT, ISD::SMULFIXSAT),
  MAP(ISD_UMULFIXSAT, ISD::UMULFIXSAT),
  MAP(ISD_SDIVFIX, ISD::SDIVFIX),
  MAP(ISD_UDIVFIX, ISD::UDIVFIX),
  MAP(ISD_FADD, ISD::FADD),
  MAP(ISD_FSUB, ISD::FSUB),
  MAP(ISD_FMUL, ISD::FMUL),
  MAP(ISD_FDIV, ISD::FDIV),
  MAP(ISD_FREM, ISD::FREM),
  MAP(ISD_STRICT_FADD, ISD::STRICT_FADD),
  MAP(ISD_STRICT_FSUB, ISD::STRICT_FSUB),
  MAP(ISD_STRICT_FMUL, ISD::STRICT_FMUL),
  MAP(ISD_STRICT_FDIV, ISD::STRICT_FDIV),
  MAP(ISD_STRICT_FREM, ISD::STRICT_FREM),
  MAP(ISD_STRICT_FMA, ISD::STRICT_FMA),
  MAP(ISD_STRICT_FSQRT, ISD::STRICT_FSQRT),
  MAP(ISD_STRICT_FPOW, ISD::STRICT_FPOW),
  MAP(ISD_STRICT_FPOWI, ISD::STRICT_FPOWI),
  MAP(ISD_STRICT_FSIN, ISD::STRICT_FSIN),
  MAP(ISD_STRICT_FCOS, ISD::STRICT_FCOS),
  MAP(ISD_STRICT_FEXP, ISD::STRICT_FEXP),
  MAP(ISD_STRICT_FEXP2, ISD::STRICT_FEXP2),
  MAP(ISD_STRICT_FLOG, ISD::STRICT_FLOG),
  MAP(ISD_STRICT_FLOG10, ISD::STRICT_FLOG10),
  MAP(ISD_STRICT_FLOG2, ISD::STRICT_FLOG2),
  MAP(ISD_STRICT_FRINT, ISD::STRICT_FRINT),
  MAP(ISD_STRICT_FNEARBYINT, ISD::STRICT_FNEARBYINT),
  MAP(ISD_STRICT_FMAXNUM, ISD::STRICT_FMAXNUM),
  MAP(ISD_STRICT_FMINNUM, ISD::STRICT_FMINNUM),
  MAP(ISD_STRICT_FCEIL, ISD::STRICT_FCEIL),
  MAP(ISD_STRICT_FFLOOR, ISD::STRICT_FFLOOR),
  MAP(ISD_STRICT_FROUND, ISD::STRICT_FROUND),
  MAP(ISD_STRICT_FTRUNC, ISD::STRICT_FTRUNC),
  MAP(ISD_STRICT_LROUND, ISD::STRICT_LROUND),
  MAP(ISD_STRICT_LLROUND, ISD::STRICT_LLROUND),
  MAP(ISD_STRICT_LRINT, ISD::STRICT_LRINT),
  MAP(ISD_STRICT_LLRINT, ISD::STRICT_LLRINT),
  MAP(ISD_STRICT_FMAXIMUM, ISD::STRICT_FMAXIMUM),
  MAP(ISD_STRICT_FMINIMUM, ISD::STRICT_FMINIMUM),
  MAP(ISD_STRICT_FP_TO_SINT, ISD::STRICT_FP_TO_SINT),
  MAP(ISD_STRICT_FP_TO_UINT, ISD::STRICT_FP_TO_UINT),
  MAP(ISD_STRICT_SINT_TO_FP, ISD::STRICT_SINT_TO_FP),
  MAP(ISD_STRICT_UINT_TO_FP, ISD::STRICT_UINT_TO_FP),
  MAP(ISD_STRICT_FP_ROUND, ISD::STRICT_FP_ROUND),
  MAP(ISD_STRICT_FP_EXTEND, ISD::STRICT_FP_EXTEND),
  MAP(ISD_STRICT_FSETCC, ISD::STRICT_FSETCC),
  MAP(ISD_STRICT_FSETCCS, ISD::STRICT_FSETCCS),
  MAP(ISD_FMA, ISD::FMA),
  MAP(ISD_FMAD, ISD::FMAD),
  MAP(ISD_FCOPYSIGN, ISD::FCOPYSIGN),
  MAP(ISD_FGETSIGN, ISD::FGETSIGN),
  MAP(ISD_FCANONICALIZE, ISD::FCANONICALIZE),
  MAP(ISD_BUILD_VECTOR, ISD::BUILD_VECTOR),
  MAP(ISD_INSERT_VECTOR_ELT, ISD::INSERT_VECTOR_ELT),
  MAP(ISD_EXTRACT_VECTOR_ELT, ISD::EXTRACT_VECTOR_ELT),
  MAP(ISD_CONCAT_VECTORS, ISD::CONCAT_VECTORS),
  MAP(ISD_INSERT_SUBVECTOR, ISD::INSERT_SUBVECTOR),
  MAP(ISD_EXTRACT_SUBVECTOR, ISD::EXTRACT_SUBVECTOR),
  MAP(ISD_VECTOR_SHUFFLE, ISD::VECTOR_SHUFFLE),
  MAP(ISD_SCALAR_TO_VECTOR, ISD::SCALAR_TO_VECTOR),
  MAP(ISD_SPLAT_VECTOR, ISD::SPLAT_VECTOR),
  MAP(ISD_MULHU, ISD::MULHU),
  MAP(ISD_MULHS, ISD::MULHS),
  MAP(ISD_SMIN, ISD::SMIN),
  MAP(ISD_SMAX, ISD::SMAX),
  MAP(ISD_UMIN, ISD::UMIN),
  MAP(ISD_UMAX, ISD::UMAX),
  MAP(ISD_AND, ISD::AND),
  MAP(ISD_OR, ISD::OR),
  MAP(ISD_XOR, ISD::XOR),
  MAP(ISD_ABS, ISD::ABS),
  MAP(ISD_SHL, ISD::SHL),
  MAP(ISD_SRA, ISD::SRA),
  MAP(ISD_SRL, ISD::SRL),
  MAP(ISD_ROTL, ISD::ROTL),
  MAP(ISD_ROTR, ISD::ROTR),
  MAP(ISD_FSHL, ISD::FSHL),
  MAP(ISD_FSHR, ISD::FSHR),
  MAP(ISD_BSWAP, ISD::BSWAP),
  MAP(ISD_CTTZ, ISD::CTTZ),
  MAP(ISD_CTLZ, ISD::CTLZ),
  MAP(ISD_CTPOP, ISD::CTPOP),
  MAP(ISD_BITREVERSE, ISD::BITREVERSE),
  MAP(ISD_CTTZ_ZERO_UNDEF, ISD::CTTZ_ZERO_UNDEF),
  MAP(ISD_CTLZ_ZERO_UNDEF, ISD::CTLZ_ZERO_UNDEF),
  MAP(ISD_SELECT, ISD::SELECT),
  MAP(ISD_VSELECT, ISD::VSELECT),
  MAP(ISD_SELECT_CC, ISD::SELECT_CC),
  MAP(ISD_SETCC, ISD::SETCC),
  MAP(ISD_SETCCCARRY, ISD::SETCCCARRY),
  MAP(ISD_SHL_PARTS, ISD::SHL_PARTS),
  MAP(ISD_SRA_PARTS, ISD::SRA_PARTS),
  MAP(ISD_SRL_PARTS, ISD::SRL_PARTS),
  MAP(ISD_SIGN_EXTEND, ISD::SIGN_EXTEND),
  MAP(ISD_ZERO_EXTEND, ISD::ZERO_EXTEND),
  MAP(ISD_ANY_EXTEND, ISD::ANY_EXTEND),
  MAP(ISD_TRUNCATE, ISD::TRUNCATE),
  MAP(ISD_SINT_TO_FP, ISD::SINT_TO_FP),
  MAP(ISD_UINT_TO_FP, ISD::UINT_TO_FP),
  MAP(ISD_SIGN_EXTEND_INREG, ISD::SIGN_EXTEND_INREG),
  MAP(ISD_ANY_EXTEND_VECTOR_INREG, ISD::ANY_EXTEND_VECTOR_INREG),
  MAP(ISD_SIGN_EXTEND_VECTOR_INREG, ISD::SIGN_EXTEND_VECTOR_INREG),
  MAP(ISD_ZERO_EXTEND_VECTOR_INREG, ISD::ZERO_EXTEND_VECTOR_INREG),
  MAP(ISD_FP_TO_SINT, ISD::FP_TO_SINT),
  MAP(ISD_FP_TO_UINT, ISD::FP_TO_UINT),
  MAP(ISD_FP_ROUND, ISD::FP_ROUND),
  MAP(ISD_FLT_ROUNDS_, ISD::FLT_ROUNDS_),
  MAP(ISD_FP_EXTEND, ISD::FP_EXTEND),
  MAP(ISD_BITCAST, ISD::BITCAST),
  MAP(ISD_ADDRSPACECAST, ISD::ADDRSPACECAST),
  MAP(ISD_FP16_TO_FP, ISD::FP16_TO_FP),
  MAP(ISD_FP_TO_FP16, ISD::FP_TO_FP16),
  MAP(ISD_STRICT_FP16_TO_FP, ISD::STRICT_FP16_TO_FP),
  MAP(ISD_STRICT_FP_TO_FP16, ISD::STRICT_FP_TO_FP16),
  MAP(ISD_FNEG, ISD::FNEG),
  MAP(ISD_FABS, ISD::FABS),
  MAP(ISD_FSQRT, ISD::FSQRT),
  MAP(ISD_FCBRT, ISD::FCBRT),
  MAP(ISD_FSIN, ISD::FSIN),
  MAP(ISD_FCOS, ISD::FCOS),
  MAP(ISD_FPOWI, ISD::FPOWI),
  MAP(ISD_FPOW, ISD::FPOW),
  MAP(ISD_FLOG, ISD::FLOG),
  MAP(ISD_FLOG2, ISD::FLOG2),
  MAP(ISD_FLOG10, ISD::FLOG10),
  MAP(ISD_FEXP, ISD::FEXP),
  MAP(ISD_FEXP2, ISD::FEXP2),
  MAP(ISD_FCEIL, ISD::FCEIL),
  MAP(ISD_FTRUNC, ISD::FTRUNC),
  MAP(ISD_FRINT, ISD::FRINT),
  MAP(ISD_FNEARBYINT, ISD::FNEARBYINT),
  MAP(ISD_FROUND, ISD::FROUND),
  MAP(ISD_FFLOOR, ISD::FFLOOR),
  MAP(ISD_LROUND, ISD::LROUND),
  MAP(ISD_LLROUND, ISD::LLROUND),
  MAP(ISD_LRINT, ISD::LRINT),
  MAP(ISD_LLRINT, ISD::LLRINT),
  MAP(ISD_FMINNUM, ISD::FMINNUM),
  MAP(ISD_FMAXNUM, ISD::FMAXNUM),
  MAP(ISD_FMINNUM_IEEE, ISD::FMINNUM_IEEE),
  MAP(ISD_FMAXNUM_IEEE, ISD::FMAXNUM_IEEE),
  MAP(ISD_FMINIMUM, ISD::FMINIMUM),
  MAP(ISD_FMAXIMUM, ISD::FMAXIMUM),
  MAP(ISD_FSINCOS, ISD::FSINCOS),
  MAP(ISD_LOAD, ISD::LOAD),
  MAP(ISD_STORE, ISD::STORE),
  MAP(ISD_DYNAMIC_STACKALLOC, ISD::DYNAMIC_STACKALLOC),
  MAP(ISD_BR, ISD::BR),
  MAP(ISD_BRIND, ISD::BRIND),
  MAP(ISD_BR_JT, ISD::BR_JT),
  MAP(ISD_BRCOND, ISD::BRCOND),
  MAP(ISD_BR_CC, ISD::BR_CC),
  MAP(ISD_INLINEASM, ISD::INLINEASM),
  MAP(ISD_INLINEASM_BR, ISD::INLINEASM_BR),
  MAP(ISD_EH_LABEL, ISD::EH_LABEL),
  MAP(ISD_ANNOTATION_LABEL, ISD::ANNOTATION_LABEL),
  MAP(ISD_CATCHRET, ISD::CATCHRET),
  MAP(ISD_CLEANUPRET, ISD::CLEANUPRET),
  MAP(ISD_STACKSAVE, ISD::STACKSAVE),
  MAP(ISD_STACKRESTORE, ISD::STACKRESTORE),
  MAP(ISD_VAARG, ISD::VAARG),
  MAP(ISD_VACOPY, ISD::VACOPY),
  MAP(ISD_VAEND, ISD::VAEND),
  MAP(ISD_VASTART, ISD::VASTART),
  MAP(ISD_SRCVALUE, ISD::SRCVALUE),
  MAP(ISD_MDNODE_SDNODE, ISD::MDNODE_SDNODE),
  MAP(ISD_PCMARKER, ISD::PCMARKER),
  MAP(ISD_READCYCLECOUNTER, ISD::READCYCLECOUNTER),
  MAP(ISD_HANDLENODE, ISD::HANDLENODE),
  MAP(ISD_INIT_TRAMPOLINE, ISD::INIT_TRAMPOLINE),
  MAP(ISD_ADJUST_TRAMPOLINE, ISD::ADJUST_TRAMPOLINE),
  MAP(ISD_TRAP, ISD::TRAP),
  MAP(ISD_DEBUGTRAP, ISD::DEBUGTRAP),
  MAP(ISD_PREFETCH, ISD::PREFETCH),
  MAP(ISD_ATOMIC_FENCE, ISD::ATOMIC_FENCE),
  MAP(ISD_ATOMIC_LOAD, ISD::ATOMIC_LOAD),
  MAP(ISD_ATOMIC_STORE, ISD::ATOMIC_STORE),
  MAP(ISD_ATOMIC_CMP_SWAP, ISD::ATOMIC_CMP_SWAP),
  MAP(ISD_ATOMIC_CMP_SWAP_WITH_SUCCESS, ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS),
  MAP(ISD_ATOMIC_SWAP, ISD::ATOMIC_SWAP),
  MAP(ISD_ATOMIC_LOAD_ADD, ISD::ATOMIC_LOAD_ADD),
  MAP(ISD_ATOMIC_LOAD_SUB, ISD::ATOMIC_LOAD_SUB),
  MAP(ISD_ATOMIC_LOAD_AND, ISD::ATOMIC_LOAD_AND),
  MAP(ISD_ATOMIC_LOAD_CLR, ISD::ATOMIC_LOAD_CLR),
  MAP(ISD_ATOMIC_LOAD_OR, ISD::ATOMIC_LOAD_OR),
  MAP(ISD_ATOMIC_LOAD_XOR, ISD::ATOMIC_LOAD_XOR),
  MAP(ISD_ATOMIC_LOAD_NAND, ISD::ATOMIC_LOAD_NAND),
  MAP(ISD_ATOMIC_LOAD_MIN, ISD::ATOMIC_LOAD_MIN),
  MAP(ISD_ATOMIC_LOAD_MAX, ISD::ATOMIC_LOAD_MAX),
  MAP(ISD_ATOMIC_LOAD_UMIN, ISD::ATOMIC_LOAD_UMIN),
  MAP(ISD_ATOMIC_LOAD_UMAX, ISD::ATOMIC_LOAD_UMAX),
  MAP(ISD_ATOMIC_LOAD_FADD, ISD::ATOMIC_LOAD_FADD),
  MAP(ISD_ATOMIC_LOAD_FSUB, ISD::ATOMIC_LOAD_FSUB),
  MAP(ISD_MLOAD, ISD::MLOAD),
  MAP(ISD_MSTORE, ISD::MSTORE),
  MAP(ISD_MGATHER, ISD::MGATHER),
  MAP(ISD_MSCATTER, ISD::MSCATTER),
  MAP(ISD_LIFETIME_START, ISD::LIFETIME_START),
  MAP(ISD_LIFETIME_END, ISD::LIFETIME_END),
  MAP(ISD_GC_TRANSITION_START, ISD::GC_TRANSITION_START),
  MAP(ISD_GC_TRANSITION_END, ISD::GC_TRANSITION_END),
  MAP(ISD_GET_DYNAMIC_AREA_OFFSET, ISD::GET_DYNAMIC_AREA_OFFSET),
  MAP(ISD_VSCALE, ISD::VSCALE),
  MAP(ISD_VECREDUCE_SEQ_FADD, ISD::VECREDUCE_SEQ_FADD),
  MAP(ISD_VECREDUCE_SEQ_FMUL, ISD::VECREDUCE_SEQ_FMUL),
  MAP(ISD_VECREDUCE_FADD, ISD::VECREDUCE_FADD),
  MAP(ISD_VECREDUCE_FMUL, ISD::VECREDUCE_FMUL),
  MAP(ISD_VECREDUCE_FMAX, ISD::VECREDUCE_FMAX),
  MAP(ISD_VECREDUCE_FMIN, ISD::VECREDUCE_FMIN),
  MAP(ISD_VECREDUCE_ADD, ISD::VECREDUCE_ADD),
  MAP(ISD_VECREDUCE_MUL, ISD::VECREDUCE_MUL),
  MAP(ISD_VECREDUCE_AND, ISD::VECREDUCE_AND),
  MAP(ISD_VECREDUCE_OR, ISD::VECREDUCE_OR),
  MAP(ISD_VECREDUCE_XOR, ISD::VECREDUCE_XOR),
  MAP(ISD_VECREDUCE_SMAX, ISD::VECREDUCE_SMAX),
  MAP(ISD_VECREDUCE_SMIN, ISD::VECREDUCE_SMIN),
  MAP(ISD_VECREDUCE_UMAX, ISD::VECREDUCE_UMAX),
  MAP(ISD_VECREDUCE_UMIN, ISD::VECREDUCE_UMIN),
  MAP(ISD_BUILTIN_OP_END, ISD::BUILTIN_OP_END),
};
#undef MAP

int main(int argc, char *argv[]) {

  if (argc > 1) {
    int ret = 0;
    for (int i = 1; i < argc; i++) {
      auto Mapping = ISDNameConstantMapping.find(argv[i]);
      if (Mapping == ISDNameConstantMapping.end()) {
        std::cerr << "No ISD node named " << argv[i] << " exists" << std::endl;
        ret = 1;
        continue;
      }
      StringRef VarName;
      int ISDValue;
      std::tie(VarName, ISDValue) = Mapping->getValue();
      std::cout << "extern constexpr unsigned " << VarName.str() << " = "
                << ISDValue << ';' << std::endl;
    }
    return ret;
  }

  for (auto &Mapping : ISDNameConstantMapping) {
    StringRef VarName;
    int ISDValue;
    std::tie(VarName, ISDValue) = Mapping.getValue();
    std::cout << "extern constexpr unsigned " << VarName.str() << " = "
              << ISDValue << ';' << std::endl;
  }

  return 0;
}