Index: CMakeLists.txt =================================================================== --- CMakeLists.txt +++ CMakeLists.txt @@ -321,6 +321,7 @@ AMDGPU ARM BPF + Connex Hexagon Lanai Mips Index: include/llvm/ADT/Triple.h =================================================================== --- include/llvm/ADT/Triple.h +++ include/llvm/ADT/Triple.h @@ -53,6 +53,7 @@ avr, // AVR: Atmel AVR microcontroller bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) + connex, // Connex vector processor hexagon, // Hexagon: hexagon mips, // MIPS: mips, mipsallegrex, mipsr6 mipsel, // MIPSEL: mipsel, mipsallegrexe, mipsr6el Index: include/llvm/CodeGen/SelectionDAG.h =================================================================== --- include/llvm/CodeGen/SelectionDAG.h +++ include/llvm/CodeGen/SelectionDAG.h @@ -270,6 +270,12 @@ uint16_t NextPersistentId = 0; public: + DenseMap *crtNodeMapPtr; + + void SetNodeMap(DenseMap *aCrtNodeMapPtr); + + void UpdateNodeMapSDValue(SDNode *oldSDN, SDValue &newSDV); + /// Clients of various APIs that cause global effects on /// the DAG can optionally implement this interface. This allows the clients /// to handle the various sorts of updates that happen. @@ -1217,6 +1223,12 @@ MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT, SDValue Op1, SDValue Op2, SDValue Op3); MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT, + SDValue Op1, SDValue Op2, + SDValue Op3, SDValue Op4); + MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1, + EVT VT2, SDValue Op1, SDValue Op2, + SDValue Op3, SDValue Op4); + MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT, ArrayRef Ops); MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1, EVT VT2, SDValue Op1, SDValue Op2); Index: include/llvm/CodeGen/SelectionDAGISel.h =================================================================== --- include/llvm/CodeGen/SelectionDAGISel.h +++ include/llvm/CodeGen/SelectionDAGISel.h @@ -56,6 +56,7 @@ const TargetLowering *TLI; bool FastISelFailed; SmallPtrSet ElidedArgCopyInstrs; + DenseMap crtNodeMap; /// Current optimization remark emitter. /// Used to report things like combines and FastISel failures. Index: include/llvm/IR/Intrinsics.td =================================================================== --- include/llvm/IR/Intrinsics.td +++ include/llvm/IR/Intrinsics.td @@ -1182,6 +1182,7 @@ include "llvm/IR/IntrinsicsMips.td" include "llvm/IR/IntrinsicsAMDGPU.td" include "llvm/IR/IntrinsicsBPF.td" +include "llvm/IR/IntrinsicsConnex.td" include "llvm/IR/IntrinsicsSystemZ.td" include "llvm/IR/IntrinsicsWebAssembly.td" include "llvm/IR/IntrinsicsRISCV.td" Index: include/llvm/IR/IntrinsicsConnex.td =================================================================== --- include/llvm/IR/IntrinsicsConnex.td +++ include/llvm/IR/IntrinsicsConnex.td @@ -0,0 +1,106 @@ +//===- IntrinsicsConnex.td - Defines Connex-S intrinsics ---*- tablegen -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines all of the Connex-specific intrinsics. +// +//===----------------------------------------------------------------------===// + +// All Connex-S vector processor intrinsics start with "llvm.connex." +// +let TargetPrefix = "connex" in { + + /* + * Note: all intrinsics defined in these .td files start with + * the int_ prefix (from intrinsic). For this file they start with + * int_connex prefix - otherwise we get the following TableGen error + * <> + * + * The LLVM IR intrinsics extend the LLVM language s.t. we can use + * these instructions in an LLVM IR program. We also need to define the + * corresponding assembly instructions in the back end TableGen files. + */ + + /* Alex: following Intrinsics.td: + class Intrinsic ret_types, + list param_types = [], + list properties = [], + string name = ""> + */ + + + /* Small-note: + llvm_i64_ty makes simpler my LLVM IR generation in the LoopVectorize.cpp + module: + def int_connex_repeat_x_times : Intrinsic<[], [llvm_i64_ty], []>; + But llvm_i32_ty is in accordance to the original i32 type of n.vec in the + LoopVectorize.cpp module: + def int_connex_repeat_x_times : Intrinsic<[], [llvm_i32_ty], []>; + + Small-note: We get inspired from include/llvm/IR/IntrinsicsPowerPC.td: + // Intrinsics used to generate ctrl-based loops. + def int_ppc_mtctr : Intrinsic<[], [llvm_anyint_ty], []>; + + Small-note: Trying to use a polymorphic definition, which requires + specifying the actual type in Function::Create(FunctionType::get(), ...) + is: + def int_connex_repeat_x_times : Intrinsic<[], [llvm_anyint_ty], []>; + When instantiating it in LoopVectorize.cpp like this: + Value *instrinsicFunc = Intrinsic::getDeclaration(M, + Intrinsic::connex_repeat_x_times); + it gives error at runtime: + llvm::ArrayRef::operator[](size_t) const [with T = llvm::Type*; + size_t = long unsigned int]: Assertion `Index < Length && + "Invalid index!"' failed. + */ + def int_connex_repeat_x_times : Intrinsic<[], [llvm_i64_ty], []>; + def int_connex_end_repeat : Intrinsic<[], [], []>; + + /* Note: Possibly useful in the future. + Connex Opincaa's END_REPEAT does not have a relative offset, + as the standard Connex assembly ijmpnzdec instruction, + since it falls on Opincaa to compute the jump back relative offset. + We can also use a setlc to position it outside the loop created by the + ijmpnzdec instruction by using it inside a delay-slot instruction. + + def int_connex_setlc : Intrinsic<[], [llvm_i16_ty], []>; + def int_connex_ijmpnzdec : Intrinsic<[], [], []>; + */ + + + + /* IMPORTANT: REDUCE cannot return a value. It is the duty of the host (CPU) + to read the result itself from the REDUCE issued by Connex-S. + Therefore this definition is incorrect: + def int_connex_reduce : Intrinsic<[llvm_i32_ty], [llvm_v128i16_ty], []>; + */ + /* GOOD: + def int_connex_reduce : Intrinsic<[], [llvm_v128i16_ty], []>; + def int_connex_reduce_i32 : Intrinsic<[], [llvm_v64i32_ty], []>; + def int_connex_reduce_f16 : Intrinsic<[], [llvm_v128f16_ty], []>; + */ + def int_connex_reduce : Intrinsic<[], [llvm_anyvector_ty], []>; + + /* Note: ctpop is already defined in Intrinsics.td. + So the below definition is not required: + def int_connex_ctpop : Intrinsic<[llvm_v8i16_ty], + [llvm_v8i16_ty], []>; + */ + + + // Inherited BPF scalar intrinsics: Specialized loads from packet + def int_connex_load_byte : GCCBuiltin<"__builtin_connex_load_byte">, + Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>; + def int_connex_load_half : GCCBuiltin<"__builtin_connex_load_half">, + Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>; + def int_connex_load_word : GCCBuiltin<"__builtin_connex_load_word">, + Intrinsic<[llvm_i64_ty], [llvm_ptr_ty, llvm_i64_ty], [IntrReadMem]>; + def int_connex_pseudo : GCCBuiltin<"__builtin_connex_pseudo">, + Intrinsic<[llvm_i64_ty], [llvm_i64_ty, llvm_i64_ty]>; +} + Index: lib/CodeGen/SelectionDAG/DAGCombiner.cpp =================================================================== --- lib/CodeGen/SelectionDAG/DAGCombiner.cpp +++ lib/CodeGen/SelectionDAG/DAGCombiner.cpp @@ -1469,6 +1469,9 @@ LLVM_DEBUG(dbgs() << " ... into: "; RV.getNode()->dump(&DAG)); + // Replacing SDNode N with RV in crtNodeMap + DAG.UpdateNodeMapSDValue(N, RV); + if (N->getNumValues() == RV.getNode()->getNumValues()) DAG.ReplaceAllUsesWith(N, RV.getNode()); else { Index: lib/CodeGen/SelectionDAG/SelectionDAG.cpp =================================================================== --- lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -82,6 +82,33 @@ return Res; } +void SelectionDAG::SetNodeMap(DenseMap *aCrtNodeMapPtr) { + crtNodeMapPtr = aCrtNodeMapPtr; +} + +void SelectionDAG::UpdateNodeMapSDValue(SDNode *oldSDN, SDValue &newSDV) { + /* NOTE: SelectionDAGBuilder defines DenseMap NodeMap. + * I added in SelectionDAGISel a copy of it, crtNodeMap. + * The pointer crtNodeMapPtr here is the pointer of crtNodeMap + * initialized in SelectionDAGISel::CodeGenAndEmitDAG(). + */ + for (auto iterNodeMap = crtNodeMapPtr->begin(); + iterNodeMap != crtNodeMapPtr->end(); iterNodeMap++) { + auto tmp1 = (*iterNodeMap); + + const Value *crtValue = (const Value *)(tmp1.first); + + SDValue crtSDValue = tmp1.second; + SDNode *crtSDNode = crtSDValue.getNode(); + + if (crtSDNode == oldSDN) { + (*crtNodeMapPtr)[crtValue] = newSDV; + break; + } + } +} + + // Default null implementations of the callbacks. void SelectionDAG::DAGUpdateListener::NodeDeleted(SDNode*, SDNode*) {} void SelectionDAG::DAGUpdateListener::NodeUpdated(SDNode*) {} @@ -7803,6 +7830,24 @@ } MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl, + EVT VT, + SDValue Op1, SDValue Op2, + SDValue Op3, SDValue Op4) { + SDVTList VTs = getVTList(VT); + SDValue Ops[] = { Op1, Op2, Op3, Op4 }; + return getMachineNode(Opcode, dl, VTs, Ops); +} + +MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl, + EVT VT1, EVT VT2, + SDValue Op1, SDValue Op2, + SDValue Op3, SDValue Op4) { + SDVTList VTs = getVTList(VT1, VT2); + SDValue Ops[] = { Op1, Op2, Op3, Op4 }; + return getMachineNode(Opcode, dl, VTs, Ops); +} + +MachineSDNode *SelectionDAG::getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1, EVT VT2, EVT VT3, ArrayRef Ops) { SDVTList VTs = getVTList(VT1, VT2, VT3); Index: lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h =================================================================== --- lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h +++ lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h @@ -38,6 +38,7 @@ #include #include #include +#include "llvm/Support/Debug.h" namespace llvm { @@ -125,6 +126,11 @@ MapVector DanglingDebugInfoMap; public: + // Add a getter for NodeMap + DenseMap &getNodeMap() { + return NodeMap; + } + /// Loads are not emitted to the program immediately. We bunch them up and /// then emit token factor nodes when possible. This allows us to get simple /// disambiguation between loads without worrying about alias analysis. Index: lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp =================================================================== --- lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -9090,8 +9090,15 @@ void TargetLowering::LowerOperationWrapper(SDNode *N, SmallVectorImpl &Results, SelectionDAG &DAG) const { - if (SDValue Res = LowerOperation(SDValue(N, 0), DAG)) - Results.push_back(Res); + SDValue Res1 = LowerOperation(SDValue(N, 0), DAG); + if (Res1.getNode()) + Results.push_back(Res1); + + if (N->getNumValues() > 1) { + SDValue Res2 = LowerOperation(SDValue(N, 1), DAG); + if (Res2.getNode()) + Results.push_back(Res2); + } } SDValue TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const { Index: lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp =================================================================== --- lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -692,6 +692,9 @@ CurDAG->setRoot(SDB->getControlRoot()); HadTailCall = SDB->HasTailCall; SDB->resolveOrClearDbgInfo(); + + crtNodeMap = SDB->getNodeMap(); + SDB->clear(); // Final step, emit the lowered DAG as machine code. @@ -778,6 +781,9 @@ // Run the DAG combiner in pre-legalize mode. { + // We should do this only once + CurDAG->SetNodeMap(&crtNodeMap); + NamedRegionTimer T("combine1", "DAG Combining 1", GroupName, GroupDescription, TimePassesIsEnabled); CurDAG->Combine(BeforeLegalizeTypes, AA, OptLevel); Index: lib/Target/Connex/Connex.h =================================================================== --- lib/Target/Connex/Connex.h +++ lib/Target/Connex/Connex.h @@ -0,0 +1,31 @@ +//===-- Connex.h - Top-level interface for Connex representation ------*- 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 +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIB_TARGET_CONNEX_CONNEX_H +#define LLVM_LIB_TARGET_CONNEX_CONNEX_H + +#include "MCTargetDesc/ConnexMCTargetDesc.h" +#include "llvm/Target/TargetMachine.h" + + +// We define reserved register(s) of Connex to use for: +// - handling COPY instructions in WHERE blocks +// (see ConnexTargetMachine.cpp and ConnexISelLowering.cpp), etc +#define CONNEX_RESERVED_REGISTER_01 Connex::Wh30 +#define CONNEX_RESERVED_REGISTER_02 Connex::Wh31 +#define CONNEX_RESERVED_REGISTER_03 Connex::Wh29 + +#define COPY_REGISTER_IMPLEMENTED_WITH_ORV_H + +namespace llvm { +class ConnexTargetMachine; + +FunctionPass *createConnexISelDag(ConnexTargetMachine &TM); +} + +#endif Index: lib/Target/Connex/ConnexConfig.h =================================================================== --- lib/Target/Connex/ConnexConfig.h +++ lib/Target/Connex/ConnexConfig.h @@ -0,0 +1,68 @@ +#ifndef CONNEX_CONFIG_ALEX +#define CONNEX_CONFIG_ALEX + +// This file is used by... TODO TODO TODO + +// These 2 types are defined also in Opincaa lib, in include/Architecture.h +typedef short TypeElement; +typedef unsigned short UnsignedTypeElement; + + +#define CONNEX_VECTOR_LENGTH 8 +#define TYPE_SIZEOF 2 +#define CONNEX_LINE_SIZE (CONNEX_VECTOR_LENGTH * TYPE_SIZEOF) + +//#define STR_LOOP_SYMBOLIC_INDEX "indexLLVM_LV / CONNEX_VECTOR_LENGTH" +// NOTE: make sure it is equiavlent to the above commented macro +// NOTE: keep the paranthesis since >> has low operator priority +#define STR_LOOP_SYMBOLIC_INDEX "(indexLLVM_LV >> 7)" + +// This is the type of the scalar processor (basically the BPF processor) operand +// TODO_CHANGE_BACKEND: +#define TYPE_ELEMENT MVT::i64 +//#define TYPE_ELEMENT MVT::i32 + +//#define TYPE_VECTOR MVT::v8i64 +//#define TYPE_VECTOR MVT::v16i32 +//#define TYPE_VECTOR MVT::v32i16 +//#define TYPE_VECTOR_I16 MVT::v128i16 +#define TYPE_VECTOR_I16 MVT::v8i16 +//#define TYPE_VECTOR_ELEMENT MVT::i64 +#define TYPE_VECTOR_I16_ELEMENT MVT::i16 + +//#define TYPE_VECTOR_I32 MVT::v64i32 +#define TYPE_VECTOR_I32 MVT::v4i32 +#define TYPE_VECTOR_I32_ELEMENT MVT::i32 + +//#define TYPE_VECTOR_F16 MVT::v128f16 +#define TYPE_VECTOR_F16 MVT::v8f16 +#define TYPE_VECTOR_F16_ELEMENT MVT::f16 + + +#define TYPE_VECTOR_I16_ELEMENT_BITSIZE 16 +#define TYPE_VECTOR_I32_ELEMENT_BITSIZE 32 +#define TYPE_VECTOR_F16_ELEMENT_BITSIZE 16 + + +//#define CONNEX_MEM_SIZE 1024 +#define CONNEX_MEM_NUM_ROWS 1024 +// Extra LS memory for spills and LUTs for div/sqrt.f16, etc +#define CONNEX_MEM_NUM_ROWS_EXTRA 200 +// For 64 lanes: #define CONNEX_MEM_NUM_ROWS 2048 + +// NOTE: normally REPEAT accepts immediates in interval 0..1023 +#define VALUE_BOGUS_REPEAT_X_TIMES 32761 + + +//#ifndef MAXLEN_STR +#define MAXLEN_STR 8192 +//#endif + +// Used in ConnexAsmPrinter.cpp and LoopVectorize.cpp +#define STR_OPINCAA_CODE_BEGIN "// START_OPINCAA_HOST_DEVICE_CODE" +#define STR_OPINCAA_CODE_END "// END_OPINCAA_HOST_DEVICE_CODE" + +#define STR_OPINCAA_KERNEL_REDUCE_BEFORE_END "REDUCE R(0); // We add a 'bogus' REDUCE to wait for it" + +#endif + Index: lib/Target/Connex/ConnexSubtarget.h =================================================================== --- lib/Target/Connex/ConnexSubtarget.h +++ lib/Target/Connex/ConnexSubtarget.h @@ -0,0 +1,71 @@ +//===-- ConnexSubtarget.h - Define Subtarget for the Connex -----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file declares the Connex specific subclass of TargetSubtargetInfo. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIB_TARGET_CONNEX_CONNEXSUBTARGET_H +#define LLVM_LIB_TARGET_CONNEX_CONNEXSUBTARGET_H + +#include "ConnexFrameLowering.h" +#include "ConnexISelLowering.h" +#include "ConnexInstrInfo.h" +#include "ConnexSelectionDAGInfo.h" + +#include "llvm/CodeGen/SelectionDAGTargetInfo.h" +#include "llvm/CodeGen/TargetSubtargetInfo.h" +#include "llvm/IR/DataLayout.h" +#include "llvm/Target/TargetMachine.h" + +#define GET_SUBTARGETINFO_HEADER +#include "ConnexGenSubtargetInfo.inc" + +namespace llvm { +class StringRef; + +class ConnexSubtarget : public ConnexGenSubtargetInfo { + virtual void anchor(); + ConnexInstrInfo InstrInfo; + ConnexFrameLowering FrameLowering; + ConnexTargetLowering TLInfo; + + SelectionDAGTargetInfo TSInfo; + ConnexSelectionDAGInfo TSInfo2; + +public: + // This constructor initializes the data members to match that + // of the specified triple. + ConnexSubtarget(const Triple &TT, const std::string &CPU, const std::string &FS, + const TargetMachine &TM); + + // ParseSubtargetFeatures - Parses features string setting specified + // subtarget options. Definition of function is auto generated by tblgen. + void ParseSubtargetFeatures(StringRef CPU, StringRef FS); + + const ConnexInstrInfo *getInstrInfo() const override { return &InstrInfo; } + const ConnexFrameLowering *getFrameLowering() const override { + return &FrameLowering; + } + const ConnexTargetLowering *getTargetLowering() const override { + return &TLInfo; + } + + const TargetRegisterInfo *getRegisterInfo() const override { + return &InstrInfo.getRegisterInfo(); + } + + // Inspired from ARM/ARMSubtarget.cpp + const ConnexSelectionDAGInfo *getSelectionDAGInfo() const override { + return &TSInfo2; + } +}; +} // End llvm namespace + +#endif Index: lib/Target/Connex/ConnexTargetMachine.h =================================================================== --- lib/Target/Connex/ConnexTargetMachine.h +++ lib/Target/Connex/ConnexTargetMachine.h @@ -0,0 +1,54 @@ +//===-- ConnexTargetMachine.h - Define TargetMachine for Connex --- C++ ---===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file declares the Connex specific subclass of TargetMachine. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIB_TARGET_CONNEX_CONNEXTARGETMACHINE_H +#define LLVM_LIB_TARGET_CONNEX_CONNEXTARGETMACHINE_H + +#include "ConnexSubtarget.h" +// 2019_03_30 +#include "llvm/ADT/Optional.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/Support/CodeGen.h" +#include "llvm/Target/TargetMachine.h" // This was before +#include +// END 2019_03_30 + +namespace llvm { +class ConnexTargetMachine : public LLVMTargetMachine { + std::unique_ptr TLOF; + ConnexSubtarget Subtarget; + +public: + ConnexTargetMachine(const Target &T, const Triple &TT, StringRef CPU, + StringRef FS, const TargetOptions &Options, + Optional RM, Optional CM, + CodeGenOpt::Level OL, bool JIT); + + const ConnexSubtarget *getSubtargetImpl() const { return &Subtarget; } + const ConnexSubtarget *getSubtargetImpl(const Function &) const override { + return &Subtarget; + } + + TargetPassConfig *createPassConfig(PassManagerBase &PM) override; + + // 2019_03_30: Inspired from ARC/ARCTargetMachine.h + TargetTransformInfo getTargetTransformInfo(const Function &F) override; + + TargetLoweringObjectFile *getObjFileLowering() const override { + return TLOF.get(); + } +}; +} + +#endif Index: lib/Target/Connex/LLVMBuild.txt =================================================================== --- lib/Target/Connex/LLVMBuild.txt +++ lib/Target/Connex/LLVMBuild.txt @@ -0,0 +1,43 @@ +;===- ./lib/Target/Connex/LLVMBuild.txt ---------------------------*- Conf -*--===; +; +; The LLVM Compiler Infrastructure +; +; This file is distributed under the University of Illinois Open Source +; License. See LICENSE.TXT for details. +; +;===------------------------------------------------------------------------===; +; +; This is an LLVMBuild description file for the components in this subdirectory. +; +; For more information on the LLVMBuild system, please see: +; +; http://llvm.org/docs/LLVMBuild.html +; +;===------------------------------------------------------------------------===; + +[common] +subdirectories = InstPrinter MCTargetDesc TargetInfo + +[component_0] +type = TargetGroup +name = Connex +parent = Target +has_asmprinter = 1 + +[component_1] +type = Library +name = ConnexCodeGen +parent = Connex +required_libraries = + Analysis + AsmPrinter + CodeGen + Core + MC + ConnexAsmPrinter + ConnexDesc + ConnexInfo + SelectionDAG + Support + Target +add_to_library_groups = Connex Index: lib/Target/Connex/Makefile =================================================================== --- lib/Target/Connex/Makefile +++ lib/Target/Connex/Makefile @@ -0,0 +1,21 @@ +##===- lib/Target/Connex/Makefile -----------------------------*- Makefile -*-===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + +LEVEL = ../../.. +LIBRARYNAME = LLVMConnexCodeGen +TARGET = Connex + +# Make sure that tblgen is run, first thing. +BUILT_SOURCES = ConnexGenRegisterInfo.inc ConnexGenInstrInfo.inc \ + ConnexGenAsmWriter.inc ConnexGenAsmMatcher.inc ConnexGenDAGISel.inc \ + ConnexGenMCCodeEmitter.inc ConnexGenSubtargetInfo.inc ConnexGenCallingConv.inc + +DIRS = InstPrinter TargetInfo MCTargetDesc + +include $(LEVEL)/Makefile.common Index: lib/Target/Connex/Select_ADDf16_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_ADDf16_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_ADDf16_OpincaaCodeGen.cpp @@ -0,0 +1,3625 @@ +// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/ADD_SUB_f16_manual/DumpISel_OpincaaCodeGen_old36_C00_ADDf16.cpp + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: add_or_sub.f16. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 279. + + + + +SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R14 = 1; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast1, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #2 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +SDValue ct3 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R29 = 16; +// Instr #3 +SDNode *vload3 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +SDValue ct4 = CurDAG->getConstant(31, DL, MVT::i16, true, false); +// R28 = 31; +// Instr #4 +SDNode *vload4 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(vload3, 1) + ); + +SDValue ct5 = CurDAG->getConstant(1023, DL, MVT::i16, true, false); +// R13 = 1023; +// Instr #5 +SDNode *vload5 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct5, + // glue (or chain) input edge + SDValue(vload4, 1) + ); + +SDValue ct6 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R12 = 31744; +// Instr #6 +SDNode *vload6 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct6, + // glue (or chain) input edge + SDValue(vload5, 1) + ); + +SDValue ct7 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false); +// R11 = -32768; +// Instr #7 +SDNode *vload7 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct7, + // glue (or chain) input edge + SDValue(vload6, 1) + ); + +SDValue ct8 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R10 = 1024; +// Instr #8 +SDNode *vload8 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct8, + // glue (or chain) input edge + SDValue(vload7, 1) + ); + +SDValue ct9 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = 0; +// Instr #9 +SDNode *vload9 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct9, + // glue (or chain) input edge + SDValue(vload8, 1) + ); + +SDValue ct10 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R19 = 0; +// Instr #10 +SDNode *vload10 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct10, + // glue (or chain) input edge + SDValue(vload9, 1) + ); + +SDValue ct11 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = 0; +// Instr #11 +SDNode *vload11 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct11, + // glue (or chain) input edge + SDValue(vload10, 1) + ); + +SDValue ct12 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R61 = 0; +// Instr #12 +SDNode *vload12 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct12, + // glue (or chain) input edge + SDValue(vload11, 1) + ); + +SDValue ct13 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R07 = 0; +// Instr #13 +SDNode *vload13 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct13, + // glue (or chain) input edge + SDValue(vload12, 1) + ); + +SDValue ct14 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R04 = 0; +// Instr #14 +SDNode *vload14 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct14, + // glue (or chain) input edge + SDValue(vload13, 1) + ); + +SDValue ct15 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R03 = 0; +// Instr #15 +SDNode *vload15 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct15, + // glue (or chain) input edge + SDValue(vload14, 1) + ); + +SDValue ct16 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R02 = 0; +// Instr #16 +SDNode *vload16 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct16, + // glue (or chain) input edge + SDValue(vload15, 1) + ); + +SDValue ct17 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R01 = 0; +// Instr #17 +SDNode *vload17 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct17, + // glue (or chain) input edge + SDValue(vload16, 1) + ); + +SDValue ct18 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R00 = 0; +// Instr #18 +SDNode *vload18 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct18, + // glue (or chain) input edge + SDValue(vload17, 1) + ); + +// R24 = R27 & R11; +// Instr #19 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(vload18, 1) + ); + +// R25 = R27 & R12; +// Instr #20 +SDNode *and1 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct19 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R25 = R25 >> 10; +// Instr #21 +SDNode *ishr0 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and1, 0), + ct19, + // glue (or chain) input edge + SDValue(and1, 1) + ); + +// R26 = R27 & R13; +// Instr #22 +SDNode *and2 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(ishr0, 1) + ); + +// R18 = R31 < R26; +// Instr #23 +SDNode *lt0 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(and2, 1) + ); + +// R17 = R25 == R31; +// Instr #24 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr0, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(lt0, 1) + ); + +// R09 = R17 & R18; +// Instr #25 +SDNode *and3 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt0, 0), + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// R09 = R09 == R30; +// Instr #26 +SDNode *eq1 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and3, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and3, 1) + ); + +SDValue ct20 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #27 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct20, + // glue (or chain) input edge + SDValue(eq1, 1) + ); + +// WHERE_EQ; +// Instr #28 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq1, 0), + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +SDValue ct21 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R25 = 1; +// Instr #29 +SDNode *vload19 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct21, + SDValue(ishr0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// END_WHERE; +// Instr #30 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload19, 1) + ); + +// R18 = R25 == R28; +// Instr #31 +SDNode *eq2 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload19, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +// R18 = R18 | R17; +// Instr #32 +SDNode *or0 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + SDValue(eq2, 0), + // glue (or chain) input edge + SDValue(eq2, 1) + ); + +// R18 = R18 == R31; +// Instr #33 +SDNode *eq3 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or0, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(or0, 1) + ); + +SDValue ct22 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #34 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct22, + // glue (or chain) input edge + SDValue(eq3, 1) + ); + +// WHERE_EQ; +// Instr #35 +SDNode *whereeq1 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq3, 0), + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R26 = R26 | R10; +// Instr #36 +SDNode *or1 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload8, 0), + SDValue(and2, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(whereeq1, 1) + ); + +// END_WHERE; +// Instr #37 +SDNode *endwhere1 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or1, 1) + ); + +// R20 = R23 & R11; +// Instr #38 +SDNode *and4 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(endwhere1, 0) + ); + +// R21 = R23 & R12; +// Instr #39 +SDNode *and5 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(and4, 1) + ); + +SDValue ct23 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R21 = R21 >> 10; +// Instr #40 +SDNode *ishr1 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and5, 0), + ct23, + // glue (or chain) input edge + SDValue(and5, 1) + ); + +// R22 = R23 & R13; +// Instr #41 +SDNode *and6 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(ishr1, 1) + ); + +// R16 = R31 < R22; +// Instr #42 +SDNode *lt1 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(and6, 1) + ); + +// R15 = R21 == R31; +// Instr #43 +SDNode *eq4 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr1, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(lt1, 1) + ); + +// R09 = R15 & R16; +// Instr #44 +SDNode *and7 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt1, 0), + SDValue(eq4, 0), + // glue (or chain) input edge + SDValue(eq4, 1) + ); + +// R09 = R09 == R30; +// Instr #45 +SDNode *eq5 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and7, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and7, 1) + ); + +SDValue ct24 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #46 +SDNode *nop2 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct24, + // glue (or chain) input edge + SDValue(eq5, 1) + ); + +// WHERE_EQ; +// Instr #47 +SDNode *whereeq2 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq5, 0), + // glue (or chain) input edge + SDValue(nop2, 0) + ); + +SDValue ct25 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R21 = 1; +// Instr #48 +SDNode *vload20 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct25, + SDValue(ishr1, 0), + // glue (or chain) input edge + SDValue(whereeq2, 1) + ); + +// END_WHERE; +// Instr #49 +SDNode *endwhere2 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload20, 1) + ); + +// R16 = R21 == R28; +// Instr #50 +SDNode *eq6 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(endwhere2, 0) + ); + +// R16 = R16 | R15; +// Instr #51 +SDNode *or2 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq4, 0), + SDValue(eq6, 0), + // glue (or chain) input edge + SDValue(eq6, 1) + ); + +// R16 = R16 == R31; +// Instr #52 +SDNode *eq7 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or2, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(or2, 1) + ); + +SDValue ct26 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #53 +SDNode *nop3 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct26, + // glue (or chain) input edge + SDValue(eq7, 1) + ); + +// WHERE_EQ; +// Instr #54 +SDNode *whereeq3 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq7, 0), + // glue (or chain) input edge + SDValue(nop3, 0) + ); + +// R22 = R22 | R10; +// Instr #55 +SDNode *or3 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload8, 0), + SDValue(and6, 0), + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(whereeq3, 1) + ); + +// END_WHERE; +// Instr #56 +SDNode *endwhere3 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or3, 1) + ); + +// R50 = R24 == R11; +// Instr #57 +SDNode *eq8 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(endwhere3, 0) + ); + +// R49 = R25 == R28; +// Instr #58 +SDNode *eq9 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload19, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(eq8, 1) + ); + +// R48 = R26 == R31; +// Instr #59 +SDNode *eq10 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or1, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(eq9, 1) + ); + +// R47 = R20 == R11; +// Instr #60 +SDNode *eq11 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and4, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(eq10, 1) + ); + +// R46 = R21 == R28; +// Instr #61 +SDNode *eq12 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(eq11, 1) + ); + +// R45 = R22 == R31; +// Instr #62 +SDNode *eq13 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or3, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(eq12, 1) + ); + +// R07 = R49 & R46; +// Instr #63 +SDNode *and8 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + SDValue(eq9, 0), + // glue (or chain) input edge + SDValue(eq13, 1) + ); + +// R08 = R07 & R50; +// Instr #64 +SDNode *and9 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq8, 0), + SDValue(and8, 0), + // glue (or chain) input edge + SDValue(and8, 1) + ); + +// R44 = ~R47; +// Instr #65 +SDNode *not0 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq11, 0), + // glue (or chain) input edge + SDValue(and9, 1) + ); + +// R08 = R08 & R44; +// Instr #66 +SDNode *and10 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(not0, 0), + SDValue(and9, 0), + // glue (or chain) input edge + SDValue(not0, 1) + ); + +// R44 = ~R50; +// Instr #67 +SDNode *not1 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq8, 0), + // glue (or chain) input edge + SDValue(and10, 1) + ); + +// R44 = R44 & R07; +// Instr #68 +SDNode *and11 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and8, 0), + SDValue(not1, 0), + // glue (or chain) input edge + SDValue(not1, 1) + ); + +// R44 = R44 & R47; +// Instr #69 +SDNode *and12 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq11, 0), + SDValue(and11, 0), + // glue (or chain) input edge + SDValue(and11, 1) + ); + +// R08 = R08 | R44; +// Instr #70 +SDNode *or4 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and12, 0), + SDValue(and10, 0), + // glue (or chain) input edge + SDValue(and12, 1) + ); + +// R07 = ~R45; +// Instr #71 +SDNode *not2 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + // glue (or chain) input edge + SDValue(or4, 1) + ); + +// R07 = R07 & R46; +// Instr #72 +SDNode *and13 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + SDValue(not2, 0), + // glue (or chain) input edge + SDValue(not2, 1) + ); + +// R08 = R08 | R07; +// Instr #73 +SDNode *or5 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and13, 0), + SDValue(or4, 0), + // glue (or chain) input edge + SDValue(and13, 1) + ); + +// R07 = ~R48; +// Instr #74 +SDNode *not3 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq10, 0), + // glue (or chain) input edge + SDValue(or5, 1) + ); + +// R07 = R07 & R49; +// Instr #75 +SDNode *and14 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq9, 0), + SDValue(not3, 0), + // glue (or chain) input edge + SDValue(not3, 1) + ); + +// R08 = R08 | R07; +// Instr #76 +SDNode *or6 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and14, 0), + SDValue(or5, 0), + // glue (or chain) input edge + SDValue(and14, 1) + ); + +// R09 = R08 == R30; +// Instr #77 +SDNode *eq14 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or6, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(or6, 1) + ); + +SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #78 +SDNode *nop4 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct27, + // glue (or chain) input edge + SDValue(eq14, 1) + ); + +// WHERE_EQ; +// Instr #79 +SDNode *whereeq4 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq14, 0), + // glue (or chain) input edge + SDValue(nop4, 0) + ); + +SDValue ct28 = CurDAG->getConstant(31745, DL, MVT::i16, true, false); +// R19 = 31745; +// Instr #80 +SDNode *vload21 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct28, + SDValue(vload10, 0), + // glue (or chain) input edge + SDValue(whereeq4, 1) + ); + +SDValue ct29 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R14 = 0; +// Instr #81 +SDNode *vload22 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct29, + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(vload21, 1) + ); + +// END_WHERE; +// Instr #82 +SDNode *endwhere4 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload22, 1) + ); + +// R08 = R49 | R46; +// Instr #83 +SDNode *or7 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + SDValue(eq9, 0), + // glue (or chain) input edge + SDValue(endwhere4, 0) + ); + +// R09 = R08 & R14; +// Instr #84 +SDNode *and15 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload22, 0), + SDValue(or7, 0), + // glue (or chain) input edge + SDValue(or7, 1) + ); + +// R09 = R09 == R30; +// Instr #85 +SDNode *eq15 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and15, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and15, 1) + ); + +SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #86 +SDNode *nop5 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct30, + // glue (or chain) input edge + SDValue(eq15, 1) + ); + +// WHERE_EQ; +// Instr #87 +SDNode *whereeq5 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq15, 0), + // glue (or chain) input edge + SDValue(nop5, 0) + ); + +SDValue ct31 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R19 = 31744; +// Instr #88 +SDNode *vload23 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct31, + SDValue(vload21, 0), + // glue (or chain) input edge + SDValue(whereeq5, 1) + ); + +// R08 = R50 & R49; +// Instr #89 +SDNode *and16 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq9, 0), + SDValue(eq8, 0), + SDValue(or7, 0), + // glue (or chain) input edge + SDValue(vload23, 1) + ); + +// R07 = R47 & R46; +// Instr #90 +SDNode *and17 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + SDValue(eq11, 0), + SDValue(and14, 0), + // glue (or chain) input edge + SDValue(and16, 1) + ); + +// R08 = R08 | R07; +// Instr #91 +SDNode *or8 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and17, 0), + SDValue(and16, 0), + SDValue(and16, 0), + // glue (or chain) input edge + SDValue(and17, 1) + ); + +SDValue ct32 = CurDAG->getConstant(15, DL, MVT::i16, true, false); +// R08 = R08 << 15; +// Instr #92 +SDNode *ishl0 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or8, 0), + ct32, + SDValue(or8, 0), + // glue (or chain) input edge + SDValue(or8, 1) + ); + +// R19 = R19 ^ R08; +// Instr #93 +SDNode *xor0 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl0, 0), + SDValue(vload23, 0), + SDValue(vload23, 0), + // glue (or chain) input edge + SDValue(ishl0, 1) + ); + +SDValue ct33 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R14 = 0; +// Instr #94 +SDNode *vload24 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct33, + SDValue(vload22, 0), + // glue (or chain) input edge + SDValue(xor0, 1) + ); + +// END_WHERE; +// Instr #95 +SDNode *endwhere5 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload24, 1) + ); + +// R15 = R25 - R21; +// Instr #96 +SDNode *sub0 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload19, 0), + SDValue(vload20, 0), + // glue (or chain) input edge + SDValue(endwhere5, 0) + ); + +SDValue ct34 = CurDAG->getConstant(-15, DL, MVT::i16, true, false); +// R08 = -15; +// Instr #97 +SDNode *vload25 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct34, + // glue (or chain) input edge + SDValue(sub0, 1) + ); + +// R09 = R15 < R08; +// Instr #98 +SDNode *lt2 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub0, 0), + SDValue(vload25, 0), + // glue (or chain) input edge + SDValue(vload25, 1) + ); + +// R09 = R09 & R14; +// Instr #99 +SDNode *and18 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt2, 0), + // glue (or chain) input edge + SDValue(lt2, 1) + ); + +// R09 = R09 == R30; +// Instr #100 +SDNode *eq16 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and18, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and18, 1) + ); + +SDValue ct35 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #101 +SDNode *nop6 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct35, + // glue (or chain) input edge + SDValue(eq16, 1) + ); + +// WHERE_EQ; +// Instr #102 +SDNode *whereeq6 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq16, 0), + // glue (or chain) input edge + SDValue(nop6, 0) + ); + +// R15 = R31 - R15; +// Instr #103 +SDNode *sub1 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub0, 0), + SDValue(sub0, 0), + // glue (or chain) input edge + SDValue(whereeq6, 1) + ); + +SDValue ct36 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R26 = 0; +// Instr #104 +SDNode *vload26 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct36, + SDValue(or1, 0), + // glue (or chain) input edge + SDValue(sub1, 1) + ); + +SDValue ct37 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = R21 << 0; +// Instr #105 +SDNode *ishl1 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + ct37, + SDValue(vload19, 0), + // glue (or chain) input edge + SDValue(vload26, 1) + ); + +SDValue ct38 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #106 +SDNode *vload27 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct38, + SDValue(sub1, 0), + // glue (or chain) input edge + SDValue(ishl1, 1) + ); + +// END_WHERE; +// Instr #107 +SDNode *endwhere6 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload27, 1) + ); + +SDValue ct39 = CurDAG->getConstant(-3, DL, MVT::i16, true, false); +// R08 = -3; +// Instr #108 +SDNode *vload28 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct39, + // glue (or chain) input edge + SDValue(endwhere6, 0) + ); + +// R09 = R15 < R08; +// Instr #109 +SDNode *lt3 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload27, 0), + SDValue(vload28, 0), + // glue (or chain) input edge + SDValue(vload28, 1) + ); + +// R09 = R09 & R14; +// Instr #110 +SDNode *and19 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt3, 0), + // glue (or chain) input edge + SDValue(lt3, 1) + ); + +// R09 = R09 == R30; +// Instr #111 +SDNode *eq17 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and19, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and19, 1) + ); + +SDValue ct40 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #112 +SDNode *nop7 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct40, + // glue (or chain) input edge + SDValue(eq17, 1) + ); + +// WHERE_EQ; +// Instr #113 +SDNode *whereeq7 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq17, 0), + // glue (or chain) input edge + SDValue(nop7, 0) + ); + +// R15 = R31 - R15; +// Instr #114 +SDNode *sub2 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload27, 0), + SDValue(vload27, 0), + // glue (or chain) input edge + SDValue(whereeq7, 1) + ); + +// R26 = R26 >> R15; +// Instr #115 +SDNode *shr0 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload26, 0), + SDValue(sub2, 0), + SDValue(vload26, 0), + // glue (or chain) input edge + SDValue(sub2, 1) + ); + +SDValue ct41 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = R21 << 0; +// Instr #116 +SDNode *ishl2 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + ct41, + SDValue(ishl1, 0), + // glue (or chain) input edge + SDValue(shr0, 1) + ); + +SDValue ct42 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #117 +SDNode *vload29 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct42, + SDValue(sub2, 0), + // glue (or chain) input edge + SDValue(ishl2, 1) + ); + +// END_WHERE; +// Instr #118 +SDNode *endwhere7 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload29, 1) + ); + +// R09 = R15 < R31; +// Instr #119 +SDNode *lt4 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload29, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere7, 0) + ); + +// R09 = R09 & R14; +// Instr #120 +SDNode *and20 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt4, 0), + // glue (or chain) input edge + SDValue(lt4, 1) + ); + +// R09 = R09 == R30; +// Instr #121 +SDNode *eq18 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and20, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and20, 1) + ); + +SDValue ct43 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #122 +SDNode *nop8 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct43, + // glue (or chain) input edge + SDValue(eq18, 1) + ); + +// WHERE_EQ; +// Instr #123 +SDNode *whereeq8 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq18, 0), + // glue (or chain) input edge + SDValue(nop8, 0) + ); + +// R15 = R31 - R15; +// Instr #124 +SDNode *sub3 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload29, 0), + SDValue(vload29, 0), + // glue (or chain) input edge + SDValue(whereeq8, 1) + ); + +// R22 = R22 << R15; +// Instr #125 +SDNode *shl0 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or3, 0), + SDValue(sub3, 0), + SDValue(or3, 0), + // glue (or chain) input edge + SDValue(sub3, 1) + ); + +SDValue ct44 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R21 = R25 << 0; +// Instr #126 +SDNode *ishl3 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl2, 0), + ct44, + SDValue(vload20, 0), + // glue (or chain) input edge + SDValue(shl0, 1) + ); + +SDValue ct45 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #127 +SDNode *vload30 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct45, + SDValue(sub3, 0), + // glue (or chain) input edge + SDValue(ishl3, 1) + ); + +// END_WHERE; +// Instr #128 +SDNode *endwhere8 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload30, 1) + ); + +SDValue ct46 = CurDAG->getConstant(4, DL, MVT::i16, true, false); +// R08 = 4; +// Instr #129 +SDNode *vload31 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct46, + // glue (or chain) input edge + SDValue(endwhere8, 0) + ); + +// R09 = R15 < R08; +// Instr #130 +SDNode *lt5 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload30, 0), + SDValue(vload31, 0), + // glue (or chain) input edge + SDValue(vload31, 1) + ); + +// R09 = R09 & R14; +// Instr #131 +SDNode *and21 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt5, 0), + // glue (or chain) input edge + SDValue(lt5, 1) + ); + +// R09 = R09 == R30; +// Instr #132 +SDNode *eq19 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and21, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and21, 1) + ); + +SDValue ct47 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #133 +SDNode *nop9 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct47, + // glue (or chain) input edge + SDValue(eq19, 1) + ); + +// WHERE_EQ; +// Instr #134 +SDNode *whereeq9 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq19, 0), + // glue (or chain) input edge + SDValue(nop9, 0) + ); + +// R26 = R26 << R15; +// Instr #135 +SDNode *shl1 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr0, 0), + SDValue(vload30, 0), + SDValue(shr0, 0), + // glue (or chain) input edge + SDValue(whereeq9, 1) + ); + +SDValue ct48 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = R21 << 0; +// Instr #136 +SDNode *ishl4 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl3, 0), + ct48, + SDValue(ishl2, 0), + // glue (or chain) input edge + SDValue(shl1, 1) + ); + +SDValue ct49 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #137 +SDNode *vload32 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct49, + SDValue(vload30, 0), + // glue (or chain) input edge + SDValue(ishl4, 1) + ); + +// END_WHERE; +// Instr #138 +SDNode *endwhere9 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload32, 1) + ); + +// R09 = R15 < R29; +// Instr #139 +SDNode *lt6 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload32, 0), + SDValue(vload3, 0), + // glue (or chain) input edge + SDValue(endwhere9, 0) + ); + +// R09 = R09 & R14; +// Instr #140 +SDNode *and22 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt6, 0), + // glue (or chain) input edge + SDValue(lt6, 1) + ); + +// R09 = R09 == R30; +// Instr #141 +SDNode *eq20 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and22, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and22, 1) + ); + +SDValue ct50 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #142 +SDNode *nop10 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct50, + // glue (or chain) input edge + SDValue(eq20, 1) + ); + +// WHERE_EQ; +// Instr #143 +SDNode *whereeq10 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq20, 0), + // glue (or chain) input edge + SDValue(nop10, 0) + ); + +// R22 = R22 >> R15; +// Instr #144 +SDNode *shr1 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl0, 0), + SDValue(vload32, 0), + SDValue(shl0, 0), + // glue (or chain) input edge + SDValue(whereeq10, 1) + ); + +SDValue ct51 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R21 = R25 << 0; +// Instr #145 +SDNode *ishl5 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + ct51, + SDValue(ishl3, 0), + // glue (or chain) input edge + SDValue(shr1, 1) + ); + +SDValue ct52 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #146 +SDNode *vload33 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct52, + SDValue(vload32, 0), + // glue (or chain) input edge + SDValue(ishl5, 1) + ); + +// END_WHERE; +// Instr #147 +SDNode *endwhere10 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload33, 1) + ); + +SDValue ct53 = CurDAG->getConstant(32, DL, MVT::i16, true, false); +// R08 = 32; +// Instr #148 +SDNode *vload34 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct53, + // glue (or chain) input edge + SDValue(endwhere10, 0) + ); + +// R09 = R15 < R08; +// Instr #149 +SDNode *lt7 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload33, 0), + SDValue(vload34, 0), + // glue (or chain) input edge + SDValue(vload34, 1) + ); + +// R09 = R09 & R14; +// Instr #150 +SDNode *and23 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt7, 0), + // glue (or chain) input edge + SDValue(lt7, 1) + ); + +// R09 = R09 == R30; +// Instr #151 +SDNode *eq21 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and23, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and23, 1) + ); + +SDValue ct54 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #152 +SDNode *nop11 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct54, + // glue (or chain) input edge + SDValue(eq21, 1) + ); + +// WHERE_EQ; +// Instr #153 +SDNode *whereeq11 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq21, 0), + // glue (or chain) input edge + SDValue(nop11, 0) + ); + +SDValue ct55 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R22 = 0; +// Instr #154 +SDNode *vload35 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct55, + SDValue(shr1, 0), + // glue (or chain) input edge + SDValue(whereeq11, 1) + ); + +SDValue ct56 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R21 = R25 << 0; +// Instr #155 +SDNode *ishl6 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + ct56, + SDValue(ishl5, 0), + // glue (or chain) input edge + SDValue(vload35, 1) + ); + +// END_WHERE; +// Instr #156 +SDNode *endwhere11 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(ishl6, 1) + ); + +// R09 = R24 == R11; +// Instr #157 +SDNode *eq22 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(endwhere11, 0) + ); + +// R09 = R09 & R14; +// Instr #158 +SDNode *and24 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq22, 0), + // glue (or chain) input edge + SDValue(eq22, 1) + ); + +// R09 = R09 == R30; +// Instr #159 +SDNode *eq23 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and24, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and24, 1) + ); + +SDValue ct57 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #160 +SDNode *nop12 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct57, + // glue (or chain) input edge + SDValue(eq23, 1) + ); + +// WHERE_EQ; +// Instr #161 +SDNode *whereeq12 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq23, 0), + // glue (or chain) input edge + SDValue(nop12, 0) + ); + +// R26 = R31 - R26; +// Instr #162 +SDNode *sub4 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(shl1, 0), + SDValue(shl1, 0), + // glue (or chain) input edge + SDValue(whereeq12, 1) + ); + +// END_WHERE; +// Instr #163 +SDNode *endwhere12 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub4, 1) + ); + +// R09 = R20 == R11; +// Instr #164 +SDNode *eq24 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and4, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(endwhere12, 0) + ); + +// R09 = R09 & R14; +// Instr #165 +SDNode *and25 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq24, 0), + // glue (or chain) input edge + SDValue(eq24, 1) + ); + +// R09 = R09 == R30; +// Instr #166 +SDNode *eq25 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and25, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and25, 1) + ); + +SDValue ct58 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #167 +SDNode *nop13 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct58, + // glue (or chain) input edge + SDValue(eq25, 1) + ); + +// WHERE_EQ; +// Instr #168 +SDNode *whereeq13 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq25, 0), + // glue (or chain) input edge + SDValue(nop13, 0) + ); + +// R22 = R31 - R22; +// Instr #169 +SDNode *sub5 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload35, 0), + SDValue(vload35, 0), + // glue (or chain) input edge + SDValue(whereeq13, 1) + ); + +// END_WHERE; +// Instr #170 +SDNode *endwhere13 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub5, 1) + ); + +// R09 = R14 == R30; +// Instr #171 +SDNode *eq26 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere13, 0) + ); + +SDValue ct59 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #172 +SDNode *nop14 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct59, + // glue (or chain) input edge + SDValue(eq26, 1) + ); + +// WHERE_EQ; +// Instr #173 +SDNode *whereeq14 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq26, 0), + // glue (or chain) input edge + SDValue(nop14, 0) + ); + +// R26 = R22 + R26; +// Instr #174 +SDNode *add0 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub4, 0), + SDValue(sub5, 0), + SDValue(sub4, 0), + // glue (or chain) input edge + SDValue(whereeq14, 1) + ); + +// END_WHERE; +// Instr #175 +SDNode *endwhere14 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(add0, 1) + ); + +// R24 = R26 & R11; +// Instr #176 +SDNode *and26 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add0, 0), + // glue (or chain) input edge + SDValue(endwhere14, 0) + ); + +// R09 = R24 == R11; +// Instr #177 +SDNode *eq27 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and26, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(and26, 1) + ); + +// R09 = R09 & R14; +// Instr #178 +SDNode *and27 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq27, 0), + // glue (or chain) input edge + SDValue(eq27, 1) + ); + +// R09 = R09 == R30; +// Instr #179 +SDNode *eq28 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and27, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and27, 1) + ); + +SDValue ct60 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #180 +SDNode *nop15 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct60, + // glue (or chain) input edge + SDValue(eq28, 1) + ); + +// WHERE_EQ; +// Instr #181 +SDNode *whereeq15 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq28, 0), + // glue (or chain) input edge + SDValue(nop15, 0) + ); + +// R26 = R31 - R26; +// Instr #182 +SDNode *sub6 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(add0, 0), + SDValue(add0, 0), + // glue (or chain) input edge + SDValue(whereeq15, 1) + ); + +// END_WHERE; +// Instr #183 +SDNode *endwhere15 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub6, 1) + ); + +SDValue ct61 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R05 = R26 << 0; +// Instr #184 +SDNode *ishl7 = CurDAG->getMachineNode( + Connex::ISHLV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + ct61, + // glue (or chain) input edge + SDValue(endwhere15, 0) + ); + +SDValue ct62 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R08 = R05 >> 1; +// Instr #185 +SDNode *ishr2 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl7, 0), + ct62, + // glue (or chain) input edge + SDValue(ishl7, 1) + ); + +// R05 = R05 | R08; +// Instr #186 +SDNode *or9 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr2, 0), + SDValue(ishl7, 0), + // glue (or chain) input edge + SDValue(ishr2, 1) + ); + +SDValue ct63 = CurDAG->getConstant(2, DL, MVT::i16, true, false); +// R08 = R05 >> 2; +// Instr #187 +SDNode *ishr3 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or9, 0), + ct63, + // glue (or chain) input edge + SDValue(or9, 1) + ); + +// R05 = R05 | R08; +// Instr #188 +SDNode *or10 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr3, 0), + SDValue(or9, 0), + // glue (or chain) input edge + SDValue(ishr3, 1) + ); + +SDValue ct64 = CurDAG->getConstant(4, DL, MVT::i16, true, false); +// R08 = R05 >> 4; +// Instr #189 +SDNode *ishr4 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or10, 0), + ct64, + // glue (or chain) input edge + SDValue(or10, 1) + ); + +// R05 = R05 | R08; +// Instr #190 +SDNode *or11 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr4, 0), + SDValue(or10, 0), + // glue (or chain) input edge + SDValue(ishr4, 1) + ); + +SDValue ct65 = CurDAG->getConstant(8, DL, MVT::i16, true, false); +// R08 = R05 >> 8; +// Instr #191 +SDNode *ishr5 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or11, 0), + ct65, + // glue (or chain) input edge + SDValue(or11, 1) + ); + +// R05 = R05 | R08; +// Instr #192 +SDNode *or12 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr5, 0), + SDValue(or11, 0), + // glue (or chain) input edge + SDValue(ishr5, 1) + ); + +// R05 = ~R05; +// Instr #193 +SDNode *not4 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or12, 0), + // glue (or chain) input edge + SDValue(or12, 1) + ); + +// R06 = POPCNT(R05); +// Instr #194 +SDNode *popcnt0 = CurDAG->getMachineNode( + Connex::POPCNT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(not4, 0), + // glue (or chain) input edge + SDValue(not4, 1) + ); + +// R06 = R29 - R06; +// Instr #195 +SDNode *sub7 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(popcnt0, 0), + // glue (or chain) input edge + SDValue(popcnt0, 1) + ); + +SDValue ct66 = CurDAG->getConstant(11, DL, MVT::i16, true, false); +// R08 = 11; +// Instr #196 +SDNode *vload36 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct66, + // glue (or chain) input edge + SDValue(sub7, 1) + ); + +// R08 = R06 - R08; +// Instr #197 +SDNode *sub8 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub7, 0), + SDValue(vload36, 0), + // glue (or chain) input edge + SDValue(vload36, 1) + ); + +// R09 = R31 < R08; +// Instr #198 +SDNode *lt8 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub8, 0), + // glue (or chain) input edge + SDValue(sub8, 1) + ); + +// R09 = R09 & R14; +// Instr #199 +SDNode *and28 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt8, 0), + // glue (or chain) input edge + SDValue(lt8, 1) + ); + +// R09 = R09 == R30; +// Instr #200 +SDNode *eq29 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and28, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and28, 1) + ); + +SDValue ct67 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #201 +SDNode *nop16 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct67, + // glue (or chain) input edge + SDValue(eq29, 1) + ); + +// WHERE_EQ; +// Instr #202 +SDNode *whereeq16 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq29, 0), + // glue (or chain) input edge + SDValue(nop16, 0) + ); + +SDValue ct68 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = R26 << 0; +// Instr #203 +SDNode *ishl8 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + ct68, + SDValue(vload11, 0), + // glue (or chain) input edge + SDValue(whereeq16, 1) + ); + +// R09 = R29 - R08; +// Instr #204 +SDNode *sub9 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(sub8, 0), + SDValue(eq29, 0), + // glue (or chain) input edge + SDValue(ishl8, 1) + ); + +// R62 = R62 << R09; +// Instr #205 +SDNode *shl2 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl8, 0), + SDValue(sub9, 0), + SDValue(ishl8, 0), + // glue (or chain) input edge + SDValue(sub9, 1) + ); + +// R62 = R62 >> R09; +// Instr #206 +SDNode *shr2 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl2, 0), + SDValue(sub9, 0), + SDValue(shl2, 0), + // glue (or chain) input edge + SDValue(shl2, 1) + ); + +SDValue ct69 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R61 = R08 << 0; +// Instr #207 +SDNode *ishl9 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub8, 0), + ct69, + SDValue(vload12, 0), + // glue (or chain) input edge + SDValue(shr2, 1) + ); + +// R26 = R26 >> R08; +// Instr #208 +SDNode *shr3 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + SDValue(sub8, 0), + SDValue(sub6, 0), + // glue (or chain) input edge + SDValue(ishl9, 1) + ); + +// R25 = R08 + R25; +// Instr #209 +SDNode *add1 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + SDValue(sub8, 0), + SDValue(ishl4, 0), + // glue (or chain) input edge + SDValue(shr3, 1) + ); + +// END_WHERE; +// Instr #210 +SDNode *endwhere16 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(add1, 1) + ); + +// R09 = R08 < R31; +// Instr #211 +SDNode *lt9 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub8, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere16, 0) + ); + +// R09 = R09 & R14; +// Instr #212 +SDNode *and29 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt9, 0), + // glue (or chain) input edge + SDValue(lt9, 1) + ); + +// R09 = R09 == R30; +// Instr #213 +SDNode *eq30 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and29, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and29, 1) + ); + +SDValue ct70 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #214 +SDNode *nop17 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct70, + // glue (or chain) input edge + SDValue(eq30, 1) + ); + +// WHERE_EQ; +// Instr #215 +SDNode *whereeq17 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq30, 0), + // glue (or chain) input edge + SDValue(nop17, 0) + ); + +// R08 = R31 - R08; +// Instr #216 +SDNode *sub10 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub8, 0), + SDValue(sub8, 0), + // glue (or chain) input edge + SDValue(whereeq17, 1) + ); + +// R26 = R26 << R08; +// Instr #217 +SDNode *shl3 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr3, 0), + SDValue(sub10, 0), + SDValue(shr3, 0), + // glue (or chain) input edge + SDValue(sub10, 1) + ); + +// R25 = R25 - R08; +// Instr #218 +SDNode *sub11 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(add1, 0), + SDValue(sub10, 0), + SDValue(add1, 0), + // glue (or chain) input edge + SDValue(shl3, 1) + ); + +// END_WHERE; +// Instr #219 +SDNode *endwhere17 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub11, 1) + ); + +// R09 = R25 < R30; +// Instr #220 +SDNode *lt10 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub11, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere17, 0) + ); + +// R09 = R09 & R14; +// Instr #221 +SDNode *and30 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt10, 0), + // glue (or chain) input edge + SDValue(lt10, 1) + ); + +// R09 = R09 == R30; +// Instr #222 +SDNode *eq31 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and30, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and30, 1) + ); + +SDValue ct71 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #223 +SDNode *nop18 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct71, + // glue (or chain) input edge + SDValue(eq31, 1) + ); + +// WHERE_EQ; +// Instr #224 +SDNode *whereeq18 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq31, 0), + // glue (or chain) input edge + SDValue(nop18, 0) + ); + +// R61 = R30 - R25; +// Instr #225 +SDNode *sub12 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(sub11, 0), + SDValue(ishl9, 0), + // glue (or chain) input edge + SDValue(whereeq18, 1) + ); + +SDValue ct72 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R25 = 1; +// Instr #226 +SDNode *vload37 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct72, + SDValue(sub11, 0), + // glue (or chain) input edge + SDValue(sub12, 1) + ); + +SDValue ct73 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = R26 << 0; +// Instr #227 +SDNode *ishl10 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl3, 0), + ct73, + SDValue(shr2, 0), + // glue (or chain) input edge + SDValue(vload37, 1) + ); + +// R09 = R29 - R61; +// Instr #228 +SDNode *sub13 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(sub12, 0), + SDValue(eq31, 0), + // glue (or chain) input edge + SDValue(ishl10, 1) + ); + +// R62 = R62 << R09; +// Instr #229 +SDNode *shl4 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl10, 0), + SDValue(sub13, 0), + SDValue(ishl10, 0), + // glue (or chain) input edge + SDValue(sub13, 1) + ); + +// R62 = R62 >> R09; +// Instr #230 +SDNode *shr4 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl4, 0), + SDValue(sub13, 0), + SDValue(shl4, 0), + // glue (or chain) input edge + SDValue(shl4, 1) + ); + +// R26 = R26 >> R61; +// Instr #231 +SDNode *shr5 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl3, 0), + SDValue(sub12, 0), + SDValue(shl3, 0), + // glue (or chain) input edge + SDValue(shr4, 1) + ); + +// END_WHERE; +// Instr #232 +SDNode *endwhere18 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(shr5, 1) + ); + +SDValue ct74 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R08 = 1024; +// Instr #233 +SDNode *vload38 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct74, + // glue (or chain) input edge + SDValue(endwhere18, 0) + ); + +// R08 = R26 < R08; +// Instr #234 +SDNode *lt11 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr5, 0), + SDValue(vload38, 0), + // glue (or chain) input edge + SDValue(vload38, 1) + ); + +// R09 = R25 == R30; +// Instr #235 +SDNode *eq32 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload37, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(lt11, 1) + ); + +// R09 = R09 & R14; +// Instr #236 +SDNode *and31 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq32, 0), + // glue (or chain) input edge + SDValue(eq32, 1) + ); + +// R09 = R09 & R08; +// Instr #237 +SDNode *and32 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt11, 0), + SDValue(and31, 0), + // glue (or chain) input edge + SDValue(and31, 1) + ); + +// R09 = R09 == R30; +// Instr #238 +SDNode *eq33 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and32, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and32, 1) + ); + +SDValue ct75 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #239 +SDNode *nop19 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct75, + // glue (or chain) input edge + SDValue(eq33, 1) + ); + +// WHERE_EQ; +// Instr #240 +SDNode *whereeq19 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq33, 0), + // glue (or chain) input edge + SDValue(nop19, 0) + ); + +SDValue ct76 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = 0; +// Instr #241 +SDNode *vload39 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct76, + SDValue(vload37, 0), + // glue (or chain) input edge + SDValue(whereeq19, 1) + ); + +// END_WHERE; +// Instr #242 +SDNode *endwhere19 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload39, 1) + ); + +// R26 = R26 & R13; +// Instr #243 +SDNode *and33 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(shr5, 0), + // glue (or chain) input edge + SDValue(endwhere19, 0) + ); + +SDValue ct77 = CurDAG->getConstant(30, DL, MVT::i16, true, false); +// R09 = 30; +// Instr #244 +SDNode *vload40 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct77, + // glue (or chain) input edge + SDValue(and33, 1) + ); + +// R09 = R09 < R25; +// Instr #245 +SDNode *lt12 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload40, 0), + SDValue(vload39, 0), + // glue (or chain) input edge + SDValue(vload40, 1) + ); + +// R09 = R09 & R14; +// Instr #246 +SDNode *and34 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt12, 0), + // glue (or chain) input edge + SDValue(lt12, 1) + ); + +// R09 = R09 == R30; +// Instr #247 +SDNode *eq34 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and34, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and34, 1) + ); + +SDValue ct78 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #248 +SDNode *nop20 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct78, + // glue (or chain) input edge + SDValue(eq34, 1) + ); + +// WHERE_EQ; +// Instr #249 +SDNode *whereeq20 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq34, 0), + // glue (or chain) input edge + SDValue(nop20, 0) + ); + +SDValue ct79 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R14 = 0; +// Instr #250 +SDNode *vload41 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct79, + SDValue(vload24, 0), + // glue (or chain) input edge + SDValue(whereeq20, 1) + ); + +SDValue ct80 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R19 = 31744; +// Instr #251 +SDNode *vload42 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct80, + SDValue(xor0, 0), + // glue (or chain) input edge + SDValue(vload41, 1) + ); + +// R19 = R19 | R24; +// Instr #252 +SDNode *or13 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and26, 0), + SDValue(vload42, 0), + SDValue(vload42, 0), + // glue (or chain) input edge + SDValue(vload42, 1) + ); + +// END_WHERE; +// Instr #253 +SDNode *endwhere20 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or13, 1) + ); + +// R08 = R14 == R30; +// Instr #254 +SDNode *eq35 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload41, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere20, 0) + ); + +SDValue ct81 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #255 +SDNode *nop21 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct81, + // glue (or chain) input edge + SDValue(eq35, 1) + ); + +// WHERE_EQ; +// Instr #256 +SDNode *whereeq21 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq35, 0), + // glue (or chain) input edge + SDValue(nop21, 0) + ); + +SDValue ct82 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R19 = R25 << 10; +// Instr #257 +SDNode *ishl11 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload39, 0), + ct82, + SDValue(or13, 0), + // glue (or chain) input edge + SDValue(whereeq21, 1) + ); + +// R19 = R19 | R26; +// Instr #258 +SDNode *or14 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and33, 0), + SDValue(ishl11, 0), + SDValue(ishl11, 0), + // glue (or chain) input edge + SDValue(ishl11, 1) + ); + +// R04 = R26 & R30; +// Instr #259 +SDNode *and35 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(and33, 0), + SDValue(vload14, 0), + // glue (or chain) input edge + SDValue(or14, 1) + ); + +// R07 = R61 - R30; +// Instr #260 +SDNode *sub14 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub12, 0), + SDValue(vload1, 0), + SDValue(and17, 0), + // glue (or chain) input edge + SDValue(and35, 1) + ); + +// R08 = R30 << R08; +// Instr #261 +SDNode *shl5 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq35, 0), + SDValue(eq35, 0), + // glue (or chain) input edge + SDValue(sub14, 1) + ); + +// R03 = R62 & R08; +// Instr #262 +SDNode *and36 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl5, 0), + SDValue(shr4, 0), + SDValue(vload15, 0), + // glue (or chain) input edge + SDValue(shl5, 1) + ); + +// R62 = R62 ^ R03; +// Instr #263 +SDNode *xor1 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and36, 0), + SDValue(shr4, 0), + SDValue(shr4, 0), + // glue (or chain) input edge + SDValue(and36, 1) + ); + +// R03 = R03 == R31; +// Instr #264 +SDNode *eq36 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and36, 0), + SDValue(vload2, 0), + SDValue(and36, 0), + // glue (or chain) input edge + SDValue(xor1, 1) + ); + +// R03 = R30 - R03; +// Instr #265 +SDNode *sub15 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq36, 0), + SDValue(eq36, 0), + // glue (or chain) input edge + SDValue(eq36, 1) + ); + +SDValue ct83 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R08 = R08 >> 1; +// Instr #266 +SDNode *ishr6 = CurDAG->getMachineNode( + Connex::ISHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl5, 0), + ct83, + SDValue(shl5, 0), + // glue (or chain) input edge + SDValue(sub15, 1) + ); + +// R02 = R62 & R08; +// Instr #267 +SDNode *and37 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr6, 0), + SDValue(xor1, 0), + SDValue(vload16, 0), + // glue (or chain) input edge + SDValue(ishr6, 1) + ); + +// R62 = R62 ^ R02; +// Instr #268 +SDNode *xor2 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and37, 0), + SDValue(xor1, 0), + SDValue(xor1, 0), + // glue (or chain) input edge + SDValue(and37, 1) + ); + +// R02 = R02 == R31; +// Instr #269 +SDNode *eq37 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and37, 0), + SDValue(vload2, 0), + SDValue(and37, 0), + // glue (or chain) input edge + SDValue(xor2, 1) + ); + +// R02 = R30 - R02; +// Instr #270 +SDNode *sub16 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq37, 0), + SDValue(eq37, 0), + // glue (or chain) input edge + SDValue(eq37, 1) + ); + +// R01 = R62 == R31; +// Instr #271 +SDNode *eq38 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(xor2, 0), + SDValue(vload2, 0), + SDValue(vload17, 0), + // glue (or chain) input edge + SDValue(sub16, 1) + ); + +// R01 = R30 - R01; +// Instr #272 +SDNode *sub17 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq38, 0), + SDValue(eq38, 0), + // glue (or chain) input edge + SDValue(eq38, 1) + ); + +// R00 = R04 | R02; +// Instr #273 +SDNode *or15 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub16, 0), + SDValue(and35, 0), + SDValue(vload18, 0), + // glue (or chain) input edge + SDValue(sub17, 1) + ); + +// R00 = R00 | R01; +// Instr #274 +SDNode *or16 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub17, 0), + SDValue(or15, 0), + SDValue(or15, 0), + // glue (or chain) input edge + SDValue(or15, 1) + ); + +// R00 = R00 & R03; +// Instr #275 +SDNode *and38 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub15, 0), + SDValue(or16, 0), + SDValue(or16, 0), + // glue (or chain) input edge + SDValue(or16, 1) + ); + +// R19 = R00 + R19; +// Instr #276 +SDNode *add2 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or14, 0), + SDValue(and38, 0), + SDValue(or14, 0), + // glue (or chain) input edge + SDValue(and38, 1) + ); + +// R19 = R19 | R24; +// Instr #277 +SDNode *resF16 /*or17*/ = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and26, 0), + SDValue(add2, 0), + SDValue(add2, 0), + // glue (or chain) input edge + SDValue(add2, 1) + ); + +// END_WHERE; +// Instr #278 +SDNode *lastNode /*endwhere21*/ = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, +// Alex: MVT::Glue, + MVT::Other, + // glue (or chain) input edge +// Alex: SDValue(or17, 1) + SDValue(resF16, 1) + ); + Index: lib/Target/Connex/Select_ADDi32_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_ADDi32_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_ADDi32_OpincaaCodeGen.cpp @@ -0,0 +1,205 @@ +// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/ADD_i32_manual/DumpISel_OpincaaCodeGen_old05_011.cpp + +// R27 is REG_SRC1. It is represented by result of nodeOpSrcCast1. +// R28 is REG_SRC2. It is represented by result of nodeOpSrcCast2. + + + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 15. + + + + +SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast2, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +// R29 = R27 + R28; +// Instr #2 +SDNode *add0 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(nodeOpSrcCast2, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +// R23 = ADDC(R31, R31); +// Instr #3 +SDNode *addc0 = CurDAG->getMachineNode( + Connex::ADDCV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(vload0, 0), + SDValue(add0, 0) + // no need for glue or chain input (since it normally consumes the output of the predecessor) + ); + +// R26 = INDEX; +// Instr #4 +SDNode *ldix0 = CurDAG->getMachineNode( + Connex::LDIX_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(addc0, 1) + ); + +// R25 = R26 & R30; +// Instr #5 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(ldix0, 0), + // glue (or chain) input edge + SDValue(ldix0, 1) + ); + +// R24 = R25 == R30; +// Instr #6 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #7 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// WHERE_EQ; +// Instr #8 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +SDValue ct3 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R23 = 0; +// Instr #9 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + SDValue(addc0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// END_WHERE; +// Instr #10 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +// CELL_SHR(R23, R30); +// Instr #11 +SDNode *cellshr0 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #12 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(cellshr0, 0) + ); + +// R21 = SHIFT_REG; +// Instr #13 +SDNode *ldsh0 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R22 = R21 + R29; +// Instr #14 +SDNode *resH /*add1*/ = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(add0, 0), + SDValue(ldsh0, 0), + // glue (or chain) input edge + SDValue(ldsh0, 1) + ); + +SDNode *lastNode = resH; Index: lib/Target/Connex/Select_MULTf16_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_MULTf16_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_MULTf16_OpincaaCodeGen.cpp @@ -0,0 +1,3258 @@ +// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/MULTf16_manual/DumpISel_OpincaaCodeGen.cpp + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: mul.f16. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 249. + + + + +SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast1, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R29 = 16; +// Instr #2 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +SDValue ct3 = CurDAG->getConstant(31, DL, MVT::i16, true, false); +// R28 = 31; +// Instr #3 +SDNode *vload3 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +SDValue ct4 = CurDAG->getConstant(1023, DL, MVT::i16, true, false); +// R10 = 1023; +// Instr #4 +SDNode *vload4 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(vload3, 1) + ); + +SDValue ct5 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R09 = 31744; +// Instr #5 +SDNode *vload5 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct5, + // glue (or chain) input edge + SDValue(vload4, 1) + ); + +SDValue ct6 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false); +// R08 = -32768; +// Instr #6 +SDNode *vload6 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct6, + // glue (or chain) input edge + SDValue(vload5, 1) + ); + +SDValue ct7 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R07 = 1024; +// Instr #7 +SDNode *vload7 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct7, + // glue (or chain) input edge + SDValue(vload6, 1) + ); + +SDValue ct8 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R55 = 0; +// Instr #8 +SDNode *vload8 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct8, + // glue (or chain) input edge + SDValue(vload7, 1) + ); + +SDValue ct9 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R00 = 1; +// Instr #9 +SDNode *vload9 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct9, + // glue (or chain) input edge + SDValue(vload8, 1) + ); + +// R24 = R27 & R08; +// Instr #10 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(vload9, 1) + ); + +// R25 = R27 & R09; +// Instr #11 +SDNode *and1 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct10 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R25 = R25 >> 10; +// Instr #12 +SDNode *ishr0 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and1, 0), + ct10, + // glue (or chain) input edge + SDValue(and1, 1) + ); + +// R26 = R27 & R10; +// Instr #13 +SDNode *and2 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload4, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(ishr0, 1) + ); + +// R14 = R31 < R26; +// Instr #14 +SDNode *lt0 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(and2, 1) + ); + +// R13 = R25 == R31; +// Instr #15 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr0, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt0, 1) + ); + +// R12 = R13 & R14; +// Instr #16 +SDNode *and3 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt0, 0), + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// R12 = R12 == R30; +// Instr #17 +SDNode *eq1 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and3, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and3, 1) + ); + +SDValue ct11 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #18 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct11, + // glue (or chain) input edge + SDValue(eq1, 1) + ); + +// WHERE_EQ; +// Instr #19 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq1, 0), + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +SDValue ct12 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R25 = 1; +// Instr #20 +SDNode *vload10 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct12, + SDValue(ishr0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// END_WHERE; +// Instr #21 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload10, 1) + ); + +// R14 = R25 == R28; +// Instr #22 +SDNode *eq2 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload10, 0), + SDValue(vload3, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +// R14 = R14 | R13; +// Instr #23 +SDNode *or0 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + SDValue(eq2, 0), + // glue (or chain) input edge + SDValue(eq2, 1) + ); + +// R14 = R14 == R31; +// Instr #24 +SDNode *eq3 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or0, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(or0, 1) + ); + +SDValue ct13 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #25 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct13, + // glue (or chain) input edge + SDValue(eq3, 1) + ); + +// WHERE_EQ; +// Instr #26 +SDNode *whereeq1 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq3, 0), + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R26 = R26 | R07; +// Instr #27 +SDNode *or1 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(and2, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(whereeq1, 1) + ); + +// END_WHERE; +// Instr #28 +SDNode *endwhere1 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or1, 1) + ); + +// R20 = R23 & R08; +// Instr #29 +SDNode *and4 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(endwhere1, 0) + ); + +// R21 = R23 & R09; +// Instr #30 +SDNode *and5 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(and4, 1) + ); + +SDValue ct14 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R21 = R21 >> 10; +// Instr #31 +SDNode *ishr1 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and5, 0), + ct14, + // glue (or chain) input edge + SDValue(and5, 1) + ); + +// R22 = R23 & R10; +// Instr #32 +SDNode *and6 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload4, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(ishr1, 1) + ); + +// R14 = R31 < R22; +// Instr #33 +SDNode *lt1 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(and6, 1) + ); + +// R13 = R21 == R31; +// Instr #34 +SDNode *eq4 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr1, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt1, 1) + ); + +// R12 = R13 & R14; +// Instr #35 +SDNode *and7 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt1, 0), + SDValue(eq4, 0), + // glue (or chain) input edge + SDValue(eq4, 1) + ); + +// R12 = R12 == R30; +// Instr #36 +SDNode *eq5 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and7, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and7, 1) + ); + +SDValue ct15 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #37 +SDNode *nop2 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct15, + // glue (or chain) input edge + SDValue(eq5, 1) + ); + +// WHERE_EQ; +// Instr #38 +SDNode *whereeq2 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq5, 0), + // glue (or chain) input edge + SDValue(nop2, 0) + ); + +SDValue ct16 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R21 = 1; +// Instr #39 +SDNode *vload11 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct16, + SDValue(ishr1, 0), + // glue (or chain) input edge + SDValue(whereeq2, 1) + ); + +// END_WHERE; +// Instr #40 +SDNode *endwhere2 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload11, 1) + ); + +// R14 = R21 == R28; +// Instr #41 +SDNode *eq6 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload11, 0), + SDValue(vload3, 0), + // glue (or chain) input edge + SDValue(endwhere2, 0) + ); + +// R14 = R14 | R13; +// Instr #42 +SDNode *or2 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq4, 0), + SDValue(eq6, 0), + // glue (or chain) input edge + SDValue(eq6, 1) + ); + +// R14 = R14 == R31; +// Instr #43 +SDNode *eq7 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or2, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(or2, 1) + ); + +SDValue ct17 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #44 +SDNode *nop3 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct17, + // glue (or chain) input edge + SDValue(eq7, 1) + ); + +// WHERE_EQ; +// Instr #45 +SDNode *whereeq3 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq7, 0), + // glue (or chain) input edge + SDValue(nop3, 0) + ); + +// R22 = R22 | R07; +// Instr #46 +SDNode *or3 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(and6, 0), + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(whereeq3, 1) + ); + +// END_WHERE; +// Instr #47 +SDNode *endwhere3 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or3, 1) + ); + +SDValue ct18 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R19 = 31744; +// Instr #48 +SDNode *vload12 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct18, + // glue (or chain) input edge + SDValue(endwhere3, 0) + ); + +// R15 = R24 ^ R20; +// Instr #49 +SDNode *xor0 = CurDAG->getMachineNode( + Connex::XORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and4, 0), + SDValue(and0, 0), + // glue (or chain) input edge + SDValue(vload12, 1) + ); + +SDValue ct19 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R16 = 0; +// Instr #50 +SDNode *vload13 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct19, + // glue (or chain) input edge + SDValue(xor0, 1) + ); + +SDValue ct20 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R18 = 0; +// Instr #51 +SDNode *vload14 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct20, + // glue (or chain) input edge + SDValue(vload13, 1) + ); + +SDValue ct21 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R17 = 0; +// Instr #52 +SDNode *vload15 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct21, + // glue (or chain) input edge + SDValue(vload14, 1) + ); + +SDValue ct22 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R54 = 0; +// Instr #53 +SDNode *vload16 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct22, + // glue (or chain) input edge + SDValue(vload15, 1) + ); + +SDValue ct23 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R60 = 0; +// Instr #54 +SDNode *vload17 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct23, + // glue (or chain) input edge + SDValue(vload16, 1) + ); + +SDValue ct24 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R59 = 0; +// Instr #55 +SDNode *vload18 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct24, + // glue (or chain) input edge + SDValue(vload17, 1) + ); + +SDValue ct25 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R58 = 0; +// Instr #56 +SDNode *vload19 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct25, + // glue (or chain) input edge + SDValue(vload18, 1) + ); + +SDValue ct26 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R57 = 0; +// Instr #57 +SDNode *vload20 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct26, + // glue (or chain) input edge + SDValue(vload19, 1) + ); + +// R02 = R27 == R24; +// Instr #58 +SDNode *eq8 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(nodeOpSrcCast1, 0), + SDValue(and0, 0), + // glue (or chain) input edge + SDValue(vload20, 1) + ); + +// R01 = R23 == R20; +// Instr #59 +SDNode *eq9 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(nodeOpSrcCast2, 0), + SDValue(and4, 0), + // glue (or chain) input edge + SDValue(eq8, 1) + ); + +// R36 = R25 == R28; +// Instr #60 +SDNode *eq10 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload10, 0), + SDValue(vload3, 0), + // glue (or chain) input edge + SDValue(eq9, 1) + ); + +// R38 = R31 < R26; +// Instr #61 +SDNode *lt2 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(or1, 0), + // glue (or chain) input edge + SDValue(eq10, 1) + ); + +// R35 = R21 == R28; +// Instr #62 +SDNode *eq11 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload11, 0), + SDValue(vload3, 0), + // glue (or chain) input edge + SDValue(lt2, 1) + ); + +// R37 = R31 < R22; +// Instr #63 +SDNode *lt3 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(or3, 0), + // glue (or chain) input edge + SDValue(eq11, 1) + ); + +// R62 = R36 & R38; +// Instr #64 +SDNode *and8 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt2, 0), + SDValue(eq10, 0), + // glue (or chain) input edge + SDValue(lt3, 1) + ); + +// R63 = R35 & R37; +// Instr #65 +SDNode *and9 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt3, 0), + SDValue(eq11, 0), + // glue (or chain) input edge + SDValue(and8, 1) + ); + +// R61 = R62 | R63; +// Instr #66 +SDNode *or4 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and9, 0), + SDValue(and8, 0), + // glue (or chain) input edge + SDValue(and9, 1) + ); + +// R62 = R36 & R01; +// Instr #67 +SDNode *and10 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq9, 0), + SDValue(eq10, 0), + // glue (or chain) input edge + SDValue(or4, 1) + ); + +// R63 = R35 & R02; +// Instr #68 +SDNode *and11 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq8, 0), + SDValue(eq11, 0), + // glue (or chain) input edge + SDValue(and10, 1) + ); + +// R61 = R61 | R62; +// Instr #69 +SDNode *or5 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and10, 0), + SDValue(or4, 0), + // glue (or chain) input edge + SDValue(and11, 1) + ); + +// R61 = R61 | R63; +// Instr #70 +SDNode *or6 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and11, 0), + SDValue(or5, 0), + // glue (or chain) input edge + SDValue(or5, 1) + ); + +// R03 = R61 == R30; +// Instr #71 +SDNode *eq12 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or6, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(or6, 1) + ); + +SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #72 +SDNode *nop4 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct27, + // glue (or chain) input edge + SDValue(eq12, 1) + ); + +// WHERE_EQ; +// Instr #73 +SDNode *whereeq4 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + // glue (or chain) input edge + SDValue(nop4, 0) + ); + +SDValue ct28 = CurDAG->getConstant(31745, DL, MVT::i16, true, false); +// R19 = 31745; +// Instr #74 +SDNode *vload21 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct28, + SDValue(vload12, 0), + // glue (or chain) input edge + SDValue(whereeq4, 1) + ); + +SDValue ct29 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R00 = 0; +// Instr #75 +SDNode *vload22 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct29, + SDValue(vload9, 0), + // glue (or chain) input edge + SDValue(vload21, 1) + ); + +// END_WHERE; +// Instr #76 +SDNode *endwhere4 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload22, 1) + ); + +// R39 = R36 | R35; +// Instr #77 +SDNode *or7 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq11, 0), + SDValue(eq10, 0), + // glue (or chain) input edge + SDValue(endwhere4, 0) + ); + +// R04 = R61 == R31; +// Instr #78 +SDNode *eq13 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or6, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(or7, 1) + ); + +// R03 = R39 == R30; +// Instr #79 +SDNode *eq14 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or7, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(eq13, 1) + ); + +// R03 = R03 & R04; +// Instr #80 +SDNode *and12 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + SDValue(eq14, 0), + // glue (or chain) input edge + SDValue(eq14, 1) + ); + +// R03 = R03 == R30; +// Instr #81 +SDNode *eq15 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and12, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and12, 1) + ); + +SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #82 +SDNode *nop5 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct30, + // glue (or chain) input edge + SDValue(eq15, 1) + ); + +// WHERE_EQ; +// Instr #83 +SDNode *whereeq5 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq15, 0), + // glue (or chain) input edge + SDValue(nop5, 0) + ); + +// R19 = R19 | R15; +// Instr #84 +SDNode *or8 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(xor0, 0), + SDValue(vload21, 0), + SDValue(vload21, 0), + // glue (or chain) input edge + SDValue(whereeq5, 1) + ); + +SDValue ct31 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R00 = 0; +// Instr #85 +SDNode *vload23 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct31, + SDValue(vload22, 0), + // glue (or chain) input edge + SDValue(or8, 1) + ); + +// END_WHERE; +// Instr #86 +SDNode *endwhere5 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload23, 1) + ); + +// R52 = R00 == R30; +// Instr #87 +SDNode *eq16 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere5, 0) + ); + +SDValue ct32 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #88 +SDNode *nop6 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct32, + // glue (or chain) input edge + SDValue(eq16, 1) + ); + +// WHERE_EQ; +// Instr #89 +SDNode *whereeq6 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq16, 0), + // glue (or chain) input edge + SDValue(nop6, 0) + ); + +// R16 = R21 + R25; +// Instr #90 +SDNode *add0 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload10, 0), + SDValue(vload11, 0), + SDValue(vload13, 0), + // glue (or chain) input edge + SDValue(whereeq6, 1) + ); + +SDValue ct33 = CurDAG->getConstant(15, DL, MVT::i16, true, false); +// R04 = 15; +// Instr #91 +SDNode *vload24 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct33, + SDValue(eq13, 0), + // glue (or chain) input edge + SDValue(add0, 1) + ); + +// R16 = R16 - R04; +// Instr #92 +SDNode *sub0 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(add0, 0), + SDValue(vload24, 0), + SDValue(add0, 0), + // glue (or chain) input edge + SDValue(vload24, 1) + ); + +// R26 * R22; +// Instr #93 +SDNode *mult0 = CurDAG->getMachineNode( + Connex::MULT_H, + DL, + MVT::Glue, + SDValue(or1, 0), + SDValue(or3, 0), + // glue (or chain) input edge + SDValue(sub0, 1) + ); + +// R18 = MULT_LOW(); +// Instr #94 +SDNode *multlo0 = CurDAG->getMachineNode( + Connex::MULTLO_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload14, 0), + // glue (or chain) input edge + SDValue(mult0, 0) + ); + +// R17 = MULT_HIGH(); +// Instr #95 +SDNode *multhi0 = CurDAG->getMachineNode( + Connex::MULTHI_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload15, 0), + // glue (or chain) input edge + SDValue(multlo0, 1) + ); + +// END_WHERE; +// Instr #96 +SDNode *endwhere6 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(multhi0, 1) + ); + +SDValue ct34 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R03 = 16; +// Instr #97 +SDNode *vload25 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct34, + // glue (or chain) input edge + SDValue(endwhere6, 0) + ); + +SDValue ct35 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R06 = R18 << 0; +// Instr #98 +SDNode *ishl0 = CurDAG->getMachineNode( + Connex::ISHLV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(multlo0, 0), + ct35, + // glue (or chain) input edge + SDValue(vload25, 1) + ); + +// R04 = R31 < R17; +// Instr #99 +SDNode *lt4 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(multhi0, 0), + // glue (or chain) input edge + SDValue(ishl0, 1) + ); + +// R52 = R04 & R00; +// Instr #100 +SDNode *and13 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt4, 0), + // glue (or chain) input edge + SDValue(lt4, 1) + ); + +// R52 = R52 == R30; +// Instr #101 +SDNode *eq17 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and13, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and13, 1) + ); + +SDValue ct36 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #102 +SDNode *nop7 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct36, + // glue (or chain) input edge + SDValue(eq17, 1) + ); + +// WHERE_EQ; +// Instr #103 +SDNode *whereeq7 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq17, 0), + // glue (or chain) input edge + SDValue(nop7, 0) + ); + +SDValue ct37 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R06 = R17 << 0; +// Instr #104 +SDNode *ishl1 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(multhi0, 0), + ct37, + SDValue(ishl0, 0), + // glue (or chain) input edge + SDValue(whereeq7, 1) + ); + +SDValue ct38 = CurDAG->getConstant(32, DL, MVT::i16, true, false); +// R03 = 32; +// Instr #105 +SDNode *vload26 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct38, + SDValue(vload25, 0), + // glue (or chain) input edge + SDValue(ishl1, 1) + ); + +// END_WHERE; +// Instr #106 +SDNode *endwhere7 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload26, 1) + ); + +SDValue ct39 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R04 = R06 >> 1; +// Instr #107 +SDNode *ishr2 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl1, 0), + ct39, + // glue (or chain) input edge + SDValue(endwhere7, 0) + ); + +// R06 = R06 | R04; +// Instr #108 +SDNode *or9 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr2, 0), + SDValue(ishl1, 0), + // glue (or chain) input edge + SDValue(ishr2, 1) + ); + +SDValue ct40 = CurDAG->getConstant(2, DL, MVT::i16, true, false); +// R04 = R06 >> 2; +// Instr #109 +SDNode *ishr3 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or9, 0), + ct40, + // glue (or chain) input edge + SDValue(or9, 1) + ); + +// R06 = R06 | R04; +// Instr #110 +SDNode *or10 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr3, 0), + SDValue(or9, 0), + // glue (or chain) input edge + SDValue(ishr3, 1) + ); + +SDValue ct41 = CurDAG->getConstant(4, DL, MVT::i16, true, false); +// R04 = R06 >> 4; +// Instr #111 +SDNode *ishr4 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or10, 0), + ct41, + // glue (or chain) input edge + SDValue(or10, 1) + ); + +// R06 = R06 | R04; +// Instr #112 +SDNode *or11 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr4, 0), + SDValue(or10, 0), + // glue (or chain) input edge + SDValue(ishr4, 1) + ); + +SDValue ct42 = CurDAG->getConstant(8, DL, MVT::i16, true, false); +// R04 = R06 >> 8; +// Instr #113 +SDNode *ishr5 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or11, 0), + ct42, + // glue (or chain) input edge + SDValue(or11, 1) + ); + +// R06 = R06 | R04; +// Instr #114 +SDNode *or12 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr5, 0), + SDValue(or11, 0), + // glue (or chain) input edge + SDValue(ishr5, 1) + ); + +// R06 = ~R06; +// Instr #115 +SDNode *not0 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or12, 0), + // glue (or chain) input edge + SDValue(or12, 1) + ); + +// R05 = POPCNT(R06); +// Instr #116 +SDNode *popcnt0 = CurDAG->getMachineNode( + Connex::POPCNT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(not0, 0), + // glue (or chain) input edge + SDValue(not0, 1) + ); + +// R05 = R03 - R05; +// Instr #117 +SDNode *sub1 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload26, 0), + SDValue(popcnt0, 0), + // glue (or chain) input edge + SDValue(popcnt0, 1) + ); + +SDValue ct43 = CurDAG->getConstant(11, DL, MVT::i16, true, false); +// R04 = 11; +// Instr #118 +SDNode *vload27 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct43, + // glue (or chain) input edge + SDValue(sub1, 1) + ); + +// R04 = R05 - R04; +// Instr #119 +SDNode *sub2 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub1, 0), + SDValue(vload27, 0), + // glue (or chain) input edge + SDValue(vload27, 1) + ); + +// R12 = R04 < R31; +// Instr #120 +SDNode *lt5 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub2, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(sub2, 1) + ); + +// R52 = R12 & R00; +// Instr #121 +SDNode *and14 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt5, 0), + // glue (or chain) input edge + SDValue(lt5, 1) + ); + +// R52 = R52 == R30; +// Instr #122 +SDNode *eq18 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and14, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and14, 1) + ); + +SDValue ct44 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #123 +SDNode *nop8 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct44, + // glue (or chain) input edge + SDValue(eq18, 1) + ); + +// WHERE_EQ; +// Instr #124 +SDNode *whereeq8 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq18, 0), + // glue (or chain) input edge + SDValue(nop8, 0) + ); + +// R03 = R31 - R04; +// Instr #125 +SDNode *sub3 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(sub2, 0), + SDValue(vload26, 0), + // glue (or chain) input edge + SDValue(whereeq8, 1) + ); + +// R18 = R18 << R03; +// Instr #126 +SDNode *shl0 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(multlo0, 0), + SDValue(sub3, 0), + SDValue(multlo0, 0), + // glue (or chain) input edge + SDValue(sub3, 1) + ); + +// END_WHERE; +// Instr #127 +SDNode *endwhere8 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(shl0, 1) + ); + +// R12 = R31 < R04; +// Instr #128 +SDNode *lt6 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(sub2, 0), + // glue (or chain) input edge + SDValue(endwhere8, 0) + ); + +// R52 = R12 & R00; +// Instr #129 +SDNode *and15 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt6, 0), + // glue (or chain) input edge + SDValue(lt6, 1) + ); + +// R52 = R52 == R30; +// Instr #130 +SDNode *eq19 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and15, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and15, 1) + ); + +SDValue ct45 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #131 +SDNode *nop9 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct45, + // glue (or chain) input edge + SDValue(eq19, 1) + ); + +// WHERE_EQ; +// Instr #132 +SDNode *whereeq9 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq19, 0), + // glue (or chain) input edge + SDValue(nop9, 0) + ); + +SDValue ct46 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R03 = R17 << 0; +// Instr #133 +SDNode *ishl2 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(multhi0, 0), + ct46, + SDValue(sub3, 0), + // glue (or chain) input edge + SDValue(whereeq9, 1) + ); + +// R17 = R17 >> R04; +// Instr #134 +SDNode *shr0 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(multhi0, 0), + SDValue(sub2, 0), + SDValue(multhi0, 0), + // glue (or chain) input edge + SDValue(ishl2, 1) + ); + +SDValue ct47 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R12 = R04 << 0; +// Instr #135 +SDNode *ishl3 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub2, 0), + ct47, + SDValue(lt6, 0), + // glue (or chain) input edge + SDValue(shr0, 1) + ); + +// R04 = R29 - R04; +// Instr #136 +SDNode *sub4 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub2, 0), + SDValue(sub2, 0), + // glue (or chain) input edge + SDValue(ishl3, 1) + ); + +SDValue ct48 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R55 = R18 << 0; +// Instr #137 +SDNode *ishl4 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl0, 0), + ct48, + SDValue(vload8, 0), + // glue (or chain) input edge + SDValue(sub4, 1) + ); + +// R55 = R55 << R04; +// Instr #138 +SDNode *shl1 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + SDValue(sub4, 0), + SDValue(ishl4, 0), + // glue (or chain) input edge + SDValue(ishl4, 1) + ); + +// R55 = R55 >> R04; +// Instr #139 +SDNode *shr1 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl1, 0), + SDValue(sub4, 0), + SDValue(shl1, 0), + // glue (or chain) input edge + SDValue(shl1, 1) + ); + +SDValue ct49 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R54 = R12 << 0; +// Instr #140 +SDNode *ishl5 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl3, 0), + ct49, + SDValue(vload16, 0), + // glue (or chain) input edge + SDValue(shr1, 1) + ); + +// R18 = R18 >> R12; +// Instr #141 +SDNode *shr2 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl0, 0), + SDValue(ishl3, 0), + SDValue(shl0, 0), + // glue (or chain) input edge + SDValue(ishl5, 1) + ); + +// R03 = R03 << R04; +// Instr #142 +SDNode *shl2 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl2, 0), + SDValue(sub4, 0), + SDValue(ishl2, 0), + // glue (or chain) input edge + SDValue(shr2, 1) + ); + +// R18 = R18 | R03; +// Instr #143 +SDNode *or13 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl2, 0), + SDValue(shr2, 0), + SDValue(shr2, 0), + // glue (or chain) input edge + SDValue(shl2, 1) + ); + +// END_WHERE; +// Instr #144 +SDNode *endwhere9 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or13, 1) + ); + +// R52 = R00 == R30; +// Instr #145 +SDNode *eq20 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere9, 0) + ); + +SDValue ct50 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #146 +SDNode *nop10 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct50, + // glue (or chain) input edge + SDValue(eq20, 1) + ); + +// WHERE_EQ; +// Instr #147 +SDNode *whereeq10 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq20, 0), + // glue (or chain) input edge + SDValue(nop10, 0) + ); + +SDValue ct51 = CurDAG->getConstant(21, DL, MVT::i16, true, false); +// R04 = 21; +// Instr #148 +SDNode *vload28 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct51, + SDValue(sub4, 0), + // glue (or chain) input edge + SDValue(whereeq10, 1) + ); + +// R04 = R04 - R05; +// Instr #149 +SDNode *sub5 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload28, 0), + SDValue(sub1, 0), + SDValue(vload28, 0), + // glue (or chain) input edge + SDValue(vload28, 1) + ); + +// R16 = R16 - R04; +// Instr #150 +SDNode *sub6 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub0, 0), + SDValue(sub5, 0), + SDValue(sub0, 0), + // glue (or chain) input edge + SDValue(sub5, 1) + ); + +// END_WHERE; +// Instr #151 +SDNode *endwhere10 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub6, 1) + ); + +SDValue ct52 = CurDAG->getConstant(15, DL, MVT::i16, true, false); +// R03 = 15; +// Instr #152 +SDNode *vload29 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct52, + // glue (or chain) input edge + SDValue(endwhere10, 0) + ); + +// R04 = R30 - R16; +// Instr #153 +SDNode *sub7 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(sub6, 0), + // glue (or chain) input edge + SDValue(vload29, 1) + ); + +// R12 = R03 < R04; +// Instr #154 +SDNode *lt7 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload29, 0), + SDValue(sub7, 0), + // glue (or chain) input edge + SDValue(sub7, 1) + ); + +// R52 = R12 & R00; +// Instr #155 +SDNode *and16 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt7, 0), + // glue (or chain) input edge + SDValue(lt7, 1) + ); + +// R52 = R52 == R30; +// Instr #156 +SDNode *eq21 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and16, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and16, 1) + ); + +SDValue ct53 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #157 +SDNode *nop11 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct53, + // glue (or chain) input edge + SDValue(eq21, 1) + ); + +// WHERE_EQ; +// Instr #158 +SDNode *whereeq11 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq21, 0), + // glue (or chain) input edge + SDValue(nop11, 0) + ); + +// R54 = R55 == R31; +// Instr #159 +SDNode *eq22 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr1, 0), + SDValue(vload0, 0), + SDValue(ishl5, 0), + // glue (or chain) input edge + SDValue(whereeq11, 1) + ); + +// R54 = R30 - R54; +// Instr #160 +SDNode *sub8 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq22, 0), + SDValue(eq22, 0), + // glue (or chain) input edge + SDValue(eq22, 1) + ); + +SDValue ct54 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R55 = R18 << 0; +// Instr #161 +SDNode *ishl6 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or13, 0), + ct54, + SDValue(shr1, 0), + // glue (or chain) input edge + SDValue(sub8, 1) + ); + +// R55 = R55 | R54; +// Instr #162 +SDNode *or14 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub8, 0), + SDValue(ishl6, 0), + SDValue(ishl6, 0), + // glue (or chain) input edge + SDValue(ishl6, 1) + ); + +SDValue ct55 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R54 = 16; +// Instr #163 +SDNode *vload30 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct55, + SDValue(sub8, 0), + // glue (or chain) input edge + SDValue(or14, 1) + ); + +SDValue ct56 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R18 = R17 << 0; +// Instr #164 +SDNode *ishl7 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr0, 0), + ct56, + SDValue(or13, 0), + // glue (or chain) input edge + SDValue(vload30, 1) + ); + +SDValue ct57 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R17 = 0; +// Instr #165 +SDNode *vload31 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct57, + SDValue(shr0, 0), + // glue (or chain) input edge + SDValue(ishl7, 1) + ); + +// R04 = R04 - R29; +// Instr #166 +SDNode *sub9 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub7, 0), + SDValue(vload2, 0), + SDValue(sub7, 0), + // glue (or chain) input edge + SDValue(vload31, 1) + ); + +// R16 = R29 + R16; +// Instr #167 +SDNode *add1 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + SDValue(vload2, 0), + SDValue(sub6, 0), + // glue (or chain) input edge + SDValue(sub9, 1) + ); + +// END_WHERE; +// Instr #168 +SDNode *endwhere11 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(add1, 1) + ); + +// R12 = R03 < R04; +// Instr #169 +SDNode *lt8 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload29, 0), + SDValue(sub9, 0), + // glue (or chain) input edge + SDValue(endwhere11, 0) + ); + +// R52 = R12 & R00; +// Instr #170 +SDNode *and17 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt8, 0), + // glue (or chain) input edge + SDValue(lt8, 1) + ); + +// R52 = R52 == R30; +// Instr #171 +SDNode *eq23 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and17, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and17, 1) + ); + +SDValue ct58 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #172 +SDNode *nop12 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct58, + // glue (or chain) input edge + SDValue(eq23, 1) + ); + +// WHERE_EQ; +// Instr #173 +SDNode *whereeq12 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq23, 0), + // glue (or chain) input edge + SDValue(nop12, 0) + ); + +// R54 = R55 == R31; +// Instr #174 +SDNode *eq24 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or14, 0), + SDValue(vload0, 0), + SDValue(vload30, 0), + // glue (or chain) input edge + SDValue(whereeq12, 1) + ); + +// R54 = R30 - R54; +// Instr #175 +SDNode *sub10 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq24, 0), + SDValue(eq24, 0), + // glue (or chain) input edge + SDValue(eq24, 1) + ); + +SDValue ct59 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R55 = R18 << 0; +// Instr #176 +SDNode *ishl8 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl7, 0), + ct59, + SDValue(or14, 0), + // glue (or chain) input edge + SDValue(sub10, 1) + ); + +// R55 = R55 | R54; +// Instr #177 +SDNode *or15 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub10, 0), + SDValue(ishl8, 0), + SDValue(ishl8, 0), + // glue (or chain) input edge + SDValue(ishl8, 1) + ); + +SDValue ct60 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R54 = 16; +// Instr #178 +SDNode *vload32 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct60, + SDValue(sub10, 0), + // glue (or chain) input edge + SDValue(or15, 1) + ); + +SDValue ct61 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R18 = 0; +// Instr #179 +SDNode *vload33 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct61, + SDValue(ishl7, 0), + // glue (or chain) input edge + SDValue(vload32, 1) + ); + +// R04 = R04 - R29; +// Instr #180 +SDNode *sub11 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub9, 0), + SDValue(vload2, 0), + SDValue(sub9, 0), + // glue (or chain) input edge + SDValue(vload33, 1) + ); + +// R16 = R29 + R16; +// Instr #181 +SDNode *add2 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(add1, 0), + SDValue(vload2, 0), + SDValue(add1, 0), + // glue (or chain) input edge + SDValue(sub11, 1) + ); + +// END_WHERE; +// Instr #182 +SDNode *endwhere12 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(add2, 1) + ); + +// R12 = R16 < R30; +// Instr #183 +SDNode *lt9 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(add2, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere12, 0) + ); + +// R52 = R12 & R00; +// Instr #184 +SDNode *and18 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt9, 0), + // glue (or chain) input edge + SDValue(lt9, 1) + ); + +// R52 = R52 == R30; +// Instr #185 +SDNode *eq25 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and18, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and18, 1) + ); + +SDValue ct62 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #186 +SDNode *nop13 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct62, + // glue (or chain) input edge + SDValue(eq25, 1) + ); + +// WHERE_EQ; +// Instr #187 +SDNode *whereeq13 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq25, 0), + // glue (or chain) input edge + SDValue(nop13, 0) + ); + +// R04 = R30 - R16; +// Instr #188 +SDNode *sub12 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(add2, 0), + SDValue(sub11, 0), + // glue (or chain) input edge + SDValue(whereeq13, 1) + ); + +// R54 = R55 == R31; +// Instr #189 +SDNode *eq26 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or15, 0), + SDValue(vload0, 0), + SDValue(vload32, 0), + // glue (or chain) input edge + SDValue(sub12, 1) + ); + +// R54 = R30 - R54; +// Instr #190 +SDNode *sub13 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq26, 0), + SDValue(eq26, 0), + // glue (or chain) input edge + SDValue(eq26, 1) + ); + +SDValue ct63 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R55 = R18 << 0; +// Instr #191 +SDNode *ishl9 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload33, 0), + ct63, + SDValue(or15, 0), + // glue (or chain) input edge + SDValue(sub13, 1) + ); + +// R55 = R55 | R54; +// Instr #192 +SDNode *or16 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub13, 0), + SDValue(ishl9, 0), + SDValue(ishl9, 0), + // glue (or chain) input edge + SDValue(ishl9, 1) + ); + +// R03 = R29 - R04; +// Instr #193 +SDNode *sub14 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub12, 0), + SDValue(vload29, 0), + // glue (or chain) input edge + SDValue(or16, 1) + ); + +// R55 = R55 << R03; +// Instr #194 +SDNode *shl3 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or16, 0), + SDValue(sub14, 0), + SDValue(or16, 0), + // glue (or chain) input edge + SDValue(sub14, 1) + ); + +// R55 = R55 >> R03; +// Instr #195 +SDNode *shr3 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl3, 0), + SDValue(sub14, 0), + SDValue(shl3, 0), + // glue (or chain) input edge + SDValue(shl3, 1) + ); + +SDValue ct64 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R54 = R04 << 0; +// Instr #196 +SDNode *ishl10 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub12, 0), + ct64, + SDValue(sub13, 0), + // glue (or chain) input edge + SDValue(shr3, 1) + ); + +// R18 = R18 >> R04; +// Instr #197 +SDNode *shr4 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload33, 0), + SDValue(sub12, 0), + SDValue(vload33, 0), + // glue (or chain) input edge + SDValue(ishl10, 1) + ); + +SDValue ct65 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R03 = R17 << 0; +// Instr #198 +SDNode *ishl11 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload31, 0), + ct65, + SDValue(sub14, 0), + // glue (or chain) input edge + SDValue(shr4, 1) + ); + +// R17 = R17 >> R04; +// Instr #199 +SDNode *shr5 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload31, 0), + SDValue(sub12, 0), + SDValue(vload31, 0), + // glue (or chain) input edge + SDValue(ishl11, 1) + ); + +// R04 = R29 - R04; +// Instr #200 +SDNode *sub15 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub12, 0), + SDValue(sub12, 0), + // glue (or chain) input edge + SDValue(shr5, 1) + ); + +// R03 = R03 << R04; +// Instr #201 +SDNode *shl4 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl11, 0), + SDValue(sub15, 0), + SDValue(ishl11, 0), + // glue (or chain) input edge + SDValue(sub15, 1) + ); + +// R18 = R18 | R03; +// Instr #202 +SDNode *or17 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl4, 0), + SDValue(shr4, 0), + SDValue(shr4, 0), + // glue (or chain) input edge + SDValue(shl4, 1) + ); + +SDValue ct66 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R16 = 1; +// Instr #203 +SDNode *vload34 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct66, + SDValue(add2, 0), + // glue (or chain) input edge + SDValue(or17, 1) + ); + +// END_WHERE; +// Instr #204 +SDNode *endwhere13 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload34, 1) + ); + +SDValue ct67 = CurDAG->getConstant(30, DL, MVT::i16, true, false); +// R12 = 30; +// Instr #205 +SDNode *vload35 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct67, + // glue (or chain) input edge + SDValue(endwhere13, 0) + ); + +// R12 = R12 < R16; +// Instr #206 +SDNode *lt10 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload35, 0), + SDValue(vload34, 0), + // glue (or chain) input edge + SDValue(vload35, 1) + ); + +// R52 = R12 & R00; +// Instr #207 +SDNode *and19 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload23, 0), + SDValue(lt10, 0), + // glue (or chain) input edge + SDValue(lt10, 1) + ); + +// R52 = R52 == R30; +// Instr #208 +SDNode *eq27 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and19, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and19, 1) + ); + +SDValue ct68 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #209 +SDNode *nop14 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct68, + // glue (or chain) input edge + SDValue(eq27, 1) + ); + +// WHERE_EQ; +// Instr #210 +SDNode *whereeq14 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq27, 0), + // glue (or chain) input edge + SDValue(nop14, 0) + ); + +// R19 = R19 | R15; +// Instr #211 +SDNode *or18 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(xor0, 0), + SDValue(or8, 0), + SDValue(or8, 0), + // glue (or chain) input edge + SDValue(whereeq14, 1) + ); + +SDValue ct69 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R00 = 0; +// Instr #212 +SDNode *vload36 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct69, + SDValue(vload23, 0), + // glue (or chain) input edge + SDValue(or18, 1) + ); + +// END_WHERE; +// Instr #213 +SDNode *endwhere14 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload36, 1) + ); + +SDValue ct70 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R04 = 1024; +// Instr #214 +SDNode *vload37 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct70, + // glue (or chain) input edge + SDValue(endwhere14, 0) + ); + +// R04 = R18 < R04; +// Instr #215 +SDNode *lt11 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or17, 0), + SDValue(vload37, 0), + // glue (or chain) input edge + SDValue(vload37, 1) + ); + +// R12 = R16 == R30; +// Instr #216 +SDNode *eq28 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload34, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(lt11, 1) + ); + +// R12 = R12 & R04; +// Instr #217 +SDNode *and20 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt11, 0), + SDValue(eq28, 0), + // glue (or chain) input edge + SDValue(eq28, 1) + ); + +// R12 = R12 == R30; +// Instr #218 +SDNode *eq29 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and20, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and20, 1) + ); + +// R52 = R12 & R00; +// Instr #219 +SDNode *and21 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload36, 0), + SDValue(eq29, 0), + // glue (or chain) input edge + SDValue(eq29, 1) + ); + +// R52 = R52 == R30; +// Instr #220 +SDNode *eq30 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and21, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and21, 1) + ); + +SDValue ct71 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #221 +SDNode *nop15 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct71, + // glue (or chain) input edge + SDValue(eq30, 1) + ); + +// WHERE_EQ; +// Instr #222 +SDNode *whereeq15 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq30, 0), + // glue (or chain) input edge + SDValue(nop15, 0) + ); + +SDValue ct72 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R16 = 0; +// Instr #223 +SDNode *vload38 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct72, + SDValue(vload34, 0), + // glue (or chain) input edge + SDValue(whereeq15, 1) + ); + +// END_WHERE; +// Instr #224 +SDNode *endwhere15 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload38, 1) + ); + +// R52 = R00 == R30; +// Instr #225 +SDNode *eq31 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload36, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere15, 0) + ); + +SDValue ct73 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #226 +SDNode *nop16 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct73, + // glue (or chain) input edge + SDValue(eq31, 1) + ); + +// WHERE_EQ; +// Instr #227 +SDNode *whereeq16 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq31, 0), + // glue (or chain) input edge + SDValue(nop16, 0) + ); + +// R60 = R18 & R30; +// Instr #228 +SDNode *and22 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(or17, 0), + SDValue(vload17, 0), + // glue (or chain) input edge + SDValue(whereeq16, 1) + ); + +// R54 = R54 - R30; +// Instr #229 +SDNode *sub16 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl10, 0), + SDValue(vload1, 0), + SDValue(ishl10, 0), + // glue (or chain) input edge + SDValue(and22, 1) + ); + +// R54 = R30 << R54; +// Instr #230 +SDNode *shl5 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(sub16, 0), + SDValue(sub16, 0), + // glue (or chain) input edge + SDValue(sub16, 1) + ); + +// R59 = R55 & R54; +// Instr #231 +SDNode *and23 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl5, 0), + SDValue(shr3, 0), + SDValue(vload18, 0), + // glue (or chain) input edge + SDValue(shl5, 1) + ); + +// R55 = R55 ^ R59; +// Instr #232 +SDNode *xor1 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and23, 0), + SDValue(shr3, 0), + SDValue(shr3, 0), + // glue (or chain) input edge + SDValue(and23, 1) + ); + +// R59 = R59 == R31; +// Instr #233 +SDNode *eq32 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and23, 0), + SDValue(vload0, 0), + SDValue(and23, 0), + // glue (or chain) input edge + SDValue(xor1, 1) + ); + +// R59 = R30 - R59; +// Instr #234 +SDNode *sub17 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq32, 0), + SDValue(eq32, 0), + // glue (or chain) input edge + SDValue(eq32, 1) + ); + +// R58 = R55 == R31; +// Instr #235 +SDNode *eq33 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(xor1, 0), + SDValue(vload0, 0), + SDValue(vload19, 0), + // glue (or chain) input edge + SDValue(sub17, 1) + ); + +// R58 = R30 - R58; +// Instr #236 +SDNode *sub18 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq33, 0), + SDValue(eq33, 0), + // glue (or chain) input edge + SDValue(eq33, 1) + ); + +// R57 = R58 | R60; +// Instr #237 +SDNode *or19 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and22, 0), + SDValue(sub18, 0), + SDValue(vload20, 0), + // glue (or chain) input edge + SDValue(sub18, 1) + ); + +// R57 = R57 & R59; +// Instr #238 +SDNode *and24 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub17, 0), + SDValue(or19, 0), + SDValue(or19, 0), + // glue (or chain) input edge + SDValue(or19, 1) + ); + +// END_WHERE; +// Instr #239 +SDNode *endwhere16 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(and24, 1) + ); + +// R52 = R00 == R30; +// Instr #240 +SDNode *eq34 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload36, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere16, 0) + ); + +SDValue ct74 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #241 +SDNode *nop17 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct74, + // glue (or chain) input edge + SDValue(eq34, 1) + ); + +// WHERE_EQ; +// Instr #242 +SDNode *whereeq17 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq34, 0), + // glue (or chain) input edge + SDValue(nop17, 0) + ); + +SDValue ct75 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R19 = R16 << 10; +// Instr #243 +SDNode *ishl12 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload38, 0), + ct75, + SDValue(or18, 0), + // glue (or chain) input edge + SDValue(whereeq17, 1) + ); + +// R18 = R18 & R10; +// Instr #244 +SDNode *and25 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload4, 0), + SDValue(or17, 0), + SDValue(or17, 0), + // glue (or chain) input edge + SDValue(ishl12, 1) + ); + +// R19 = R19 | R18; +// Instr #245 +SDNode *or20 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and25, 0), + SDValue(ishl12, 0), + SDValue(ishl12, 0), + // glue (or chain) input edge + SDValue(and25, 1) + ); + +// R19 = R57 + R19; +// Instr #246 +SDNode *add3 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or20, 0), + SDValue(and24, 0), + SDValue(or20, 0), + // glue (or chain) input edge + SDValue(or20, 1) + ); + +// R19 = R19 | R15; +// Instr #247 +SDNode *resF16 /*or21*/ = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(xor0, 0), + SDValue(add3, 0), + SDValue(add3, 0), + // glue (or chain) input edge + SDValue(add3, 1) + ); + +// END_WHERE; +// Instr #248 +SDNode *lastNode /*endwhere17*/ = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, +// Alex: MVT::Glue, + MVT::Other, + // glue (or chain) input edge +// Alex: SDValue(or21, 1) + SDValue(resF16, 1) + ); + Index: lib/Target/Connex/Select_MULTi32_ComplementedRepresentation_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_MULTi32_ComplementedRepresentation_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_MULTi32_ComplementedRepresentation_OpincaaCodeGen.cpp @@ -0,0 +1,345 @@ +// Copied from /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/MULTi32_manual_Complemented_radix_216_representation/DumpISel_OpincaaCodeGen_old27_220.cpp + + +// R27 is REG_SRC1. It is represented by result of nodeOpSrcCast1. +// R28 is REG_SRC2. It is represented by result of nodeOpSrcCast2. + + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 27. + + + + +SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast2, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +// MULT_U(R28, R27); +// Instr #2 +SDNode *mult_u0 = CurDAG->getMachineNode( + Connex::MULT_U_H, + DL, + MVT::Other, + SDValue(nodeOpSrcCast2, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +// R26 = MULT_LOW(); +// Instr #3 +SDNode *multlo0 = CurDAG->getMachineNode( + Connex::MULTLO_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(mult_u0, 0) + ); + +// R25 = MULT_HIGH(); +// Instr #4 +SDNode *multhi0 = CurDAG->getMachineNode( + Connex::MULTHI_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(multlo0, 1) + ); + +// CELL_SHR(R27, R30); +// Instr #5 +SDNode *cellshr0 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Other, + SDValue(nodeOpSrcCast1, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(multhi0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #6 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Other, + ct2, + // glue (or chain) input edge + SDValue(cellshr0, 0) + ); + +// R24 = SHIFT_REG; +// Instr #7 +SDNode *ldsh0 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +// MULT_U(R24, R28); +// Instr #8 +SDNode *mult_u1 = CurDAG->getMachineNode( + Connex::MULT_U_H, + DL, + MVT::Other, + SDValue(ldsh0, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(ldsh0, 1) + ); + +// R24 = MULT_LOW(); +// Instr #9 +SDNode *multlo1 = CurDAG->getMachineNode( + Connex::MULTLO_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(mult_u1, 0) + ); + +// CELL_SHR(R28, R30); +// Instr #10 +SDNode *cellshr1 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Other, + SDValue(nodeOpSrcCast2, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(multlo1, 1) + ); + +SDValue ct3 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #11 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Other, + ct3, + // glue (or chain) input edge + SDValue(cellshr1, 0) + ); + +// R23 = SHIFT_REG; +// Instr #12 +SDNode *ldsh1 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// MULT_U(R23, R27); +// Instr #13 +SDNode *mult_u2 = CurDAG->getMachineNode( + Connex::MULT_U_H, + DL, + MVT::Other, + SDValue(ldsh1, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(ldsh1, 1) + ); + +// R23 = MULT_LOW(); +// Instr #14 +SDNode *multlo2 = CurDAG->getMachineNode( + Connex::MULTLO_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(mult_u2, 0) + ); + +// CELL_SHR(R25, R30); +// Instr #15 +SDNode *cellshr2 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Other, + SDValue(multhi0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(multlo2, 1) + ); + +SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #16 +SDNode *nop2 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Other, + ct4, + // glue (or chain) input edge + SDValue(cellshr2, 0) + ); + +// R21 = SHIFT_REG; +// Instr #17 +SDNode *ldsh2 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(nop2, 0) + ); + +// R14 = INDEX; +// Instr #18 +SDNode *ldix0 = CurDAG->getMachineNode( + Connex::LDIX_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + // glue (or chain) input edge + SDValue(ldsh2, 1) + ); + +// R13 = R14 & R30; +// Instr #19 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + SDValue(vload1, 0), + SDValue(ldix0, 0), + // glue (or chain) input edge + SDValue(ldix0, 1) + ); + +// R12 = R13 == R30; +// Instr #20 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + SDValue(and0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct5 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #21 +SDNode *nop3 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Other, + ct5, + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// WHERE_EQ; +// Instr #22 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Other, + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(nop3, 0) + ); + +// R26 = R21 | R21; +// Instr #23 +SDNode *or0 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + SDValue(ldsh2, 0), + SDValue(ldsh2, 0), + SDValue(multlo0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// R26 = R24 + R26; +// Instr #24 +SDNode *add0 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + SDValue(or0, 0), + SDValue(multlo1, 0), + SDValue(or0, 0), + // glue (or chain) input edge + SDValue(or0, 1) + ); + +// R26 = R23 + R26; +// Instr #25 +SDNode *resH /*add1*/ = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Other, + SDValue(add0, 0), + SDValue(multlo2, 0), + SDValue(add0, 0), + // glue (or chain) input edge + SDValue(add0, 1) + ); + +// END_WHERE; +// Instr #26 +SDNode *lastNode /*endwhere0*/ = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Other, + // glue (or chain) input edge + SDValue(resH /*add1*/, 1) + ); + + +//SDNode *lastNode = resF16; Index: lib/Target/Connex/Select_REDf16_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_REDf16_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_REDf16_OpincaaCodeGen.cpp @@ -0,0 +1,1554 @@ +// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/REDf16_manual/DumpISel_OpincaaCodeGen.cpp + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: red.f16. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 122. + + + +SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R31 = 1; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast, 1) + ); + +SDValue ct1 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R30 = 0; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(31, DL, MVT::i16, true, false); +// R29 = 31; +// Instr #2 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +SDValue ct3 = CurDAG->getConstant(1023, DL, MVT::i16, true, false); +// R13 = 1023; +// Instr #3 +SDNode *vload3 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +SDValue ct4 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R12 = 31744; +// Instr #4 +SDNode *vload4 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(vload3, 1) + ); + +SDValue ct5 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false); +// R11 = -32768; +// Instr #5 +SDNode *vload5 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct5, + // glue (or chain) input edge + SDValue(vload4, 1) + ); + +SDValue ct6 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R10 = 1024; +// Instr #6 +SDNode *vload6 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct6, + // glue (or chain) input edge + SDValue(vload5, 1) + ); + +// R25 = R28 & R11; +// Instr #7 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast, 0), + // glue (or chain) input edge + SDValue(vload6, 1) + ); + +// R26 = R28 & R12; +// Instr #8 +SDNode *and1 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload4, 0), + SDValue(nodeOpSrcCast, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct7 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R26 = R26 >> 10; +// Instr #9 +SDNode *ishr0 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and1, 0), + ct7, + // glue (or chain) input edge + SDValue(and1, 1) + ); + +// R27 = R28 & R13; +// Instr #10 +SDNode *and2 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(nodeOpSrcCast, 0), + // glue (or chain) input edge + SDValue(ishr0, 1) + ); + +// R17 = R30 < R27; +// Instr #11 +SDNode *lt0 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(and2, 1) + ); + +// R16 = R26 == R30; +// Instr #12 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(lt0, 1) + ); + +// R09 = R16 & R17; +// Instr #13 +SDNode *and3 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt0, 0), + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// R09 = R09 == R31; +// Instr #14 +SDNode *eq1 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and3, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and3, 1) + ); + +SDValue ct8 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #15 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct8, + // glue (or chain) input edge + SDValue(eq1, 1) + ); + +// WHERE_EQ; +// Instr #16 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq1, 0), + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +SDValue ct9 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R26 = 1; +// Instr #17 +SDNode *vload7 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct9, + SDValue(ishr0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// END_WHERE; +// Instr #18 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload7, 1) + ); + +// R17 = R26 == R29; +// Instr #19 +SDNode *eq2 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +// R17 = R17 | R16; +// Instr #20 +SDNode *or0 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + SDValue(eq2, 0), + // glue (or chain) input edge + SDValue(eq2, 1) + ); + +// R17 = R17 == R30; +// Instr #21 +SDNode *eq3 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(or0, 1) + ); + +SDValue ct10 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #22 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct10, + // glue (or chain) input edge + SDValue(eq3, 1) + ); + +// WHERE_EQ; +// Instr #23 +SDNode *whereeq1 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq3, 0), + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R27 = R27 | R10; +// Instr #24 +SDNode *or1 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(and2, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(whereeq1, 1) + ); + +// END_WHERE; +// Instr #25 +SDNode *endwhere1 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or1, 1) + ); + +// R18 = R26 == R29; +// Instr #26 +SDNode *eq4 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere1, 0) + ); + +// R17 = R27 == R30; +// Instr #27 +SDNode *eq5 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or1, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(eq4, 1) + ); + +// R09 = R31 - R17; +// Instr #28 +SDNode *sub0 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(eq5, 0), + // glue (or chain) input edge + SDValue(eq5, 1) + ); + +// R09 = R09 & R18; +// Instr #29 +SDNode *and4 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq4, 0), + SDValue(sub0, 0), + // glue (or chain) input edge + SDValue(sub0, 1) + ); + +// REDUCE(R09); +// Instr #30 +SDNode *sumRed0 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(and4, 0), + // glue (or chain) input edge + SDValue(and4, 1) + ); + +// R24 = R18 & R17; +// Instr #31 +SDNode *and5 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq5, 0), + SDValue(eq4, 0), + // glue (or chain) input edge + SDValue(sumRed0, 0) + ); + +// R09 = R25 == R30; +// Instr #32 +SDNode *eq6 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and5, 1) + ); + +// R16 = R24 & R09; +// Instr #33 +SDNode *and6 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq6, 0), + SDValue(and5, 0), + // glue (or chain) input edge + SDValue(eq6, 1) + ); + +// REDUCE(R16); +// Instr #34 +SDNode *sumRed1 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(and6, 1) + ); + +// R09 = R31 - R09; +// Instr #35 +SDNode *sub1 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(eq6, 0), + // glue (or chain) input edge + SDValue(sumRed1, 0) + ); + +// R16 = R24 & R09; +// Instr #36 +SDNode *and7 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub1, 0), + SDValue(and5, 0), + // glue (or chain) input edge + SDValue(sub1, 1) + ); + +// REDUCE(R16); +// Instr #37 +SDNode *sumRed2 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(and7, 0), + // glue (or chain) input edge + SDValue(and7, 1) + ); + +// R09 = R25 == R11; +// Instr #38 +SDNode *eq7 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload5, 0), + // glue (or chain) input edge + SDValue(sumRed2, 0) + ); + +SDValue ct11 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #39 +SDNode *nop2 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct11, + // glue (or chain) input edge + SDValue(eq7, 1) + ); + +// WHERE_EQ; +// Instr #40 +SDNode *whereeq2 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq7, 0), + // glue (or chain) input edge + SDValue(nop2, 0) + ); + +// R27 = R30 - R27; +// Instr #41 +SDNode *sub2 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(or1, 0), + SDValue(or1, 0), + // glue (or chain) input edge + SDValue(whereeq2, 1) + ); + +// END_WHERE; +// Instr #42 +SDNode *endwhere2 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub2, 1) + ); + +SDValue ct12 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R02 = R26 << 0; +// Instr #43 +SDNode *ishl0 = CurDAG->getMachineNode( + Connex::ISHLV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + ct12, + // glue (or chain) input edge + SDValue(endwhere2, 0) + ); + +SDValue ct13 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R02 = 0; +// Instr #44 +SDNode *vload8 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct13, + // glue (or chain) input edge + SDValue(ishl0, 1) + ); + +SDValue ct14 = CurDAG->getConstant(6, DL, MVT::i16, true, false); +// R24 = 6; +// Instr #45 +SDNode *vload9 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct14, + // glue (or chain) input edge + SDValue(vload8, 1) + ); + +// R19 = R26 < R24; +// Instr #46 +SDNode *lt1 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload9, 0), + // glue (or chain) input edge + SDValue(vload9, 1) + ); + +// R17 = R02 < R26; +// Instr #47 +SDNode *lt2 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload8, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(lt1, 1) + ); + +// R02 = R31 + R02; +// Instr #48 +SDNode *add0 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload8, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt2, 1) + ); + +// R09 = R19 & R17; +// Instr #49 +SDNode *and8 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt2, 0), + SDValue(lt1, 0), + // glue (or chain) input edge + SDValue(add0, 1) + ); + +// R09 = R09 == R31; +// Instr #50 +SDNode *eq8 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and8, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and8, 1) + ); + +SDValue ct15 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #51 +SDNode *nop3 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct15, + // glue (or chain) input edge + SDValue(eq8, 1) + ); + +// WHERE_EQ; +// Instr #52 +SDNode *whereeq3 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq8, 0), + // glue (or chain) input edge + SDValue(nop3, 0) + ); + +// R19 = R26 - R02; +// Instr #53 +SDNode *sub3 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add0, 0), + SDValue(lt1, 0), + // glue (or chain) input edge + SDValue(whereeq3, 1) + ); + +// R27 = R27 << R19; +// Instr #54 +SDNode *shl0 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub2, 0), + SDValue(sub3, 0), + SDValue(sub2, 0), + // glue (or chain) input edge + SDValue(sub3, 1) + ); + +// REDUCE(R27); +// Instr #55 +SDNode *sumRed3 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(shl0, 0), + // glue (or chain) input edge + SDValue(shl0, 1) + ); + +// END_WHERE; +// Instr #56 +SDNode *endwhere3 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sumRed3, 0) + ); + +SDValue ct16 = CurDAG->getConstant(5, DL, MVT::i16, true, false); +// R02 = 5; +// Instr #57 +SDNode *vload10 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct16, + // glue (or chain) input edge + SDValue(endwhere3, 0) + ); + +SDValue ct17 = CurDAG->getConstant(11, DL, MVT::i16, true, false); +// R24 = 11; +// Instr #58 +SDNode *vload11 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct17, + // glue (or chain) input edge + SDValue(vload10, 1) + ); + +// R19 = R26 < R24; +// Instr #59 +SDNode *lt3 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload11, 0), + // glue (or chain) input edge + SDValue(vload11, 1) + ); + +// R17 = R02 < R26; +// Instr #60 +SDNode *lt4 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload10, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(lt3, 1) + ); + +// R02 = R31 + R02; +// Instr #61 +SDNode *add1 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload10, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt4, 1) + ); + +// R09 = R19 & R17; +// Instr #62 +SDNode *and9 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt4, 0), + SDValue(lt3, 0), + // glue (or chain) input edge + SDValue(add1, 1) + ); + +// R09 = R09 == R31; +// Instr #63 +SDNode *eq9 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and9, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and9, 1) + ); + +SDValue ct18 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #64 +SDNode *nop4 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct18, + // glue (or chain) input edge + SDValue(eq9, 1) + ); + +// WHERE_EQ; +// Instr #65 +SDNode *whereeq4 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq9, 0), + // glue (or chain) input edge + SDValue(nop4, 0) + ); + +// R19 = R26 - R02; +// Instr #66 +SDNode *sub4 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add1, 0), + SDValue(lt3, 0), + // glue (or chain) input edge + SDValue(whereeq4, 1) + ); + +// R27 = R27 << R19; +// Instr #67 +SDNode *shl1 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl0, 0), + SDValue(sub4, 0), + SDValue(shl0, 0), + // glue (or chain) input edge + SDValue(sub4, 1) + ); + +// REDUCE(R27); +// Instr #68 +SDNode *sumRed4 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(shl1, 0), + // glue (or chain) input edge + SDValue(shl1, 1) + ); + +// END_WHERE; +// Instr #69 +SDNode *endwhere4 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sumRed4, 0) + ); + +SDValue ct19 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R02 = 10; +// Instr #70 +SDNode *vload12 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct19, + // glue (or chain) input edge + SDValue(endwhere4, 0) + ); + +SDValue ct20 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R24 = 16; +// Instr #71 +SDNode *vload13 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct20, + // glue (or chain) input edge + SDValue(vload12, 1) + ); + +// R19 = R26 < R24; +// Instr #72 +SDNode *lt5 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload13, 0), + // glue (or chain) input edge + SDValue(vload13, 1) + ); + +// R17 = R02 < R26; +// Instr #73 +SDNode *lt6 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload12, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(lt5, 1) + ); + +// R02 = R31 + R02; +// Instr #74 +SDNode *add2 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload12, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt6, 1) + ); + +// R09 = R19 & R17; +// Instr #75 +SDNode *and10 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt6, 0), + SDValue(lt5, 0), + // glue (or chain) input edge + SDValue(add2, 1) + ); + +// R09 = R09 == R31; +// Instr #76 +SDNode *eq10 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and10, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and10, 1) + ); + +SDValue ct21 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #77 +SDNode *nop5 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct21, + // glue (or chain) input edge + SDValue(eq10, 1) + ); + +// WHERE_EQ; +// Instr #78 +SDNode *whereeq5 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq10, 0), + // glue (or chain) input edge + SDValue(nop5, 0) + ); + +// R19 = R26 - R02; +// Instr #79 +SDNode *sub5 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add2, 0), + SDValue(lt5, 0), + // glue (or chain) input edge + SDValue(whereeq5, 1) + ); + +// R27 = R27 << R19; +// Instr #80 +SDNode *shl2 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl1, 0), + SDValue(sub5, 0), + SDValue(shl1, 0), + // glue (or chain) input edge + SDValue(sub5, 1) + ); + +// REDUCE(R27); +// Instr #81 +SDNode *sumRed5 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(shl2, 0), + // glue (or chain) input edge + SDValue(shl2, 1) + ); + +// END_WHERE; +// Instr #82 +SDNode *endwhere5 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sumRed5, 0) + ); + +SDValue ct22 = CurDAG->getConstant(15, DL, MVT::i16, true, false); +// R02 = 15; +// Instr #83 +SDNode *vload14 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct22, + // glue (or chain) input edge + SDValue(endwhere5, 0) + ); + +SDValue ct23 = CurDAG->getConstant(21, DL, MVT::i16, true, false); +// R24 = 21; +// Instr #84 +SDNode *vload15 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct23, + // glue (or chain) input edge + SDValue(vload14, 1) + ); + +// R19 = R26 < R24; +// Instr #85 +SDNode *lt7 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload15, 0), + // glue (or chain) input edge + SDValue(vload15, 1) + ); + +// R17 = R02 < R26; +// Instr #86 +SDNode *lt8 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload14, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(lt7, 1) + ); + +// R02 = R31 + R02; +// Instr #87 +SDNode *add3 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload14, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt8, 1) + ); + +// R09 = R19 & R17; +// Instr #88 +SDNode *and11 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt8, 0), + SDValue(lt7, 0), + // glue (or chain) input edge + SDValue(add3, 1) + ); + +// R09 = R09 == R31; +// Instr #89 +SDNode *eq11 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and11, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and11, 1) + ); + +SDValue ct24 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #90 +SDNode *nop6 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct24, + // glue (or chain) input edge + SDValue(eq11, 1) + ); + +// WHERE_EQ; +// Instr #91 +SDNode *whereeq6 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq11, 0), + // glue (or chain) input edge + SDValue(nop6, 0) + ); + +// R19 = R26 - R02; +// Instr #92 +SDNode *sub6 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add3, 0), + SDValue(lt7, 0), + // glue (or chain) input edge + SDValue(whereeq6, 1) + ); + +// R27 = R27 << R19; +// Instr #93 +SDNode *shl3 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl2, 0), + SDValue(sub6, 0), + SDValue(shl2, 0), + // glue (or chain) input edge + SDValue(sub6, 1) + ); + +// REDUCE(R27); +// Instr #94 +SDNode *sumRed6 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(shl3, 0), + // glue (or chain) input edge + SDValue(shl3, 1) + ); + +// END_WHERE; +// Instr #95 +SDNode *endwhere6 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sumRed6, 0) + ); + +SDValue ct25 = CurDAG->getConstant(20, DL, MVT::i16, true, false); +// R02 = 20; +// Instr #96 +SDNode *vload16 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct25, + // glue (or chain) input edge + SDValue(endwhere6, 0) + ); + +SDValue ct26 = CurDAG->getConstant(26, DL, MVT::i16, true, false); +// R24 = 26; +// Instr #97 +SDNode *vload17 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct26, + // glue (or chain) input edge + SDValue(vload16, 1) + ); + +// R19 = R26 < R24; +// Instr #98 +SDNode *lt9 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload17, 0), + // glue (or chain) input edge + SDValue(vload17, 1) + ); + +// R17 = R02 < R26; +// Instr #99 +SDNode *lt10 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload16, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(lt9, 1) + ); + +// R02 = R31 + R02; +// Instr #100 +SDNode *add4 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload16, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt10, 1) + ); + +// R09 = R19 & R17; +// Instr #101 +SDNode *and12 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt10, 0), + SDValue(lt9, 0), + // glue (or chain) input edge + SDValue(add4, 1) + ); + +// R09 = R09 == R31; +// Instr #102 +SDNode *eq12 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and12, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and12, 1) + ); + +SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #103 +SDNode *nop7 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct27, + // glue (or chain) input edge + SDValue(eq12, 1) + ); + +// WHERE_EQ; +// Instr #104 +SDNode *whereeq7 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + // glue (or chain) input edge + SDValue(nop7, 0) + ); + +// R19 = R26 - R02; +// Instr #105 +SDNode *sub7 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add4, 0), + SDValue(lt9, 0), + // glue (or chain) input edge + SDValue(whereeq7, 1) + ); + +// R27 = R27 << R19; +// Instr #106 +SDNode *shl4 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl3, 0), + SDValue(sub7, 0), + SDValue(shl3, 0), + // glue (or chain) input edge + SDValue(sub7, 1) + ); + +// REDUCE(R27); +// Instr #107 +SDNode *sumRed7 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(shl4, 0), + // glue (or chain) input edge + SDValue(shl4, 1) + ); + +// END_WHERE; +// Instr #108 +SDNode *endwhere7 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sumRed7, 0) + ); + +SDValue ct28 = CurDAG->getConstant(25, DL, MVT::i16, true, false); +// R02 = 25; +// Instr #109 +SDNode *vload18 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct28, + // glue (or chain) input edge + SDValue(endwhere7, 0) + ); + +SDValue ct29 = CurDAG->getConstant(31, DL, MVT::i16, true, false); +// R24 = 31; +// Instr #110 +SDNode *vload19 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct29, + // glue (or chain) input edge + SDValue(vload18, 1) + ); + +// R19 = R26 < R24; +// Instr #111 +SDNode *lt11 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(vload19, 0), + // glue (or chain) input edge + SDValue(vload19, 1) + ); + +// R17 = R02 < R26; +// Instr #112 +SDNode *lt12 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload18, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(lt11, 1) + ); + +// R02 = R31 + R02; +// Instr #113 +SDNode *add5 = CurDAG->getMachineNode( + Connex::ADDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload18, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(lt12, 1) + ); + +// R09 = R19 & R17; +// Instr #114 +SDNode *and13 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt12, 0), + SDValue(lt11, 0), + // glue (or chain) input edge + SDValue(add5, 1) + ); + +// R09 = R09 == R31; +// Instr #115 +SDNode *eq13 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and13, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and13, 1) + ); + +SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #116 +SDNode *nop8 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct30, + // glue (or chain) input edge + SDValue(eq13, 1) + ); + +// WHERE_EQ; +// Instr #117 +SDNode *whereeq8 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + // glue (or chain) input edge + SDValue(nop8, 0) + ); + +// R19 = R26 - R02; +// Instr #118 +SDNode *sub8 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add5, 0), + SDValue(lt11, 0), + // glue (or chain) input edge + SDValue(whereeq8, 1) + ); + +// R27 = R27 << R19; +// Instr #119 +SDNode *shl5 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl4, 0), + SDValue(sub8, 0), + SDValue(shl4, 0), + // glue (or chain) input edge + SDValue(sub8, 1) + ); + +// REDUCE(R27); +// Instr #120 +SDNode *sumRed8 = CurDAG->getMachineNode( + Connex::RED_H, + DL, + MVT::Glue, + SDValue(shl5, 0), + // glue (or chain) input edge + SDValue(shl5, 1) + ); + +// END_WHERE; +// Instr #121 +SDNode *reduceH /* endwhere8 */ = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, +// Alex: MVT::Glue, // Error: <getNodeId() == -1 && "Node already inserted!"' failed.>> + MVT::Other, + // glue (or chain) input edge + SDValue(sumRed8, 0) + ); + Index: lib/Target/Connex/Select_REDi32_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_REDi32_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_REDi32_OpincaaCodeGen.cpp @@ -0,0 +1,184 @@ +// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/RED_i32_manual/DumpISel_OpincaaCodeGen_old04_300.cpp + + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 14. + + + +SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R29 = 1; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast, 1) + ); + +// CELL_SHR(R28, R29); +// Instr #1 +SDNode *cellshr0 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Glue, + SDValue(nodeOpSrcCast, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #2 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(cellshr0, 0) + ); + +// R27 = SHIFT_REG; +// Instr #3 +SDNode *ldsh0 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +// R26 = INDEX; +// Instr #4 +SDNode *ldix0 = CurDAG->getMachineNode( + Connex::LDIX_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(ldsh0, 1) + ); + +// R25 = R26 & R29; +// Instr #5 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(ldix0, 0), + // glue (or chain) input edge + SDValue(ldix0, 1) + ); + +// R24 = R25 == R29; +// Instr #6 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #7 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// WHERE_EQ; +// Instr #8 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +SDValue ct3 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R28 = 0; +// Instr #9 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + SDValue(nodeOpSrcCast, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +SDValue ct4 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R27 = 0; +// Instr #10 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct4, + SDValue(ldsh0, 0), + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +// END_WHERE; +// Instr #11 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +// REDUCE_U(R28); +// Instr #12 +SDNode *sumRedU0 = CurDAG->getMachineNode( + Connex::RED_U_H, + DL, + MVT::Glue, + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +// REDUCE_U(R27); +// Instr #13 +SDNode *reduceHigh16 /*sumRedU1*/ = CurDAG->getMachineNode( + Connex::RED_U_H, + DL, +// Alex: MVT::Glue, + MVT::Other, + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(sumRedU0, 0) + ); + Index: lib/Target/Connex/Select_SHRAi32_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_SHRAi32_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_SHRAi32_OpincaaCodeGen.cpp @@ -0,0 +1,456 @@ +// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/SHRA_i32_manual/DumpISel_OpincaaCodeGen_old13_927.cpp + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 33. + + + +/* Alex: added manually to have predicated instructions refer to tied-to + constraints to these nodes (destination registers of predicated instr) + without initializing the respective dest registers, since it's not necessary. +*/ +SDValue ct21Node = CurDAG->getConstant(21, DL, MVT::i16, true, false); +SDNode *r21Node = CurDAG->getMachineNode( + Connex::VLOAD_BOGUS_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct21Node, + // glue (or chain) input edge + SDValue(nodeOpSrcCast1, 1) + ); + +SDValue ct22Node = CurDAG->getConstant(22, DL, MVT::i16, true, false); +SDNode *r22Node = CurDAG->getMachineNode( + Connex::VLOAD_BOGUS_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct22Node, + // glue (or chain) input edge + SDValue(r21Node, 1) + ); + + +SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(r22Node, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R10 = 16; +// Instr #2 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +SDValue ct3 = CurDAG->getConstant(31, DL, MVT::i16, true, false); +// R08 = 31; +// Instr #3 +SDNode *vload3 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +// R27 = R27 & R08; +// Instr #4 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(vload3, 1) + ); + +// R25 = INDEX; +// Instr #5 +SDNode *ldix0 = CurDAG->getMachineNode( + Connex::LDIX_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(and0, 1) + ); + +// R25 = R25 & R30; +// Instr #6 +SDNode *and1 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(ldix0, 0), + // glue (or chain) input edge + SDValue(ldix0, 1) + ); + +// CELL_SHR(R27, R25); +// Instr #7 +SDNode *cellshr0 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Glue, + SDValue(and0, 0), + SDValue(and1, 0), + // glue (or chain) input edge + SDValue(and1, 1) + ); + +SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #8 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(cellshr0, 0) + ); + +// R27 = SHIFT_REG; +// Instr #9 +SDNode *ldsh0 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +// R20 = R10 < R27; +// Instr #10 +SDNode *lt0 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(ldsh0, 0), + // glue (or chain) input edge + SDValue(ldsh0, 1) + ); + +// R29 = SHRA(R28, R27); +// Instr #11 +SDNode *shra0 = CurDAG->getMachineNode( + Connex::SHRAV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(nodeOpSrcCast1, 0), + SDValue(ldsh0, 0), + // glue (or chain) input edge + SDValue(lt0, 1) + ); + +// CELL_SHL(R28, R30); +// Instr #12 +SDNode *cellshl0 = CurDAG->getMachineNode( + Connex::CELLSHL_H, + DL, + MVT::Glue, + SDValue(nodeOpSrcCast1, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(shra0, 1) + ); + +SDValue ct5 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #13 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct5, + // glue (or chain) input edge + SDValue(cellshl0, 0) + ); + +// R23 = SHIFT_REG; +// Instr #14 +SDNode *ldsh1 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R25 = R25 == R31; +// Instr #15 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and1, 0), + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(ldsh1, 1) + ); + +// R24 = R20 & R25; +// Instr #16 +SDNode *and2 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + SDValue(lt0, 0), + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// R19 = R24 == R30; +// Instr #17 +SDNode *eq1 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and2, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and2, 1) + ); + +SDValue ct6 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #18 +SDNode *nop2 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct6, + // glue (or chain) input edge + SDValue(eq1, 1) + ); + +// WHERE_EQ; +// Instr #19 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq1, 0), + // glue (or chain) input edge + SDValue(nop2, 0) + ); + +// R21 = R27 - R10; +// Instr #20 +SDNode *sub0 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ldsh0, 0), + SDValue(vload2, 0), + SDValue(r21Node, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// R29 = SHRA(R23, R21); +// Instr #21 +SDNode *shra1 = CurDAG->getMachineNode( + Connex::SHRAV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ldsh1, 0), + SDValue(sub0, 0), + SDValue(shra0, 0), + // glue (or chain) input edge + SDValue(sub0, 1) + ); + +// END_WHERE; +// Instr #22 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(shra1, 1) + ); + +// R20 = R30 - R20; +// Instr #23 +SDNode *sub1 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(lt0, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +// R24 = R20 & R25; +// Instr #24 +SDNode *and3 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + SDValue(sub1, 0), + // glue (or chain) input edge + SDValue(sub1, 1) + ); + +// R19 = R24 == R30; +// Instr #25 +SDNode *eq2 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and3, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and3, 1) + ); + +SDValue ct7 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #26 +SDNode *nop3 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct7, + // glue (or chain) input edge + SDValue(eq2, 1) + ); + +// WHERE_EQ; +// Instr #27 +SDNode *whereeq1 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq2, 0), + // glue (or chain) input edge + SDValue(nop3, 0) + ); + +// R21 = R10 - R27; +// Instr #28 +SDNode *sub2 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(ldsh0, 0), + SDValue(sub0, 0), + // glue (or chain) input edge + SDValue(whereeq1, 1) + ); + +// R22 = R23 << R21; +// Instr #29 +SDNode *shl0 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ldsh1, 0), + SDValue(sub2, 0), + SDValue(r22Node, 0), + // glue (or chain) input edge + SDValue(sub2, 1) + ); + +// R29 = R28 >> R27; +// Instr #30 +SDNode *shr0 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(nodeOpSrcCast1, 0), + SDValue(ldsh0, 0), + SDValue(shra1, 0), + // glue (or chain) input edge + SDValue(shl0, 1) + ); + +// R29 = R29 | R22; +// Instr #31 +SDNode *resH /*or0*/ = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl0, 0), + SDValue(shr0, 0), + SDValue(shr0, 0), + // glue (or chain) input edge + SDValue(shr0, 1) + ); + +// END_WHERE; +// Instr #32 +SDNode *lastNode /*endwhere1*/ = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, +// MVT::Glue, + MVT::Other, + // glue (or chain) input edge + SDValue(resH /*or0*/, 1) + ); + Index: lib/Target/Connex/Select_SUBf16_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_SUBf16_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_SUBf16_OpincaaCodeGen.cpp @@ -0,0 +1,3637 @@ +// From /home/asusu/LLVM/Tests/opincaa_standalone_apps/Emulate_f16/ADD_SUB_f16_manual/DumpISel_OpincaaCodeGen_old37_C10_SUBf16.cpp + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: add_or_sub.f16. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 280. + + + + +SDValue ct0 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R14 = 1; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast1, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #2 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +SDValue ct3 = CurDAG->getConstant(16, DL, MVT::i16, true, false); +// R29 = 16; +// Instr #3 +SDNode *vload3 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +SDValue ct4 = CurDAG->getConstant(31, DL, MVT::i16, true, false); +// R28 = 31; +// Instr #4 +SDNode *vload4 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(vload3, 1) + ); + +SDValue ct5 = CurDAG->getConstant(1023, DL, MVT::i16, true, false); +// R13 = 1023; +// Instr #5 +SDNode *vload5 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct5, + // glue (or chain) input edge + SDValue(vload4, 1) + ); + +SDValue ct6 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R12 = 31744; +// Instr #6 +SDNode *vload6 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct6, + // glue (or chain) input edge + SDValue(vload5, 1) + ); + +SDValue ct7 = CurDAG->getConstant(-32768, DL, MVT::i16, true, false); +// R11 = -32768; +// Instr #7 +SDNode *vload7 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct7, + // glue (or chain) input edge + SDValue(vload6, 1) + ); + +SDValue ct8 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R10 = 1024; +// Instr #8 +SDNode *vload8 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct8, + // glue (or chain) input edge + SDValue(vload7, 1) + ); + +SDValue ct9 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = 0; +// Instr #9 +SDNode *vload9 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct9, + // glue (or chain) input edge + SDValue(vload8, 1) + ); + +SDValue ct10 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R19 = 0; +// Instr #10 +SDNode *vload10 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct10, + // glue (or chain) input edge + SDValue(vload9, 1) + ); + +SDValue ct11 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = 0; +// Instr #11 +SDNode *vload11 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct11, + // glue (or chain) input edge + SDValue(vload10, 1) + ); + +SDValue ct12 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R61 = 0; +// Instr #12 +SDNode *vload12 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct12, + // glue (or chain) input edge + SDValue(vload11, 1) + ); + +SDValue ct13 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R07 = 0; +// Instr #13 +SDNode *vload13 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct13, + // glue (or chain) input edge + SDValue(vload12, 1) + ); + +SDValue ct14 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R04 = 0; +// Instr #14 +SDNode *vload14 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct14, + // glue (or chain) input edge + SDValue(vload13, 1) + ); + +SDValue ct15 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R03 = 0; +// Instr #15 +SDNode *vload15 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct15, + // glue (or chain) input edge + SDValue(vload14, 1) + ); + +SDValue ct16 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R02 = 0; +// Instr #16 +SDNode *vload16 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct16, + // glue (or chain) input edge + SDValue(vload15, 1) + ); + +SDValue ct17 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R01 = 0; +// Instr #17 +SDNode *vload17 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct17, + // glue (or chain) input edge + SDValue(vload16, 1) + ); + +SDValue ct18 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R00 = 0; +// Instr #18 +SDNode *vload18 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct18, + // glue (or chain) input edge + SDValue(vload17, 1) + ); + +// R24 = R27 & R11; +// Instr #19 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(vload18, 1) + ); + +// R25 = R27 & R12; +// Instr #20 +SDNode *and1 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct19 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R25 = R25 >> 10; +// Instr #21 +SDNode *ishr0 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and1, 0), + ct19, + // glue (or chain) input edge + SDValue(and1, 1) + ); + +// R26 = R27 & R13; +// Instr #22 +SDNode *and2 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast1, 0), + // glue (or chain) input edge + SDValue(ishr0, 1) + ); + +// R18 = R31 < R26; +// Instr #23 +SDNode *lt0 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(and2, 1) + ); + +// R17 = R25 == R31; +// Instr #24 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr0, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(lt0, 1) + ); + +// R09 = R17 & R18; +// Instr #25 +SDNode *and3 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt0, 0), + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// R09 = R09 == R30; +// Instr #26 +SDNode *eq1 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and3, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and3, 1) + ); + +SDValue ct20 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #27 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct20, + // glue (or chain) input edge + SDValue(eq1, 1) + ); + +// WHERE_EQ; +// Instr #28 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq1, 0), + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +SDValue ct21 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R25 = 1; +// Instr #29 +SDNode *vload19 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct21, + SDValue(ishr0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// END_WHERE; +// Instr #30 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload19, 1) + ); + +// R18 = R25 == R28; +// Instr #31 +SDNode *eq2 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload19, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +// R18 = R18 | R17; +// Instr #32 +SDNode *or0 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + SDValue(eq2, 0), + // glue (or chain) input edge + SDValue(eq2, 1) + ); + +// R18 = R18 == R31; +// Instr #33 +SDNode *eq3 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or0, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(or0, 1) + ); + +SDValue ct22 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #34 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct22, + // glue (or chain) input edge + SDValue(eq3, 1) + ); + +// WHERE_EQ; +// Instr #35 +SDNode *whereeq1 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq3, 0), + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R26 = R26 | R10; +// Instr #36 +SDNode *or1 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload8, 0), + SDValue(and2, 0), + SDValue(and2, 0), + // glue (or chain) input edge + SDValue(whereeq1, 1) + ); + +// END_WHERE; +// Instr #37 +SDNode *endwhere1 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or1, 1) + ); + +// R20 = R23 & R11; +// Instr #38 +SDNode *and4 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(endwhere1, 0) + ); + +// R21 = R23 & R12; +// Instr #39 +SDNode *and5 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload6, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(and4, 1) + ); + +SDValue ct23 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R21 = R21 >> 10; +// Instr #40 +SDNode *ishr1 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and5, 0), + ct23, + // glue (or chain) input edge + SDValue(and5, 1) + ); + +// R22 = R23 & R13; +// Instr #41 +SDNode *and6 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(ishr1, 1) + ); + +// R16 = R31 < R22; +// Instr #42 +SDNode *lt1 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(and6, 1) + ); + +// R15 = R21 == R31; +// Instr #43 +SDNode *eq4 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr1, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(lt1, 1) + ); + +// R09 = R15 & R16; +// Instr #44 +SDNode *and7 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt1, 0), + SDValue(eq4, 0), + // glue (or chain) input edge + SDValue(eq4, 1) + ); + +// R09 = R09 == R30; +// Instr #45 +SDNode *eq5 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and7, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and7, 1) + ); + +SDValue ct24 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #46 +SDNode *nop2 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct24, + // glue (or chain) input edge + SDValue(eq5, 1) + ); + +// WHERE_EQ; +// Instr #47 +SDNode *whereeq2 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq5, 0), + // glue (or chain) input edge + SDValue(nop2, 0) + ); + +SDValue ct25 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R21 = 1; +// Instr #48 +SDNode *vload20 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct25, + SDValue(ishr1, 0), + // glue (or chain) input edge + SDValue(whereeq2, 1) + ); + +// END_WHERE; +// Instr #49 +SDNode *endwhere2 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload20, 1) + ); + +// R16 = R21 == R28; +// Instr #50 +SDNode *eq6 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(endwhere2, 0) + ); + +// R16 = R16 | R15; +// Instr #51 +SDNode *or2 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq4, 0), + SDValue(eq6, 0), + // glue (or chain) input edge + SDValue(eq6, 1) + ); + +// R16 = R16 == R31; +// Instr #52 +SDNode *eq7 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or2, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(or2, 1) + ); + +SDValue ct26 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #53 +SDNode *nop3 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct26, + // glue (or chain) input edge + SDValue(eq7, 1) + ); + +// WHERE_EQ; +// Instr #54 +SDNode *whereeq3 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq7, 0), + // glue (or chain) input edge + SDValue(nop3, 0) + ); + +// R22 = R22 | R10; +// Instr #55 +SDNode *or3 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload8, 0), + SDValue(and6, 0), + SDValue(and6, 0), + // glue (or chain) input edge + SDValue(whereeq3, 1) + ); + +// END_WHERE; +// Instr #56 +SDNode *endwhere3 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or3, 1) + ); + +// R50 = R24 == R11; +// Instr #57 +SDNode *eq8 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(endwhere3, 0) + ); + +// R49 = R25 == R28; +// Instr #58 +SDNode *eq9 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload19, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(eq8, 1) + ); + +// R48 = R26 == R31; +// Instr #59 +SDNode *eq10 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or1, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(eq9, 1) + ); + +// R47 = R20 == R11; +// Instr #60 +SDNode *eq11 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and4, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(eq10, 1) + ); + +// R47 = R47 == R31; +// Instr #61 +SDNode *eq12 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq11, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(eq11, 1) + ); + +// R46 = R21 == R28; +// Instr #62 +SDNode *eq13 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + SDValue(vload4, 0), + // glue (or chain) input edge + SDValue(eq12, 1) + ); + +// R45 = R22 == R31; +// Instr #63 +SDNode *eq14 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or3, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(eq13, 1) + ); + +// R07 = R49 & R46; +// Instr #64 +SDNode *and8 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + SDValue(eq9, 0), + // glue (or chain) input edge + SDValue(eq14, 1) + ); + +// R08 = R07 & R50; +// Instr #65 +SDNode *and9 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq8, 0), + SDValue(and8, 0), + // glue (or chain) input edge + SDValue(and8, 1) + ); + +// R44 = ~R47; +// Instr #66 +SDNode *not0 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + // glue (or chain) input edge + SDValue(and9, 1) + ); + +// R08 = R08 & R44; +// Instr #67 +SDNode *and10 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(not0, 0), + SDValue(and9, 0), + // glue (or chain) input edge + SDValue(not0, 1) + ); + +// R44 = ~R50; +// Instr #68 +SDNode *not1 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq8, 0), + // glue (or chain) input edge + SDValue(and10, 1) + ); + +// R44 = R44 & R07; +// Instr #69 +SDNode *and11 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and8, 0), + SDValue(not1, 0), + // glue (or chain) input edge + SDValue(not1, 1) + ); + +// R44 = R44 & R47; +// Instr #70 +SDNode *and12 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq12, 0), + SDValue(and11, 0), + // glue (or chain) input edge + SDValue(and11, 1) + ); + +// R08 = R08 | R44; +// Instr #71 +SDNode *or4 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and12, 0), + SDValue(and10, 0), + // glue (or chain) input edge + SDValue(and12, 1) + ); + +// R07 = ~R45; +// Instr #72 +SDNode *not2 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq14, 0), + // glue (or chain) input edge + SDValue(or4, 1) + ); + +// R07 = R07 & R46; +// Instr #73 +SDNode *and13 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + SDValue(not2, 0), + // glue (or chain) input edge + SDValue(not2, 1) + ); + +// R08 = R08 | R07; +// Instr #74 +SDNode *or5 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and13, 0), + SDValue(or4, 0), + // glue (or chain) input edge + SDValue(and13, 1) + ); + +// R07 = ~R48; +// Instr #75 +SDNode *not3 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq10, 0), + // glue (or chain) input edge + SDValue(or5, 1) + ); + +// R07 = R07 & R49; +// Instr #76 +SDNode *and14 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq9, 0), + SDValue(not3, 0), + // glue (or chain) input edge + SDValue(not3, 1) + ); + +// R08 = R08 | R07; +// Instr #77 +SDNode *or6 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and14, 0), + SDValue(or5, 0), + // glue (or chain) input edge + SDValue(and14, 1) + ); + +// R09 = R08 == R30; +// Instr #78 +SDNode *eq15 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or6, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(or6, 1) + ); + +SDValue ct27 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #79 +SDNode *nop4 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct27, + // glue (or chain) input edge + SDValue(eq15, 1) + ); + +// WHERE_EQ; +// Instr #80 +SDNode *whereeq4 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq15, 0), + // glue (or chain) input edge + SDValue(nop4, 0) + ); + +SDValue ct28 = CurDAG->getConstant(31745, DL, MVT::i16, true, false); +// R19 = 31745; +// Instr #81 +SDNode *vload21 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct28, + SDValue(vload10, 0), + // glue (or chain) input edge + SDValue(whereeq4, 1) + ); + +SDValue ct29 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R14 = 0; +// Instr #82 +SDNode *vload22 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct29, + SDValue(vload0, 0), + // glue (or chain) input edge + SDValue(vload21, 1) + ); + +// END_WHERE; +// Instr #83 +SDNode *endwhere4 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload22, 1) + ); + +// R08 = R49 | R46; +// Instr #84 +SDNode *or7 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + SDValue(eq9, 0), + // glue (or chain) input edge + SDValue(endwhere4, 0) + ); + +// R09 = R08 & R14; +// Instr #85 +SDNode *and15 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload22, 0), + SDValue(or7, 0), + // glue (or chain) input edge + SDValue(or7, 1) + ); + +// R09 = R09 == R30; +// Instr #86 +SDNode *eq16 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and15, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and15, 1) + ); + +SDValue ct30 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #87 +SDNode *nop5 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct30, + // glue (or chain) input edge + SDValue(eq16, 1) + ); + +// WHERE_EQ; +// Instr #88 +SDNode *whereeq5 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq16, 0), + // glue (or chain) input edge + SDValue(nop5, 0) + ); + +SDValue ct31 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R19 = 31744; +// Instr #89 +SDNode *vload23 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct31, + SDValue(vload21, 0), + // glue (or chain) input edge + SDValue(whereeq5, 1) + ); + +// R08 = R50 & R49; +// Instr #90 +SDNode *and16 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq9, 0), + SDValue(eq8, 0), + SDValue(or7, 0), + // glue (or chain) input edge + SDValue(vload23, 1) + ); + +// R07 = R47 & R46; +// Instr #91 +SDNode *and17 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq13, 0), + SDValue(eq12, 0), + SDValue(and14, 0), + // glue (or chain) input edge + SDValue(and16, 1) + ); + +// R08 = R08 | R07; +// Instr #92 +SDNode *or8 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and17, 0), + SDValue(and16, 0), + SDValue(and16, 0), + // glue (or chain) input edge + SDValue(and17, 1) + ); + +SDValue ct32 = CurDAG->getConstant(15, DL, MVT::i16, true, false); +// R08 = R08 << 15; +// Instr #93 +SDNode *ishl0 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or8, 0), + ct32, + SDValue(or8, 0), + // glue (or chain) input edge + SDValue(or8, 1) + ); + +// R19 = R19 ^ R08; +// Instr #94 +SDNode *xor0 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl0, 0), + SDValue(vload23, 0), + SDValue(vload23, 0), + // glue (or chain) input edge + SDValue(ishl0, 1) + ); + +SDValue ct33 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R14 = 0; +// Instr #95 +SDNode *vload24 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct33, + SDValue(vload22, 0), + // glue (or chain) input edge + SDValue(xor0, 1) + ); + +// END_WHERE; +// Instr #96 +SDNode *endwhere5 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload24, 1) + ); + +// R15 = R25 - R21; +// Instr #97 +SDNode *sub0 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload19, 0), + SDValue(vload20, 0), + // glue (or chain) input edge + SDValue(endwhere5, 0) + ); + +SDValue ct34 = CurDAG->getConstant(-15, DL, MVT::i16, true, false); +// R08 = -15; +// Instr #98 +SDNode *vload25 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct34, + // glue (or chain) input edge + SDValue(sub0, 1) + ); + +// R09 = R15 < R08; +// Instr #99 +SDNode *lt2 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub0, 0), + SDValue(vload25, 0), + // glue (or chain) input edge + SDValue(vload25, 1) + ); + +// R09 = R09 & R14; +// Instr #100 +SDNode *and18 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt2, 0), + // glue (or chain) input edge + SDValue(lt2, 1) + ); + +// R09 = R09 == R30; +// Instr #101 +SDNode *eq17 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and18, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and18, 1) + ); + +SDValue ct35 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #102 +SDNode *nop6 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct35, + // glue (or chain) input edge + SDValue(eq17, 1) + ); + +// WHERE_EQ; +// Instr #103 +SDNode *whereeq6 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq17, 0), + // glue (or chain) input edge + SDValue(nop6, 0) + ); + +// R15 = R31 - R15; +// Instr #104 +SDNode *sub1 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub0, 0), + SDValue(sub0, 0), + // glue (or chain) input edge + SDValue(whereeq6, 1) + ); + +SDValue ct36 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R26 = 0; +// Instr #105 +SDNode *vload26 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct36, + SDValue(or1, 0), + // glue (or chain) input edge + SDValue(sub1, 1) + ); + +SDValue ct37 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = R21 << 0; +// Instr #106 +SDNode *ishl1 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + ct37, + SDValue(vload19, 0), + // glue (or chain) input edge + SDValue(vload26, 1) + ); + +SDValue ct38 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #107 +SDNode *vload27 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct38, + SDValue(sub1, 0), + // glue (or chain) input edge + SDValue(ishl1, 1) + ); + +// END_WHERE; +// Instr #108 +SDNode *endwhere6 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload27, 1) + ); + +SDValue ct39 = CurDAG->getConstant(-3, DL, MVT::i16, true, false); +// R08 = -3; +// Instr #109 +SDNode *vload28 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct39, + // glue (or chain) input edge + SDValue(endwhere6, 0) + ); + +// R09 = R15 < R08; +// Instr #110 +SDNode *lt3 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload27, 0), + SDValue(vload28, 0), + // glue (or chain) input edge + SDValue(vload28, 1) + ); + +// R09 = R09 & R14; +// Instr #111 +SDNode *and19 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt3, 0), + // glue (or chain) input edge + SDValue(lt3, 1) + ); + +// R09 = R09 == R30; +// Instr #112 +SDNode *eq18 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and19, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and19, 1) + ); + +SDValue ct40 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #113 +SDNode *nop7 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct40, + // glue (or chain) input edge + SDValue(eq18, 1) + ); + +// WHERE_EQ; +// Instr #114 +SDNode *whereeq7 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq18, 0), + // glue (or chain) input edge + SDValue(nop7, 0) + ); + +// R15 = R31 - R15; +// Instr #115 +SDNode *sub2 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload27, 0), + SDValue(vload27, 0), + // glue (or chain) input edge + SDValue(whereeq7, 1) + ); + +// R26 = R26 >> R15; +// Instr #116 +SDNode *shr0 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload26, 0), + SDValue(sub2, 0), + SDValue(vload26, 0), + // glue (or chain) input edge + SDValue(sub2, 1) + ); + +SDValue ct41 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = R21 << 0; +// Instr #117 +SDNode *ishl2 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload20, 0), + ct41, + SDValue(ishl1, 0), + // glue (or chain) input edge + SDValue(shr0, 1) + ); + +SDValue ct42 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #118 +SDNode *vload29 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct42, + SDValue(sub2, 0), + // glue (or chain) input edge + SDValue(ishl2, 1) + ); + +// END_WHERE; +// Instr #119 +SDNode *endwhere7 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload29, 1) + ); + +// R09 = R15 < R31; +// Instr #120 +SDNode *lt4 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload29, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere7, 0) + ); + +// R09 = R09 & R14; +// Instr #121 +SDNode *and20 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt4, 0), + // glue (or chain) input edge + SDValue(lt4, 1) + ); + +// R09 = R09 == R30; +// Instr #122 +SDNode *eq19 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and20, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and20, 1) + ); + +SDValue ct43 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #123 +SDNode *nop8 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct43, + // glue (or chain) input edge + SDValue(eq19, 1) + ); + +// WHERE_EQ; +// Instr #124 +SDNode *whereeq8 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq19, 0), + // glue (or chain) input edge + SDValue(nop8, 0) + ); + +// R15 = R31 - R15; +// Instr #125 +SDNode *sub3 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload29, 0), + SDValue(vload29, 0), + // glue (or chain) input edge + SDValue(whereeq8, 1) + ); + +// R22 = R22 << R15; +// Instr #126 +SDNode *shl0 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or3, 0), + SDValue(sub3, 0), + SDValue(or3, 0), + // glue (or chain) input edge + SDValue(sub3, 1) + ); + +SDValue ct44 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R21 = R25 << 0; +// Instr #127 +SDNode *ishl3 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl2, 0), + ct44, + SDValue(vload20, 0), + // glue (or chain) input edge + SDValue(shl0, 1) + ); + +SDValue ct45 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #128 +SDNode *vload30 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct45, + SDValue(sub3, 0), + // glue (or chain) input edge + SDValue(ishl3, 1) + ); + +// END_WHERE; +// Instr #129 +SDNode *endwhere8 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload30, 1) + ); + +SDValue ct46 = CurDAG->getConstant(4, DL, MVT::i16, true, false); +// R08 = 4; +// Instr #130 +SDNode *vload31 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct46, + // glue (or chain) input edge + SDValue(endwhere8, 0) + ); + +// R09 = R15 < R08; +// Instr #131 +SDNode *lt5 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload30, 0), + SDValue(vload31, 0), + // glue (or chain) input edge + SDValue(vload31, 1) + ); + +// R09 = R09 & R14; +// Instr #132 +SDNode *and21 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt5, 0), + // glue (or chain) input edge + SDValue(lt5, 1) + ); + +// R09 = R09 == R30; +// Instr #133 +SDNode *eq20 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and21, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and21, 1) + ); + +SDValue ct47 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #134 +SDNode *nop9 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct47, + // glue (or chain) input edge + SDValue(eq20, 1) + ); + +// WHERE_EQ; +// Instr #135 +SDNode *whereeq9 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq20, 0), + // glue (or chain) input edge + SDValue(nop9, 0) + ); + +// R26 = R26 << R15; +// Instr #136 +SDNode *shl1 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr0, 0), + SDValue(vload30, 0), + SDValue(shr0, 0), + // glue (or chain) input edge + SDValue(whereeq9, 1) + ); + +SDValue ct48 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = R21 << 0; +// Instr #137 +SDNode *ishl4 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl3, 0), + ct48, + SDValue(ishl2, 0), + // glue (or chain) input edge + SDValue(shl1, 1) + ); + +SDValue ct49 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #138 +SDNode *vload32 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct49, + SDValue(vload30, 0), + // glue (or chain) input edge + SDValue(ishl4, 1) + ); + +// END_WHERE; +// Instr #139 +SDNode *endwhere9 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload32, 1) + ); + +// R09 = R15 < R29; +// Instr #140 +SDNode *lt6 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload32, 0), + SDValue(vload3, 0), + // glue (or chain) input edge + SDValue(endwhere9, 0) + ); + +// R09 = R09 & R14; +// Instr #141 +SDNode *and22 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt6, 0), + // glue (or chain) input edge + SDValue(lt6, 1) + ); + +// R09 = R09 == R30; +// Instr #142 +SDNode *eq21 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and22, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and22, 1) + ); + +SDValue ct50 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #143 +SDNode *nop10 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct50, + // glue (or chain) input edge + SDValue(eq21, 1) + ); + +// WHERE_EQ; +// Instr #144 +SDNode *whereeq10 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq21, 0), + // glue (or chain) input edge + SDValue(nop10, 0) + ); + +// R22 = R22 >> R15; +// Instr #145 +SDNode *shr1 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl0, 0), + SDValue(vload32, 0), + SDValue(shl0, 0), + // glue (or chain) input edge + SDValue(whereeq10, 1) + ); + +SDValue ct51 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R21 = R25 << 0; +// Instr #146 +SDNode *ishl5 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + ct51, + SDValue(ishl3, 0), + // glue (or chain) input edge + SDValue(shr1, 1) + ); + +SDValue ct52 = CurDAG->getConstant(32000, DL, MVT::i16, true, false); +// R15 = 32000; +// Instr #147 +SDNode *vload33 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct52, + SDValue(vload32, 0), + // glue (or chain) input edge + SDValue(ishl5, 1) + ); + +// END_WHERE; +// Instr #148 +SDNode *endwhere10 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload33, 1) + ); + +SDValue ct53 = CurDAG->getConstant(32, DL, MVT::i16, true, false); +// R08 = 32; +// Instr #149 +SDNode *vload34 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct53, + // glue (or chain) input edge + SDValue(endwhere10, 0) + ); + +// R09 = R15 < R08; +// Instr #150 +SDNode *lt7 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload33, 0), + SDValue(vload34, 0), + // glue (or chain) input edge + SDValue(vload34, 1) + ); + +// R09 = R09 & R14; +// Instr #151 +SDNode *and23 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt7, 0), + // glue (or chain) input edge + SDValue(lt7, 1) + ); + +// R09 = R09 == R30; +// Instr #152 +SDNode *eq22 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and23, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and23, 1) + ); + +SDValue ct54 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #153 +SDNode *nop11 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct54, + // glue (or chain) input edge + SDValue(eq22, 1) + ); + +// WHERE_EQ; +// Instr #154 +SDNode *whereeq11 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq22, 0), + // glue (or chain) input edge + SDValue(nop11, 0) + ); + +SDValue ct55 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R22 = 0; +// Instr #155 +SDNode *vload35 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct55, + SDValue(shr1, 0), + // glue (or chain) input edge + SDValue(whereeq11, 1) + ); + +SDValue ct56 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R21 = R25 << 0; +// Instr #156 +SDNode *ishl6 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + ct56, + SDValue(ishl5, 0), + // glue (or chain) input edge + SDValue(vload35, 1) + ); + +// END_WHERE; +// Instr #157 +SDNode *endwhere11 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(ishl6, 1) + ); + +// R09 = R24 == R11; +// Instr #158 +SDNode *eq23 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(endwhere11, 0) + ); + +// R09 = R09 & R14; +// Instr #159 +SDNode *and24 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq23, 0), + // glue (or chain) input edge + SDValue(eq23, 1) + ); + +// R09 = R09 == R30; +// Instr #160 +SDNode *eq24 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and24, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and24, 1) + ); + +SDValue ct57 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #161 +SDNode *nop12 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct57, + // glue (or chain) input edge + SDValue(eq24, 1) + ); + +// WHERE_EQ; +// Instr #162 +SDNode *whereeq12 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq24, 0), + // glue (or chain) input edge + SDValue(nop12, 0) + ); + +// R26 = R31 - R26; +// Instr #163 +SDNode *sub4 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(shl1, 0), + SDValue(shl1, 0), + // glue (or chain) input edge + SDValue(whereeq12, 1) + ); + +// END_WHERE; +// Instr #164 +SDNode *endwhere12 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub4, 1) + ); + +// R09 = R20 == R31; +// Instr #165 +SDNode *eq25 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and4, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere12, 0) + ); + +// R09 = R09 & R14; +// Instr #166 +SDNode *and25 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq25, 0), + // glue (or chain) input edge + SDValue(eq25, 1) + ); + +// R09 = R09 == R30; +// Instr #167 +SDNode *eq26 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and25, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and25, 1) + ); + +SDValue ct58 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #168 +SDNode *nop13 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct58, + // glue (or chain) input edge + SDValue(eq26, 1) + ); + +// WHERE_EQ; +// Instr #169 +SDNode *whereeq13 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq26, 0), + // glue (or chain) input edge + SDValue(nop13, 0) + ); + +// R22 = R31 - R22; +// Instr #170 +SDNode *sub5 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload35, 0), + SDValue(vload35, 0), + // glue (or chain) input edge + SDValue(whereeq13, 1) + ); + +// END_WHERE; +// Instr #171 +SDNode *endwhere13 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub5, 1) + ); + +// R09 = R14 == R30; +// Instr #172 +SDNode *eq27 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere13, 0) + ); + +SDValue ct59 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #173 +SDNode *nop14 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct59, + // glue (or chain) input edge + SDValue(eq27, 1) + ); + +// WHERE_EQ; +// Instr #174 +SDNode *whereeq14 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq27, 0), + // glue (or chain) input edge + SDValue(nop14, 0) + ); + +// R26 = R22 + R26; +// Instr #175 +SDNode *add0 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub4, 0), + SDValue(sub5, 0), + SDValue(sub4, 0), + // glue (or chain) input edge + SDValue(whereeq14, 1) + ); + +// END_WHERE; +// Instr #176 +SDNode *endwhere14 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(add0, 1) + ); + +// R24 = R26 & R11; +// Instr #177 +SDNode *and26 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload7, 0), + SDValue(add0, 0), + // glue (or chain) input edge + SDValue(endwhere14, 0) + ); + +// R09 = R24 == R11; +// Instr #178 +SDNode *eq28 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and26, 0), + SDValue(vload7, 0), + // glue (or chain) input edge + SDValue(and26, 1) + ); + +// R09 = R09 & R14; +// Instr #179 +SDNode *and27 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq28, 0), + // glue (or chain) input edge + SDValue(eq28, 1) + ); + +// R09 = R09 == R30; +// Instr #180 +SDNode *eq29 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and27, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and27, 1) + ); + +SDValue ct60 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #181 +SDNode *nop15 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct60, + // glue (or chain) input edge + SDValue(eq29, 1) + ); + +// WHERE_EQ; +// Instr #182 +SDNode *whereeq15 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq29, 0), + // glue (or chain) input edge + SDValue(nop15, 0) + ); + +// R26 = R31 - R26; +// Instr #183 +SDNode *sub6 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(add0, 0), + SDValue(add0, 0), + // glue (or chain) input edge + SDValue(whereeq15, 1) + ); + +// END_WHERE; +// Instr #184 +SDNode *endwhere15 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub6, 1) + ); + +SDValue ct61 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R05 = R26 << 0; +// Instr #185 +SDNode *ishl7 = CurDAG->getMachineNode( + Connex::ISHLV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + ct61, + // glue (or chain) input edge + SDValue(endwhere15, 0) + ); + +SDValue ct62 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R08 = R05 >> 1; +// Instr #186 +SDNode *ishr2 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl7, 0), + ct62, + // glue (or chain) input edge + SDValue(ishl7, 1) + ); + +// R05 = R05 | R08; +// Instr #187 +SDNode *or9 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr2, 0), + SDValue(ishl7, 0), + // glue (or chain) input edge + SDValue(ishr2, 1) + ); + +SDValue ct63 = CurDAG->getConstant(2, DL, MVT::i16, true, false); +// R08 = R05 >> 2; +// Instr #188 +SDNode *ishr3 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or9, 0), + ct63, + // glue (or chain) input edge + SDValue(or9, 1) + ); + +// R05 = R05 | R08; +// Instr #189 +SDNode *or10 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr3, 0), + SDValue(or9, 0), + // glue (or chain) input edge + SDValue(ishr3, 1) + ); + +SDValue ct64 = CurDAG->getConstant(4, DL, MVT::i16, true, false); +// R08 = R05 >> 4; +// Instr #190 +SDNode *ishr4 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or10, 0), + ct64, + // glue (or chain) input edge + SDValue(or10, 1) + ); + +// R05 = R05 | R08; +// Instr #191 +SDNode *or11 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr4, 0), + SDValue(or10, 0), + // glue (or chain) input edge + SDValue(ishr4, 1) + ); + +SDValue ct65 = CurDAG->getConstant(8, DL, MVT::i16, true, false); +// R08 = R05 >> 8; +// Instr #192 +SDNode *ishr5 = CurDAG->getMachineNode( + Connex::ISHRV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or11, 0), + ct65, + // glue (or chain) input edge + SDValue(or11, 1) + ); + +// R05 = R05 | R08; +// Instr #193 +SDNode *or12 = CurDAG->getMachineNode( + Connex::ORV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr5, 0), + SDValue(or11, 0), + // glue (or chain) input edge + SDValue(ishr5, 1) + ); + +// R05 = ~R05; +// Instr #194 +SDNode *not4 = CurDAG->getMachineNode( + Connex::NOT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or12, 0), + // glue (or chain) input edge + SDValue(or12, 1) + ); + +// R06 = POPCNT(R05); +// Instr #195 +SDNode *popcnt0 = CurDAG->getMachineNode( + Connex::POPCNT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(not4, 0), + // glue (or chain) input edge + SDValue(not4, 1) + ); + +// R06 = R29 - R06; +// Instr #196 +SDNode *sub7 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(popcnt0, 0), + // glue (or chain) input edge + SDValue(popcnt0, 1) + ); + +SDValue ct66 = CurDAG->getConstant(11, DL, MVT::i16, true, false); +// R08 = 11; +// Instr #197 +SDNode *vload36 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct66, + // glue (or chain) input edge + SDValue(sub7, 1) + ); + +// R08 = R06 - R08; +// Instr #198 +SDNode *sub8 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub7, 0), + SDValue(vload36, 0), + // glue (or chain) input edge + SDValue(vload36, 1) + ); + +// R09 = R31 < R08; +// Instr #199 +SDNode *lt8 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub8, 0), + // glue (or chain) input edge + SDValue(sub8, 1) + ); + +// R09 = R09 & R14; +// Instr #200 +SDNode *and28 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt8, 0), + // glue (or chain) input edge + SDValue(lt8, 1) + ); + +// R09 = R09 == R30; +// Instr #201 +SDNode *eq30 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and28, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and28, 1) + ); + +SDValue ct67 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #202 +SDNode *nop16 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct67, + // glue (or chain) input edge + SDValue(eq30, 1) + ); + +// WHERE_EQ; +// Instr #203 +SDNode *whereeq16 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq30, 0), + // glue (or chain) input edge + SDValue(nop16, 0) + ); + +SDValue ct68 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = R26 << 0; +// Instr #204 +SDNode *ishl8 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + ct68, + SDValue(vload11, 0), + // glue (or chain) input edge + SDValue(whereeq16, 1) + ); + +// R09 = R29 - R08; +// Instr #205 +SDNode *sub9 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(sub8, 0), + SDValue(eq30, 0), + // glue (or chain) input edge + SDValue(ishl8, 1) + ); + +// R62 = R62 << R09; +// Instr #206 +SDNode *shl2 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl8, 0), + SDValue(sub9, 0), + SDValue(ishl8, 0), + // glue (or chain) input edge + SDValue(sub9, 1) + ); + +// R62 = R62 >> R09; +// Instr #207 +SDNode *shr2 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl2, 0), + SDValue(sub9, 0), + SDValue(shl2, 0), + // glue (or chain) input edge + SDValue(shl2, 1) + ); + +SDValue ct69 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R61 = R08 << 0; +// Instr #208 +SDNode *ishl9 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub8, 0), + ct69, + SDValue(vload12, 0), + // glue (or chain) input edge + SDValue(shr2, 1) + ); + +// R26 = R26 >> R08; +// Instr #209 +SDNode *shr3 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub6, 0), + SDValue(sub8, 0), + SDValue(sub6, 0), + // glue (or chain) input edge + SDValue(ishl9, 1) + ); + +// R25 = R08 + R25; +// Instr #210 +SDNode *add1 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl4, 0), + SDValue(sub8, 0), + SDValue(ishl4, 0), + // glue (or chain) input edge + SDValue(shr3, 1) + ); + +// END_WHERE; +// Instr #211 +SDNode *endwhere16 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(add1, 1) + ); + +// R09 = R08 < R31; +// Instr #212 +SDNode *lt9 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub8, 0), + SDValue(vload2, 0), + // glue (or chain) input edge + SDValue(endwhere16, 0) + ); + +// R09 = R09 & R14; +// Instr #213 +SDNode *and29 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt9, 0), + // glue (or chain) input edge + SDValue(lt9, 1) + ); + +// R09 = R09 == R30; +// Instr #214 +SDNode *eq31 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and29, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and29, 1) + ); + +SDValue ct70 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #215 +SDNode *nop17 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct70, + // glue (or chain) input edge + SDValue(eq31, 1) + ); + +// WHERE_EQ; +// Instr #216 +SDNode *whereeq17 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq31, 0), + // glue (or chain) input edge + SDValue(nop17, 0) + ); + +// R08 = R31 - R08; +// Instr #217 +SDNode *sub10 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload2, 0), + SDValue(sub8, 0), + SDValue(sub8, 0), + // glue (or chain) input edge + SDValue(whereeq17, 1) + ); + +// R26 = R26 << R08; +// Instr #218 +SDNode *shl3 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr3, 0), + SDValue(sub10, 0), + SDValue(shr3, 0), + // glue (or chain) input edge + SDValue(sub10, 1) + ); + +// R25 = R25 - R08; +// Instr #219 +SDNode *sub11 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(add1, 0), + SDValue(sub10, 0), + SDValue(add1, 0), + // glue (or chain) input edge + SDValue(shl3, 1) + ); + +// END_WHERE; +// Instr #220 +SDNode *endwhere17 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(sub11, 1) + ); + +// R09 = R25 < R30; +// Instr #221 +SDNode *lt10 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub11, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere17, 0) + ); + +// R09 = R09 & R14; +// Instr #222 +SDNode *and30 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt10, 0), + // glue (or chain) input edge + SDValue(lt10, 1) + ); + +// R09 = R09 == R30; +// Instr #223 +SDNode *eq32 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and30, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and30, 1) + ); + +SDValue ct71 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #224 +SDNode *nop18 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct71, + // glue (or chain) input edge + SDValue(eq32, 1) + ); + +// WHERE_EQ; +// Instr #225 +SDNode *whereeq18 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq32, 0), + // glue (or chain) input edge + SDValue(nop18, 0) + ); + +// R61 = R30 - R25; +// Instr #226 +SDNode *sub12 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(sub11, 0), + SDValue(ishl9, 0), + // glue (or chain) input edge + SDValue(whereeq18, 1) + ); + +SDValue ct72 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R25 = 1; +// Instr #227 +SDNode *vload37 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct72, + SDValue(sub11, 0), + // glue (or chain) input edge + SDValue(sub12, 1) + ); + +SDValue ct73 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R62 = R26 << 0; +// Instr #228 +SDNode *ishl10 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl3, 0), + ct73, + SDValue(shr2, 0), + // glue (or chain) input edge + SDValue(vload37, 1) + ); + +// R09 = R29 - R61; +// Instr #229 +SDNode *sub13 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload3, 0), + SDValue(sub12, 0), + SDValue(eq32, 0), + // glue (or chain) input edge + SDValue(ishl10, 1) + ); + +// R62 = R62 << R09; +// Instr #230 +SDNode *shl4 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishl10, 0), + SDValue(sub13, 0), + SDValue(ishl10, 0), + // glue (or chain) input edge + SDValue(sub13, 1) + ); + +// R62 = R62 >> R09; +// Instr #231 +SDNode *shr4 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl4, 0), + SDValue(sub13, 0), + SDValue(shl4, 0), + // glue (or chain) input edge + SDValue(shl4, 1) + ); + +// R26 = R26 >> R61; +// Instr #232 +SDNode *shr5 = CurDAG->getMachineNode( + Connex::SHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl3, 0), + SDValue(sub12, 0), + SDValue(shl3, 0), + // glue (or chain) input edge + SDValue(shr4, 1) + ); + +// END_WHERE; +// Instr #233 +SDNode *endwhere18 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(shr5, 1) + ); + +SDValue ct74 = CurDAG->getConstant(1024, DL, MVT::i16, true, false); +// R08 = 1024; +// Instr #234 +SDNode *vload38 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct74, + // glue (or chain) input edge + SDValue(endwhere18, 0) + ); + +// R08 = R26 < R08; +// Instr #235 +SDNode *lt11 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shr5, 0), + SDValue(vload38, 0), + // glue (or chain) input edge + SDValue(vload38, 1) + ); + +// R09 = R25 == R30; +// Instr #236 +SDNode *eq33 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload37, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(lt11, 1) + ); + +// R09 = R09 & R14; +// Instr #237 +SDNode *and31 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(eq33, 0), + // glue (or chain) input edge + SDValue(eq33, 1) + ); + +// R09 = R09 & R08; +// Instr #238 +SDNode *and32 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(lt11, 0), + SDValue(and31, 0), + // glue (or chain) input edge + SDValue(and31, 1) + ); + +// R09 = R09 == R30; +// Instr #239 +SDNode *eq34 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and32, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and32, 1) + ); + +SDValue ct75 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #240 +SDNode *nop19 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct75, + // glue (or chain) input edge + SDValue(eq34, 1) + ); + +// WHERE_EQ; +// Instr #241 +SDNode *whereeq19 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq34, 0), + // glue (or chain) input edge + SDValue(nop19, 0) + ); + +SDValue ct76 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R25 = 0; +// Instr #242 +SDNode *vload39 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct76, + SDValue(vload37, 0), + // glue (or chain) input edge + SDValue(whereeq19, 1) + ); + +// END_WHERE; +// Instr #243 +SDNode *endwhere19 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload39, 1) + ); + +// R26 = R26 & R13; +// Instr #244 +SDNode *and33 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload5, 0), + SDValue(shr5, 0), + // glue (or chain) input edge + SDValue(endwhere19, 0) + ); + +SDValue ct77 = CurDAG->getConstant(30, DL, MVT::i16, true, false); +// R09 = 30; +// Instr #245 +SDNode *vload40 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct77, + // glue (or chain) input edge + SDValue(and33, 1) + ); + +// R09 = R09 < R25; +// Instr #246 +SDNode *lt12 = CurDAG->getMachineNode( + Connex::LT_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload40, 0), + SDValue(vload39, 0), + // glue (or chain) input edge + SDValue(vload40, 1) + ); + +// R09 = R09 & R14; +// Instr #247 +SDNode *and34 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload24, 0), + SDValue(lt12, 0), + // glue (or chain) input edge + SDValue(lt12, 1) + ); + +// R09 = R09 == R30; +// Instr #248 +SDNode *eq35 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and34, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and34, 1) + ); + +SDValue ct78 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #249 +SDNode *nop20 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct78, + // glue (or chain) input edge + SDValue(eq35, 1) + ); + +// WHERE_EQ; +// Instr #250 +SDNode *whereeq20 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq35, 0), + // glue (or chain) input edge + SDValue(nop20, 0) + ); + +SDValue ct79 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R14 = 0; +// Instr #251 +SDNode *vload41 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct79, + SDValue(vload24, 0), + // glue (or chain) input edge + SDValue(whereeq20, 1) + ); + +SDValue ct80 = CurDAG->getConstant(31744, DL, MVT::i16, true, false); +// R19 = 31744; +// Instr #252 +SDNode *vload42 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct80, + SDValue(xor0, 0), + // glue (or chain) input edge + SDValue(vload41, 1) + ); + +// R19 = R19 | R24; +// Instr #253 +SDNode *or13 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and26, 0), + SDValue(vload42, 0), + SDValue(vload42, 0), + // glue (or chain) input edge + SDValue(vload42, 1) + ); + +// END_WHERE; +// Instr #254 +SDNode *endwhere20 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(or13, 1) + ); + +// R08 = R14 == R30; +// Instr #255 +SDNode *eq36 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload41, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere20, 0) + ); + +SDValue ct81 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #256 +SDNode *nop21 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct81, + // glue (or chain) input edge + SDValue(eq36, 1) + ); + +// WHERE_EQ; +// Instr #257 +SDNode *whereeq21 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq36, 0), + // glue (or chain) input edge + SDValue(nop21, 0) + ); + +SDValue ct82 = CurDAG->getConstant(10, DL, MVT::i16, true, false); +// R19 = R25 << 10; +// Instr #258 +SDNode *ishl11 = CurDAG->getMachineNode( + Connex::ISHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload39, 0), + ct82, + SDValue(or13, 0), + // glue (or chain) input edge + SDValue(whereeq21, 1) + ); + +// R19 = R19 | R26; +// Instr #259 +SDNode *or14 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and33, 0), + SDValue(ishl11, 0), + SDValue(ishl11, 0), + // glue (or chain) input edge + SDValue(ishl11, 1) + ); + +// R04 = R26 & R30; +// Instr #260 +SDNode *and35 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(and33, 0), + SDValue(vload14, 0), + // glue (or chain) input edge + SDValue(or14, 1) + ); + +// R07 = R61 - R30; +// Instr #261 +SDNode *sub14 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub12, 0), + SDValue(vload1, 0), + SDValue(and17, 0), + // glue (or chain) input edge + SDValue(and35, 1) + ); + +// R08 = R30 << R08; +// Instr #262 +SDNode *shl5 = CurDAG->getMachineNode( + Connex::SHLV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq36, 0), + SDValue(eq36, 0), + // glue (or chain) input edge + SDValue(sub14, 1) + ); + +// R03 = R62 & R08; +// Instr #263 +SDNode *and36 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl5, 0), + SDValue(shr4, 0), + SDValue(vload15, 0), + // glue (or chain) input edge + SDValue(shl5, 1) + ); + +// R62 = R62 ^ R03; +// Instr #264 +SDNode *xor1 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and36, 0), + SDValue(shr4, 0), + SDValue(shr4, 0), + // glue (or chain) input edge + SDValue(and36, 1) + ); + +// R03 = R03 == R31; +// Instr #265 +SDNode *eq37 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and36, 0), + SDValue(vload2, 0), + SDValue(and36, 0), + // glue (or chain) input edge + SDValue(xor1, 1) + ); + +// R03 = R30 - R03; +// Instr #266 +SDNode *sub15 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq37, 0), + SDValue(eq37, 0), + // glue (or chain) input edge + SDValue(eq37, 1) + ); + +SDValue ct83 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R08 = R08 >> 1; +// Instr #267 +SDNode *ishr6 = CurDAG->getMachineNode( + Connex::ISHRV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(shl5, 0), + ct83, + SDValue(shl5, 0), + // glue (or chain) input edge + SDValue(sub15, 1) + ); + +// R02 = R62 & R08; +// Instr #268 +SDNode *and37 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(ishr6, 0), + SDValue(xor1, 0), + SDValue(vload16, 0), + // glue (or chain) input edge + SDValue(ishr6, 1) + ); + +// R62 = R62 ^ R02; +// Instr #269 +SDNode *xor2 = CurDAG->getMachineNode( + Connex::XORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and37, 0), + SDValue(xor1, 0), + SDValue(xor1, 0), + // glue (or chain) input edge + SDValue(and37, 1) + ); + +// R02 = R02 == R31; +// Instr #270 +SDNode *eq38 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and37, 0), + SDValue(vload2, 0), + SDValue(and37, 0), + // glue (or chain) input edge + SDValue(xor2, 1) + ); + +// R02 = R30 - R02; +// Instr #271 +SDNode *sub16 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq38, 0), + SDValue(eq38, 0), + // glue (or chain) input edge + SDValue(eq38, 1) + ); + +// R01 = R62 == R31; +// Instr #272 +SDNode *eq39 = CurDAG->getMachineNode( + Connex::EQ_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(xor2, 0), + SDValue(vload2, 0), + SDValue(vload17, 0), + // glue (or chain) input edge + SDValue(sub16, 1) + ); + +// R01 = R30 - R01; +// Instr #273 +SDNode *sub17 = CurDAG->getMachineNode( + Connex::SUBV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(eq39, 0), + SDValue(eq39, 0), + // glue (or chain) input edge + SDValue(eq39, 1) + ); + +// R00 = R04 | R02; +// Instr #274 +SDNode *or15 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub16, 0), + SDValue(and35, 0), + SDValue(vload18, 0), + // glue (or chain) input edge + SDValue(sub17, 1) + ); + +// R00 = R00 | R01; +// Instr #275 +SDNode *or16 = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub17, 0), + SDValue(or15, 0), + SDValue(or15, 0), + // glue (or chain) input edge + SDValue(or15, 1) + ); + +// R00 = R00 & R03; +// Instr #276 +SDNode *and38 = CurDAG->getMachineNode( + Connex::ANDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub15, 0), + SDValue(or16, 0), + SDValue(or16, 0), + // glue (or chain) input edge + SDValue(or16, 1) + ); + +// R19 = R00 + R19; +// Instr #277 +SDNode *add2 = CurDAG->getMachineNode( + Connex::ADDV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(or14, 0), + SDValue(and38, 0), + SDValue(or14, 0), + // glue (or chain) input edge + SDValue(and38, 1) + ); + +// R19 = R19 | R24; +// Instr #278 +SDNode *resF16 /*or17*/ = CurDAG->getMachineNode( + Connex::ORV_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and26, 0), + SDValue(add2, 0), + SDValue(add2, 0), + // glue (or chain) input edge + SDValue(add2, 1) + ); + +// END_WHERE; +// Instr #279 +SDNode *lastNode /*endwhere21*/ = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, +// Alex: MVT::Glue, + MVT::Other, + // glue (or chain) input edge + SDValue(resF16 /*or17*/, 1) + ); + Index: lib/Target/Connex/Select_SUBi32_OpincaaCodeGen.cpp =================================================================== --- lib/Target/Connex/Select_SUBi32_OpincaaCodeGen.cpp +++ lib/Target/Connex/Select_SUBi32_OpincaaCodeGen.cpp @@ -0,0 +1,205 @@ +// From /home/asusu/LLVM/llvm38Nov2016/llvm/build40/bin/Tests/NEW_v128i16/opincaa_standalone_apps/Emulate_i32/SUB_i32_manual/DumpISel_OpincaaCodeGen_old110_400.cpp + +// R27 is REG_SRC1. It is represented by result of nodeOpSrcCast1. +// R28 is REG_SRC2. It is represented by result of nodeOpSrcCast2. + + + +// Code auto-generated by method Kernel::genLLVMISelManualCode() +// from Opincaa lib from kernel: simpleIoTest_allowOverwrite123456. +// It is important to put this code in the Select() method of the +// SelectionDAGISel class of your back end, after the ISelLowering pass, +// which contains the DAG Combiner, because the DAG Combiner can remove +// the getCopyToReg() we create, which can lead to the following error: +// <> assertion failed. +// Number of instructions generated: 15. + + + + +SDValue ct0 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R31 = 0; +// Instr #0 +SDNode *vload0 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct0, + // glue (or chain) input edge + SDValue(nodeOpSrcCast2, 1) + ); + +SDValue ct1 = CurDAG->getConstant(1, DL, MVT::i16, true, false); +// R30 = 1; +// Instr #1 +SDNode *vload1 = CurDAG->getMachineNode( + Connex::VLOAD_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct1, + // glue (or chain) input edge + SDValue(vload0, 1) + ); + +// R29 = R27 - R28; +// Instr #2 +SDNode *sub0 = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(nodeOpSrcCast1, 0), + SDValue(nodeOpSrcCast2, 0), + // glue (or chain) input edge + SDValue(vload1, 1) + ); + +// R23 = ADDC(R31, R31); +// Instr #3 +SDNode *addc0 = CurDAG->getMachineNode( + Connex::ADDCV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload0, 0), + SDValue(vload0, 0), + SDValue(sub0, 0) + // no need for glue or chain input (since it normally consumes the output of the predecessor) + ); + +// R26 = INDEX; +// Instr #4 +SDNode *ldix0 = CurDAG->getMachineNode( + Connex::LDIX_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(addc0, 1) + ); + +// R25 = R26 & R30; +// Instr #5 +SDNode *and0 = CurDAG->getMachineNode( + Connex::ANDV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(vload1, 0), + SDValue(ldix0, 0), + // glue (or chain) input edge + SDValue(ldix0, 1) + ); + +// R24 = R25 == R30; +// Instr #6 +SDNode *eq0 = CurDAG->getMachineNode( + Connex::EQ_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(and0, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(and0, 1) + ); + +SDValue ct2 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #7 +SDNode *nop0 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct2, + // glue (or chain) input edge + SDValue(eq0, 1) + ); + +// WHERE_EQ; +// Instr #8 +SDNode *whereeq0 = CurDAG->getMachineNode( + Connex::WHEREEQ, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(eq0, 0), + // glue (or chain) input edge + SDValue(nop0, 0) + ); + +SDValue ct3 = CurDAG->getConstant(0, DL, MVT::i16, true, false); +// R23 = 0; +// Instr #9 +SDNode *vload2 = CurDAG->getMachineNode( + Connex::VLOAD_SPECIAL_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + ct3, + SDValue(addc0, 0), + // glue (or chain) input edge + SDValue(whereeq0, 1) + ); + +// END_WHERE; +// Instr #10 +SDNode *endwhere0 = CurDAG->getMachineNode( + Connex::END_WHERE, + DL, + MVT::Glue, + // glue (or chain) input edge + SDValue(vload2, 1) + ); + +// CELL_SHR(R23, R30); +// Instr #11 +SDNode *cellshr0 = CurDAG->getMachineNode( + Connex::CELLSHR_H, + DL, + MVT::Glue, + SDValue(vload2, 0), + SDValue(vload1, 0), + // glue (or chain) input edge + SDValue(endwhere0, 0) + ); + +SDValue ct4 = CurDAG->getConstant(1 /* Num of cycles to NOP */, DL, MVT::i16, true, false); +// NOP; +// Instr #12 +SDNode *nop1 = CurDAG->getMachineNode( + Connex::NOP_BPF, + DL, + MVT::Glue, + ct4, + // glue (or chain) input edge + SDValue(cellshr0, 0) + ); + +// R23 = SHIFT_REG; +// Instr #13 +SDNode *ldsh0 = CurDAG->getMachineNode( + Connex::LDSH_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + // glue (or chain) input edge + SDValue(nop1, 0) + ); + +// R29 = R29 - R23; +// Instr #14 +SDNode *resH /*sub1*/ = CurDAG->getMachineNode( + Connex::SUBV_H, + DL, + TYPE_VECTOR_I16, + MVT::Glue, + SDValue(sub0, 0), + SDValue(ldsh0, 0), + // glue (or chain) input edge + SDValue(ldsh0, 1) + ); + +SDNode *lastNode = resH; Index: lib/Target/LLVMBuild.txt =================================================================== --- lib/Target/LLVMBuild.txt +++ lib/Target/LLVMBuild.txt @@ -24,6 +24,7 @@ AArch64 AVR BPF + Connex Lanai Hexagon MSP430