Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "case", "Instruction", "::", "FCmp", ":" ]

[ "if", "(", "!", "selectBinaryOp", "(", "I", ",", "ISD", "::", "UREM", ")", ")", "return", "selectRem", "(", "I", ",", "ISD", "::", "UREM", ")", ";", "return", "true", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "selectShift", "(", "I", ")", ";", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "return", "selectLogicalOp", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "selectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "IndirectBr", ":", "return", "selectIndirectBr", "(", "I", ")", ";", "case", "Instruction", "::", "BitCast", ":", "if", "(", "!", "FastISel", "::", "selectBitCast", "(", "I", ")", ")", "return", "selectBitCast", "(", "I", ")", ";", "return", "true", ";", "case", "Instruction", "::", "FPToSI", ":", "if", "(", "!", "selectCast", "(", "I", ",", "ISD", "::", "FP_TO_SINT", ")", ")", "return", "selectFPToInt", "(", "I", ",", "true", ")", ";", "return", "true", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "selectFPToInt", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "selectIntExt", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "if", "(", "!", "selectCast", "(", "I", ",", "ISD", "::", "TRUNCATE", ")", ")", "return", "selectTrunc", "(", "I", ")", ";", "return", "true", ";", "case", "Instruction", "::", "FPExt", ":", "return", "selectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "selectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "if", "(", "!", "selectCast", "(", "I", ",", "ISD", "::", "SINT_TO_FP", ")", ")", "return", "selectIntToFP", "(", "I", ",", "true", ")", ";", "return", "true", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "selectIntToFP", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "Load", ":", "return", "selectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "selectStore", "(", "I", ")", ";" ]

[ "KillSrc0", "=", "true", ";" ]

[ "if", "(", "!", "MRI", "->", "def_empty", "(", "OrigSrc0", ")", ")", "{", "MachineRegisterInfo", "::", "def_instr_iterator", "Def", "=", "MRI", "->", "def_instr_begin", "(", "OrigSrc0", ")", ";", "assert", "(", "std", "::", "next", "(", "Def", ")", "==", "MRI", "->", "def_instr_end", "(", ")", "&&", "<STR_LIT>", "Multiple def in SSA!", "<STR_LIT>", ")", ";", "MachineOperand", "*", "MOSrc0", "=", "getSrcFromCopy", "(", "&", "*", "Def", ",", "MRI", ",", "SubReg0", ")", ";", "if", "(", "MOSrc0", ")", "{", "Src0", "=", "MOSrc0", "->", "getReg", "(", ")", ";", "KillSrc0", "=", "MOSrc0", "->", "isKill", "(", ")", ";", "MOSrc0", "->", "setIsKill", "(", "false", ")", ";", "if", "(", "MRI", "->", "hasOneNonDBGUse", "(", "OrigSrc0", ")", ")", "{", "assert", "(", "MOSrc0", "&&", "<STR_LIT>", "Can't delete copy w/o a valid original source!", "<STR_LIT>", ")", ";", "Def", "->", "eraseFromParent", "(", ")", ";", "++", "NumCopiesDeleted", ";", "}", "}", "}", "if", "(", "!", "MRI", "->", "def_empty", "(", "OrigSrc1", ")", ")", "{", "MachineRegisterInfo", "::", "def_instr_iterator", "Def", "=", "MRI", "->", "def_instr_begin", "(", "OrigSrc1", ")", ";", "assert", "(", "std", "::", "next", "(", "Def", ")", "==", "MRI", "->", "def_instr_end", "(", ")", "&&", "<STR_LIT>", "Multiple def in SSA!", "<STR_LIT>", ")", ";", "MachineOperand", "*", "MOSrc1", "=", "getSrcFromCopy", "(", "&", "*", "Def", ",", "MRI", ",", "SubReg1", ")", ";", "if", "(", "MOSrc1", ")", "{", "Src1", "=", "MOSrc1", "->", "getReg", "(", ")", ";", "KillSrc1", "=", "MOSrc1", "->", "isKill", "(", ")", ";", "MOSrc1", "->", "setIsKill", "(", "false", ")", ";", "if", "(", "MRI", "->", "hasOneNonDBGUse", "(", "OrigSrc1", ")", ")", "{", "assert", "(", "MOSrc1", "&&", "<STR_LIT>", "Can't delete copy w/o a valid original source!", "<STR_LIT>", ")", ";", "Def", "->", "eraseFromParent", "(", ")", ";", "++", "NumCopiesDeleted", ";", "}", "}", "}", "if", "(", "!", "Src0", ")", "{", "SubReg0", "=", "<NUM_LIT>", ";", "Src0", "=", "MRI", "->", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "insertCopy", "(", "TII", ",", "MI", ",", "Src0", ",", "OrigSrc0", ",", "KillSrc0", ")", ";" ]

[ "(", ")", "<<", "'", "]", "'", ";" ]

[ "const", "MCOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "const", "MCOperand", "&", "Disp", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ";", "if", "(", "Base", ".", "getReg", "(", ")", ")", "O", "<<", "<STR_LIT>", "[%", "<STR_LIT>", "<<", "StringRef", "(", "getRegisterName", "(", "Base", ".", "getReg", "(", ")", ")", ")", ".", "lower" ]

[ "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Handler", ",", "StoreAddr", ",", "MachinePointerInfo", "(", ")", ")", ";" ]

[ "Register", "StoreAddrReg", "=", "(", "PtrVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "RCX", ":", "X86", "::", "ECX", ";", "SDValue", "StoreAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "Frame", ",", "DAG", ".", "getIntPtrConstant", "(", "RegInfo", "->", "getSlotSize", "(", ")", ",", "dl", ")", ")", ";", "StoreAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "StoreAddr", ",", "Offset", ")", ";" ]

[ ")", ";" ]

[ "return", "(", "getKill", "(", ")", "&&", "isKillImmutable", "(", ")", ")", "||", "!", "getKill", "(" ]

[ ")", "{" ]

[ "vreinterpret_s32_s64", "(", "int64x1_t", "_", "_", "a" ]

[ ")", ";" ]

[ "static", "SDValue", "lower_kernel_argument", "(", "int", "i", ",", "SDValue", "Chain", ",", "DebugLoc", "dl", ",", "MVT", "::", "SimpleValueType", "VT", ",", "argmap_entry", "*", "entry", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "*", "argreg", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "Not implemented yet", "<STR_LIT>" ]

[ "<STR_LIT>", ";" ]

[ "def", "fmul_su", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "lhs", ",", "node", ":", "$", "rhs", ")", ",", "(", "fmul", "node", ":", "$", "lhs", ",", "node", ":", "$", "rhs", ")", ",", "[", "{", "return", "N", "-", ">", "hasOneUse", "(", ")", ";", "}", "]", ">", ";", "def", "fadd_mlx", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "lhs", ",", "node", ":", "$", "rhs", ")", ",", "(", "fadd", "node", ":", "$", "lhs", ",", "node", ":", "$", "rhs", ")", ",", "[", "{", "return", "hasNoVMLxHazardUse", "(", "N", ")", ";", "}", "]", ">", ";", "def", "fsub_mlx", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "lhs", ",", "node", ":", "$", "rhs", ")", ",", "(", "fsub", "node", ":", "$", "lhs", ",", "node", ":", "$", "rhs", ")", ",", "[", "{", "return", "hasNoVMLxHazardUse", "(", "N", ")", ";", "}", "]", ">", ";", "class", "ImmAsmOperand", ":", "AsmOperandClass", "{", "let", "RenderMethod", "=", "<STR_LIT>", ";", "}", "class", "MemOperand", ":", "Operand", "<", "i32", ">", "{", "let", "OperandType", "=", "<STR_LIT>", ";", "}", "def", "brtarget", ":", "Operand", "<", "OtherVT", ">", "{", "let", "EncoderMethod", "=" ]

[ "}" ]

[ "let", "isCall", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "R29", "]", ";", "let", "Defs", "=", "[", "PC", ",", "R31", "]", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";" ]

[ "ior", "xor", "and", "mult", "]", ")" ]

[ "(", "define_code_iterator", "FETCHOP", "[", "plus", "minus" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "unspec_volatile", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_TABORT", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ">", "=", "<NUM_LIT>", "&", "&", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "<NUM_LIT>", ")" ]

[ "if", "(", "needsFPFromSig", "(", "F_", ")", ")", "return", "true", ";" ]

[ "const", "Instruction", "&", "Inst", "=", "*", "I", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "FAdd", ":", "case", "Instruction", "::", "FSub", ":", "case", "Instruction", "::", "FMul", ":", "case", "Instruction", "::", "FDiv", ":", "case", "Instruction", "::", "FRem", ":", "case", "Instruction", "::", "FPToUI", ":", "case", "Instruction", "::", "FPToSI", ":", "case", "Instruction", "::", "UIToFP", ":", "case", "Instruction", "::", "SIToFP", ":", "case", "Instruction", "::", "FPTrunc", ":", "case", "Instruction", "::", "FPExt", ":", "case", "Instruction", "::", "FCmp", ":", "return", "true", ";", "default", ":", ";", "}", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Working on call", "<STR_LIT>", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "Function", "&", "F_", "=", "*", "CI", "->", "getCalledFunction", "(", ")", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "{", "Index", "{", "<NUM_LIT>", "}", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "{", "Index", "{", "<NUM_LIT>", "}", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Re", ";" ]

[ ";" ]

[ "else", "if", "(", "(", "from", ")", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", "{", "if", "(", "leaf_function_p", "(", ")", ")", "(", "offset", ")", "=", "<NUM_LIT>", ";", "else", "(", "offset", ")", "=", "cfun", "->", "machine", "->", "gp_sp_offset", "+", "(", "(", "UNITS_PER_WORD", "-", "(", "POINTER_SIZE", "/", "BITS_PER_UNIT", ")", ")", "*", "(", "BYTES_BIG_ENDIAN", "!=", "<NUM_LIT>", ")", ")", ";", "}", "return", "offset" ]

[ "<NUM_LIT>", ")", ";" ]

[ "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "Ran out of VGPRs for spilling SGPR", "<STR_LIT>", ")", ";", "}", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READLANE_B32", ")", ",", "SubReg", ")", ".", "addReg", "(", "Spill", ".", "VGPR", ")", ".", "addImm", "(", "Spill", ".", "Lane", ")", ";", "}", "TII", "->", "insertNOPs", "(", "MI", ",", "<NUM_LIT>", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_SPILL_V512_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_V256_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_V128_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_V96_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_V64_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_V32_SAVE", ":", "{", "unsigned", "NumSubRegs", "=", "getNumSubRegsForSpillOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "int64_t", "Offset", "=", "FrameInfo", "->", "getObjectOffset", "(", "Index", ")", ";", "unsigned", "Size", "=", "NumSubRegs", "*", "<NUM_LIT>", ";", "unsigned", "TmpReg", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MI", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "NumSubRegs", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "SubReg", "=", "NumSubRegs", ">", "<NUM_LIT>", "?", "getPhysRegSubReg", "(", "SrcReg", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "i", ")", ":", "SrcReg", ";", "Offset", "+=", "(", "i", "*", "<NUM_LIT>", ")", ";", "MFI", "->", "LDSWaveSpillSize", "=", "std", "::", "max", "(", "(", "unsigned", ")", "Offset", "+", "<NUM_LIT>", ",", "(", "unsigned", ")", "MFI", "->", "LDSWaveSpillSize", ")", ";", "unsigned", "AddrReg", "=", "TII", "->", "calculateLDSSpillAddress", "(", "*", "MBB", ",", "MI", ",", "RS", ",", "TmpReg", ",", "Offset", ",", "Size", ")", ";", "if", "(", "AddrReg", "==", "AMDGPU", "::", "NoRegister", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "<STR_LIT>", "Ran out of VGPRs for spilling VGPRS", "<STR_LIT>", ")", ";", "AddrReg", "=", "AMDGPU", "::", "VGPR0", ";", "}", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "DS_WRITE_B32", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "AddrReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "SubReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_SPILL_V32_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_V64_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_V128_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_V256_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_V512_RESTORE", ":", "{", "unsigned", "NumSubRegs", "=", "getNumSubRegsForSpillOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "int64_t", "Offset", "=", "FrameInfo", "->", "getObjectOffset", "(", "Index", ")", ";", "unsigned", "Size", "=", "NumSubRegs", "*", "<NUM_LIT>", ";", "unsigned", "TmpReg", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MI", "," ]

[ "<FIXS>", "Ops", "[", "NumVecs", "+", "<NUM_LIT>", "]", "=", "Pred", ";", "Ops", "[", "NumVecs", "+", "<NUM_LIT>", "]", "=", "PredReg", ";", "Ops", "[", "NumVecs", "+", "<NUM_LIT>", "]", "=", "Chain", ";", "<FIXE>", "<FIXS>", "MVT", "::", "Other", ",", "Ops", ".", "data", "(", ")", ",", "NumVecs", "+", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "for", "(", "unsigned", "Vec", "=", "<NUM_LIT>", ";", "Vec", "NumVecs", ";", "++", "Vec", ")", "Ops", "[", "Vec", "+", "<NUM_LIT>", "]", "=", "CurDAG", "->", "getTargetExtractSubreg", "(", "ARM", "::", "DSUBREG_1", ",", "dl", ",", "RegVT", ",", "N", "->", "getOperand", "(", "Vec", "+", "<NUM_LIT>", ")", ")", ";", "<BUGS>", "Ops", "[", "NumVecs", "+", "<NUM_LIT>", "]", "=", "Chain", ";", "<BUGE>", "Opc", "=", "QOpcodes1", "[", "OpcodeIndex", "]", ";", "SDNode", "*", "VStB", "=", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "MemAddr", ".", "getValueType", "(", ")", ",", "<BUGS>", "MVT", "::", "Other", ",", "Ops", ".", "data", "(", ")", ",", "NumVecs", "+", "<NUM_LIT>", ")", ";", "<BUGE>", "Chain", "=", "SDValue", "(", "VStB", ",", "<NUM_LIT>", ")", ";", "ReplaceUses", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "Chain", ")", ";", "return", "NULL", ";" ]

[ "std", "::", "advance", "(", "I", ",", "Src2ModIdx", ")", ";" ]

[ "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "<NUM_LIT>", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "<NUM_LIT>", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "if", "(", "Res", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_vi", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_si", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_e64_vi", ")", ")", "{", "int", "Src2ModIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "auto", "I", "=", "MI", ".", "begin", "(", ")", ";" ]

[ "<FIXS>", "rtx", "(", "*", "gen_cbranch", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", "=", "QImode", "==", "mode", "?", "gen_cbranchqi4", ":", "gen_cbranchhi4", ";", "<FIXE>", "<FIXS>", "rtx", "op0", "=", "reg", ";", "rtx", "op1", "=", "gen_int_mode", "(", "num_idx", ",", "mode", ")", ";", "rtx", "labelref", "=", "copy_rtx", "(", "xop", "[", "<NUM_LIT>", "]", ")", ";", "emit_jump_insn", "(", "gen_cbranch", "(", "gen_rtx_fmt_ee", "(", "GTU", ",", "VOIDmode", ",", "op0", ",", "op1", ")", ",", "op0", ",", "op1", ",", "labelref", ")", ")", ";", "<FIXE>", "<FIXS>", "emit_insn_after", "(", "seq1", ",", "insns", "[", "<NUM_LIT>", "]", ")", ";", "<FIXE>" ]

[ "rtx", "reg", "=", "copy_to_mode_reg", "(", "mode", ",", "xop", "[", "<NUM_LIT>", "]", ")", ";", "rtx", "(", "*", "gen_add", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "QImode", "==", "mode", "?", "gen_addqi3", ":", "gen_addhi3", ";", "<BUGS>", "rtx", "(", "*", "gen_cmp", ")", "(", "rtx", ",", "rtx", ")", "=", "QImode", "==", "mode", "?", "gen_cmpqi3", ":", "gen_cmphi3", ";", "<BUGE>", "emit_insn", "(", "gen_add", "(", "reg", ",", "reg", ",", "gen_int_mode", "(", "-", "low_idx", ",", "mode", ")", ")", ")", ";", "<BUGS>", "emit_insn", "(", "gen_cmp", "(", "reg", ",", "gen_int_mode", "(", "num_idx", ",", "mode", ")", ")", ")", ";", "<BUGE>", "seq1", "=", "get_insns", "(", ")", ";", "last1", "=", "get_last_insn", "(", ")", ";", "end_sequence", "(", ")", ";", "<BUGS>", "emit_insn_before", "(", "seq1", ",", "insns", "[", "<NUM_LIT>", "]", ")", ";", "<BUGE>" ]

[ "return", "false", ";" ]

[ "unsigned", "isExtended", "=", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "isExtended", ")", "return", "true", ";", "unsigned", "isExtendable", "=", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "!", "isExtendable", ")", "return", "false", ";", "short", "ExtOpNum", "=", "getCExtOpNum", "(", "MI", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "ExtOpNum", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";", "if", "(", "MO", ".", "isMBB", "(", ")", ")" ]

[ "<NUM_LIT>", "}", "=", "Op2", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "CRm", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "val", ")", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "TARGET_AVX512F", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "val", ")", ")", ")", ";", "<BUGE>", "emit_insn", "(", "gen_avx512f_blendmv16si", "(", "target", ",", "tmp", ",", "target", ",", "force_reg", "(", "HImode", ",", "GEN_INT", "(", "<NUM_LIT>", "<<", "elt", ")", ")", ")", ")", ";", "return", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD3DUPpost", "<STR_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMHI", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMHS", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMEQ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGE", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMEQz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMGTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMLEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CMLTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMEQz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMGTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMLEz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::FCMLTz", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SADDV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UADDV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SMINV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UMINV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SMAXV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UMAXV", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::NOT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::BIT", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CBZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::CBNZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TBZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TBNZ", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::TC_RETURN", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::PREFETCH", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SITOF", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UITOF", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::NVCAST", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SQSHL_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::UQSHL_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SRSHR_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::URSHR_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::SQSHLU_I", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::WrapperLarge", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1x2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1x3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1x4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST1x2post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST1x3post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::ST1x4post", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD1DUPpost", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "AArch64ISD::LD2DUPpost", "<STR_LIT>", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_comge_epu8", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpcomgeub", "(", "(", "_", "_", "v16qi", ")", "_", "_", "A", ",", "(", "_", "_", "v16qi", ")", "_", "_", "B", ")", ";" ]

[ "}" ]

[ "RsrcDataFormat", "|=", "(", "<NUM_LIT>", "ULL", "<<", "<NUM_LIT>", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "SISubtarget", "::", "VOLCANIC_ISLANDS", ")", "RsrcDataFormat", "|=", "(", "<NUM_LIT>", "ULL", "<<", "<NUM_LIT>", ")", ";", "}", "return", "RsrcDataFormat", ";" ]

[ "<FIXS>", "void", "LoadM0", "(", "MachineInstr", "&", "MI", ",", "MachineInstr", "*", "MovRel", ",", "int", "Offset", "=", "<NUM_LIT>", ")", ";", "void", "computeIndirectRegAndOffset", "(", "unsigned", "VecReg", ",", "unsigned", "&", "Reg", ",", "int", "&", "Offset", ")", ";", "<FIXE>" ]

[ "void", "Kill", "(", "MachineInstr", "&", "MI", ")", ";", "void", "Branch", "(", "MachineInstr", "&", "MI", ")", ";", "<BUGS>", "void", "LoadM0", "(", "MachineInstr", "&", "MI", ",", "MachineInstr", "*", "MovRel", ")", ";", "<BUGE>", "void", "IndirectSrc", "(", "MachineInstr", "&", "MI", ")", ";", "void", "IndirectDst", "(", "MachineInstr", "&", "MI", ")", ";" ]

[ "ReverseBranchCondition", "(", "Cond", ")", ";" ]

[ "if", "(", "!", "Cond", ".", "empty", "(", ")", "&&", "Cond", "[", "<NUM_LIT>", "]", ".", "isImm", "(", ")", "&&", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "BccOpc", "=", "Hexagon", "::", "JMP_f", ";", "regPos", "=", "<NUM_LIT>", ";", "}", "if", "(", "FBB", "==", "<NUM_LIT>", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "NewTBB", ",", "*", "NewFBB", ";", "SmallVector", "<", "MachineOperand", ",", "<NUM_LIT>", ">", "Cond", ";", "MachineInstr", "*", "Term", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "isPredicated", "(", "Term", ")", "&&", "!", "AnalyzeBranch", "(", "MBB", ",", "NewTBB", ",", "NewFBB", ",", "Cond", ",", "false", ")", ")", "{", "MachineBasicBlock", "*", "NextBB", "=", "llvm", "::", "next", "(", "MachineFunction", "::", "iterator", "(", "&", "MBB", ")", ")", ";", "if", "(", "NewTBB", "==", "NextBB", ")", "{" ]

[ "}" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "b", ",", "int16_t", "_", "_", "c", ")", "{" ]

[ "_", "_", "arm_vqrdmlashq_n_s16", "(", "int16x8_t", "_", "_", "a", ",", "int16x8_t", "_", "_" ]

[ "let", "ParserMatchClass", "=", "BitfieldAsmOperand", ";" ]

[ "return", "ARM", ":", ":", "isBitFieldInvertedMask", "(", "N", "-", ">", "getZExtValue", "(", ")", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "]", ",", "<NUM_LIT>", ",", "false", ")" ]

[ "return", "m68k_output_movem", "(", "operands", ",", "operands", "[", "<NUM_LIT>" ]

[ "<STR_LIT>" ]

[ "(", "sign_extend", ":", "DI", "(", "truncate", ":", "HI", "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", ")", ")", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "DI", "(", "ashift", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "zero_extend", ":", "DI", "(", "truncate", ":", "HI", "(", "const", ":", "DI", "(", "sign_extend", ":", "DI", "(", "truncate", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", ")", ")", ")", ")", "]" ]

[ "A", ".", "getOrCreateAAFor", "<", "AAAMDGPUNoAGPR", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";" ]

[ "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "}", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "TM", ")", ";", "DenseSet", "<", "const", "char", "*", ">", "Allowed", "(", "{", "&", "AAAMDAttributes", "::", "ID", ",", "&", "AAUniformWorkGroupSize", "::", "ID", ",", "&", "AAPotentialValues", "::", "ID", ",", "&", "AAAMDFlatWorkGroupSize", "::", "ID", ",", "&", "AAAMDWavesPerEU", "::", "ID", ",", "&", "AAAMDGPUNoAGPR", "::", "ID", ",", "&", "AACallEdges", "::", "ID", ",", "&", "AAPointerInfo", "::", "ID", ",", "&", "AAPotentialConstantValues", "::", "ID", ",", "&", "AAUnderlyingObjects", "::", "ID", "}", ")", ";", "AttributorConfig", "AC", "(", "CGUpdater", ")", ";", "AC", ".", "Allowed", "=", "&", "Allowed", ";", "AC", ".", "IsModulePass", "=", "true", ";", "AC", ".", "DefaultInitializeLiveInternals", "=", "false", ";", "AC", ".", "IPOAmendableCB", "=", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_KERNEL", ";", "}", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "AC", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isIntrinsic", "(", ")", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAUniformWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";" ]

[ "const", "{" ]

[ "bool", "shouldSignWithBKey", "(", ")" ]

[ "<FIXS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM TP: Not a v8.1m.main+mve target.\\n", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", "||", "!", "ST", "->", "hasV8_1MMainlineOps", "(", ")", ")", "{", "<BUGS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "TP: Not a v8.1m.main+mve target.\\n", "<STR_LIT>", ")", ";", "<BUGE>", "return", "false", ";", "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "n1", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs16", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs16", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ ")" ]

[ "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_INSXH", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "ShiftedVal", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "if", "(", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "APInt", "Value", "=", "C", "->", "getAPIntValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "Value", ".", "isNonNegative", "(", ")", ")", "{", "APInt", "VM1", "=", "Value", "-", "<NUM_LIT>", ";", "if", "(", "VM1", ".", "isPowerOf2", "(", ")", ")", "{", "SDValue", "ShiftedVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "VM1", ".", "logBase2", "(", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "ShiftedVal", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "APInt", "VP1", "=", "Value", "+", "<NUM_LIT>", ";", "if", "(", "VP1", ".", "isPowerOf2", "(", ")", ")", "{", "SDValue", "ShiftedVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "VP1", ".", "logBase2", "(", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "ShiftedVal", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "{", "APInt", "VNP1", "=", "-", "Value", "+", "<NUM_LIT>", ";", "if", "(", "VNP1", ".", "isPowerOf2", "(", ")", ")", "{", "SDValue", "ShiftedVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "VNP1", ".", "logBase2", "(", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "ShiftedVal", ")", ";", "}", "APInt", "VNM1", "=", "-", "Value", "-", "<NUM_LIT>", ";", "if", "(", "VNM1", ".", "isPowerOf2", "(", ")", ")", "{", "SDValue", "ShiftedVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "VNM1", ".", "logBase2", "(", ")", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";" ]

[ "->", "Latency", ">", "right", "->", "Latency", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Comparing latency of SU (", "<STR_LIT>", "<<", "left", "->", "NodeNum", "<<", "<STR_LIT>", ") depth ", "<STR_LIT>", "<<", "LDepth", "<<", "<STR_LIT>", " vs SU (", "<STR_LIT>", "<<", "right", "->", "NodeNum", "<<", "<STR_LIT>", ") depth ", "<STR_LIT>", "<<", "RDepth", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "LDepth", "<", "RDepth", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ";", "}", "if", "(", "left", "->", "Latency", "!=", "right", "->", "Latency", ")", "return", "left" ]

[ "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "nImmSplatI32AsmOperand", ";" ]

[ "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "*", "MCI", ")", ";" ]

[ "bool", "Extended", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "*", "MCB", ")", ")", "{", "MCInst", "*", "MCI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "I", ".", "getInst", "(", ")", ")", ";", "if", "(", "Extended", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "isDuplex", "(", "*", "MCII", ",", "*", "MCI", ")", ")", "{", "MCInst", "*", "SubInst", "=", "const_cast", "<", "MCInst", "*", ">", "(", "MCI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getInst", "(", ")", ")", ";", "HexagonMCInstrInfo", "::", "clampExtended", "(", "*", "MCII", ",", "getContext", "(", ")", ",", "*", "SubInst", ")", ";", "}", "else", "{", "HexagonMCInstrInfo", "::", "clampExtended", "(", "*", "MCII", ",", "getContext", "(", ")", ",", "*", "MCI", ")", ";", "}", "Extended", "=", "false", ";", "}", "else", "{" ]

[ "<FIXS>", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "<FIXE>", "<FIXS>", "if", "(", "X86ScalarSSE", ")", "{", "<FIXE>" ]

[ "}", "return", "Result", ";", "}", "<BUGS>", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "{", "<BUGE>", "Tmp1", "=", "SelectExpr", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<BUGS>", "if", "(", "ISD", "::", "FP_TO_SINT", "==", "N", ".", "getOpcode", "(", ")", "&&", "X86ScalarSSE", ")", "{", "<BUGE>", "if", "(", "MVT", "::", "f32", "==", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ")", "{", "BuildMI", "(", "BB", ",", "X86", "::", "CVTTSS2SIrr", ",", "<NUM_LIT>", ",", "Result", ")", ".", "addReg", "(", "Tmp1", ")", ";", "}", "else", "if", "(", "MVT", "::", "f64", "==", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ")", "{" ]

[ "::", "<STR_LIT>", ";" ]

[ "case", "ISD", "::", "SETNE", ":", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "LHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "break", ";", "case", "ISD", "::", "SETULE", ":", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "case", "ISD", "::", "SETUGE", ":", "if", "(", "const", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "LHS", ")", ")", "{", "LHS", "=", "RHS", ";", "RHS", "=", "DAG", ".", "getConstant", "(", "C", "->", "getSExtValue", "(", ")", "+", "<NUM_LIT>", ",", "C", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGT", ":", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "case", "ISD", "::", "SETULT", ":", "if", "(", "const", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "LHS", ")", ")", "{", "LHS", "=", "RHS", ";", "RHS", "=", "DAG", ".", "getConstant", "(", "C", "->", "getSExtValue", "(", ")", "+", "<NUM_LIT>", ",", "C", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "TCC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETLE", ":", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "case", "ISD", "::", "SETGE", ":", "if", "(", "const", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "LHS", ")", ")", "{", "LHS", "=", "RHS", ";", "RHS", "=", "DAG", ".", "getConstant", "(", "C", "->", "getSExtValue", "(", ")", "+", "<NUM_LIT>", ",", "C", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "TCC", "=", "<STR_LIT>" ]

[ "<FIXS>", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "val", "&", "-", "<NUM_LIT>", ")", "<FIXE>" ]

[ "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "val", "&", "<NUM_LIT>", ")", "<BUGS>", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "val", "&", "<NUM_LIT>", ")", "<BUGE>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "Register", "R", "=", "Op", ".", "getReg", "(", ")", ";" ]

[ "unsigned", "DefReg", "=", "<NUM_LIT>", ";", "for", "(", "const", "MachineOperand", "&", "Op", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", ")", "continue", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_reservation", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno0", ")", "||", "!", "HARD_REGISTER_NUM_P", "(", "regno1", ")", ")", "return", "false", ";", "if", "(", "INT_REGNO_P", "(", "regno0", ")", "&&", "VSX_REGNO_P", "(", "regno1", ")", ")", "return", "true", ";", "if", "(", "VSX_REGNO_P", "(", "regno0", ")", "&&", "INT_REGNO_P", "(", "regno1", ")", ")", "return", "true", ";", "return", "false", ";" ]

[ "case", "ImmTyOpSelHi", ":", "OS", "<<", "<STR_LIT>", "OpSelHi", "<STR_LIT>", ";", "break", ";" ]

[ "case", "ImmTyDppRowMask", ":", "OS", "<<", "<STR_LIT>", "DppRowMask", "<STR_LIT>", ";", "break", ";", "case", "ImmTyDppBankMask", ":", "OS", "<<", "<STR_LIT>", "DppBankMask", "<STR_LIT>", ";", "break", ";", "case", "ImmTyDppBoundCtrl", ":", "OS", "<<", "<STR_LIT>", "DppBoundCtrl", "<STR_LIT>", ";", "break", ";", "case", "ImmTySdwaDstSel", ":", "OS", "<<", "<STR_LIT>", "SdwaDstSel", "<STR_LIT>", ";", "break", ";", "case", "ImmTySdwaSrc0Sel", ":", "OS", "<<", "<STR_LIT>", "SdwaSrc0Sel", "<STR_LIT>", ";", "break", ";", "case", "ImmTySdwaSrc1Sel", ":", "OS", "<<", "<STR_LIT>", "SdwaSrc1Sel", "<STR_LIT>", ";", "break", ";", "case", "ImmTySdwaDstUnused", ":", "OS", "<<", "<STR_LIT>", "SdwaDstUnused", "<STR_LIT>", ";", "break", ";", "case", "ImmTyDMask", ":", "OS", "<<", "<STR_LIT>", "DMask", "<STR_LIT>", ";", "break", ";", "case", "ImmTyUNorm", ":", "OS", "<<", "<STR_LIT>", "UNorm", "<STR_LIT>", ";", "break", ";", "case", "ImmTyDA", ":", "OS", "<<", "<STR_LIT>", "DA", "<STR_LIT>", ";", "break", ";", "case", "ImmTyR128", ":", "OS", "<<", "<STR_LIT>", "R128", "<STR_LIT>", ";", "break", ";", "case", "ImmTyLWE", ":", "OS", "<<", "<STR_LIT>", "LWE", "<STR_LIT>", ";", "break", ";", "case", "ImmTyOff", ":", "OS", "<<", "<STR_LIT>", "Off", "<STR_LIT>", ";", "break", ";", "case", "ImmTyExpTgt", ":", "OS", "<<", "<STR_LIT>", "ExpTgt", "<STR_LIT>", ";", "break", ";", "case", "ImmTyExpCompr", ":", "OS", "<<", "<STR_LIT>", "ExpCompr", "<STR_LIT>", ";", "break", ";", "case", "ImmTyExpVM", ":", "OS", "<<", "<STR_LIT>", "ExpVM", "<STR_LIT>", ";", "break", ";", "case", "ImmTyHwreg", ":", "OS", "<<", "<STR_LIT>", "Hwreg", "<STR_LIT>", ";", "break", ";", "case", "ImmTySendMsg", ":", "OS", "<<", "<STR_LIT>", "SendMsg", "<STR_LIT>", ";", "break", ";", "case", "ImmTyInterpSlot", ":", "OS", "<<", "<STR_LIT>", "InterpSlot", "<STR_LIT>", ";", "break", ";", "case", "ImmTyInterpAttr", ":", "OS", "<<", "<STR_LIT>", "InterpAttr", "<STR_LIT>", ";", "break", ";", "case", "ImmTyAttrChan", ":", "OS", "<<", "<STR_LIT>", "AttrChan", "<STR_LIT>", ";", "break", ";", "case", "ImmTyOpSel", ":", "OS", "<<", "<STR_LIT>", "OpSel", "<STR_LIT>", ";", "break", ";" ]

[ "static", "tree", "rs6000_builtin_vectorized_libmass", "(", "combined_fn", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "<NUM_LIT>", "]", ";", "const", "char", "*", "suffix", "=", "NULL", ";", "tree", "fntype", ",", "new", "_", "fndecl", ",", "bdecl", "=", "NULL_TREE", ";", "int", "n_args", "=", "<NUM_LIT>", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "flag_unsafe_math_optimizations", "||", "!", "TARGET_VSX", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "CASE_CFN_ATAN2", ":", "CASE_CFN_HYPOT", ":", "CASE_CFN_POW", ":", "n_args", "=", "<NUM_LIT>", ";", "gcc_fallthrough", "(", ")", ";", "CASE_CFN_ACOS", ":", "CASE_CFN_ACOSH", ":", "CASE_CFN_ASIN", ":", "CASE_CFN_ASINH", ":", "CASE_CFN_ATAN", ":", "CASE_CFN_ATANH", ":", "CASE_CFN_CBRT", ":", "CASE_CFN_COS", ":", "CASE_CFN_COSH", ":", "CASE_CFN_ERF", ":", "CASE_CFN_ERFC", ":", "CASE_CFN_EXP2", ":", "CASE_CFN_EXP", ":", "CASE_CFN_EXPM1", ":", "CASE_CFN_LGAMMA", ":", "CASE_CFN_LOG10", ":", "CASE_CFN_LOG1P", ":", "CASE_CFN_LOG2", ":", "CASE_CFN_LOG", ":", "CASE_CFN_SIN", ":", "CASE_CFN_SINH", ":", "CASE_CFN_SQRT", ":", "CASE_CFN_TAN", ":", "CASE_CFN_TANH", ":", "if", "(", "el_mode", "==", "DFmode", "&&", "n", "==", "<NUM_LIT>", ")", "{", "bdecl", "=", "mathfn_built_in", "(", "double_type_node", ",", "fn", ")", ";", "suffix", "=", "<STR_LIT>", "d2", "<STR_LIT>", ";", "}", "else", "if", "(", "el_mode", "==", "SFmode", "&&", "n", "==", "<NUM_LIT>", ")", "{", "bdecl", "=", "mathfn_built_in", "(", "float_type_node", ",", "fn", ")", ";", "suffix", "=", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "}", "else", "return", "NULL_TREE", ";", "if", "(", "!", "bdecl", ")", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "gcc_assert", "(", "suffix", "!=", "NULL", ")", ";", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "bdecl", ")", ")", ";", "if", "(", "!", "bname", ")", "return", "NULL_TREE", ";", "strcpy", "(", "name", ",", "bname", "+", "strlen", "(", "<STR_LIT>", "__builtin_", "<STR_LIT>", ")", ")", ";", "strcat", "(", "name", ",", "suffix", ")", ";", "if", "(", "n_args", "==", "<NUM_LIT>", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "if", "(", "n_args", "==", "<NUM_LIT>", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "new", "_", "fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new", "_", "fndecl", ")", "=", "<NUM_LIT>", ";", "DECL_EXTERNAL", "(", "new", "_", "fndecl", ")", "=", "<NUM_LIT>", ";", "DECL_IS_NOVOPS", "(", "new", "_", "fndecl", ")", "=", "<NUM_LIT>", ";", "TREE_READONLY", "(", "new", "_", "fndecl", ")", "=", "<NUM_LIT>", ";", "return", "new", "_", "fndecl", ";", "}" ]

[ "Handler", "for", "the", "Mathematical", "Acceleration", "Subsystem", "(", "mass", ")", "interface", "to", "a", "library", "with", "vectorized", "intrinsics", "." ]

[ "]", ")" ]

[ "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "emit_insn", "(", "gen_sub2_insn", "(", "out", ",", "addr", ")", ")", ";" ]

[ "bool", "ix86_expand_strlen", "(", "rtx", "out", ",", "rtx", "src", ",", "rtx", "eoschar", ",", "rtx", "align", ")", "{", "if", "(", "TARGET_UNROLL_STRLEN", "&&", "TARGET_INLINE_ALL_STRINGOPS", "&&", "eoschar", "==", "const0_rtx", "&&", "optimize", ">", "<NUM_LIT>", ")", "{", "rtx", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ")", ";", "emit_move_insn", "(", "out", ",", "addr", ")", ";", "ix86_expand_strlensi_unroll_1", "(", "out", ",", "src", ",", "align", ")", ";" ]

[ ",", "GPR32", ",", "asm", ",", "frag", ">", "{" ]

[ "ARM64CC", ":", ":", "CondCode", "CC", "=", "static_cast", "<", "ARM64CC", ":", ":", "CondCode", ">", "(", "N", "-", ">", "getZExtValue", "(", ")", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "ARM64CC", ":", ":", "getInvertedCondCode", "(", "CC", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "multiclass", "CondSelectOp", "<", "bit", "op", ",", "bits", "<", "<NUM_LIT>", ">", "op2", ",", "string", "asm", ",", "PatFrag", "frag", ">", "{", "def", "Wr", ":", "BaseCondSelectOp", "<", "op", ",", "op2" ]

[ "<FIXS>", "if", "(", "!", "validateConstPtrAlignment", "(", "LN", "->", "getBasePtr", "(", ")", ",", "ClaimAlign", ",", "dl", ",", "DAG", ")", ")", "return", "replaceMemWithUndef", "(", "Op", ",", "DAG", ")", ";", "<FIXE>" ]

[ "}", "Align", "ClaimAlign", "=", "LN", "->", "getAlign", "(", ")", ";", "<BUGS>", "validateConstPtrAlignment", "(", "LN", "->", "getBasePtr", "(", ")", ",", "ClaimAlign", ",", "dl", ")", ";", "<BUGE>", "SDValue", "LU", "=", "LowerUnalignedLoad", "(", "SDValue", "(", "LN", ",", "<NUM_LIT>", ")", ",", "DAG", ")", ";" ]

[ ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ ")", ",", "(", "f64", "(", "XSCVUXDDP", "(", "XXEXTRACTUW", "$", "A", ",", "<NUM_LIT>", ")", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "f64", "(", "PPCfcfidu", "(", "f64", "(", "PPCmtvsrz", "(", "i32", "(", "extractelt", "v4i32", ":", "$", "A", ",", "<NUM_LIT>", ")", ")", ")", ")", ")" ]

[ "[", "<NUM_LIT>", "]", ")" ]

[ "return", "output_scc_di", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "const0_rtx", ",", "operands" ]

[ "return", "S", ";" ]

[ "BRIGDwarfStreamer", "*", "S", "=", "new", "BRIGDwarfStreamer", "(", "Context", ",", "MAB", ",", "RVOS", ",", "CE", ")", ";", "if", "(", "RelaxAll", ")", "S", "->", "getAssembler", "(", ")", ".", "setRelaxAll", "(", "true", ")", ";" ]

[ "let", "Switches", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=", "(", "ins", "IRF", ":", "$", "coords", ",", "TnsrRegSt", ":", "$", "tensor", ",", "Rsrc", ":", "$", "value", ",", "SwitchSet", ":", "$", "sw", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_StoreTensor", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "coords", ";", "bits", "<", "<NUM_LIT>", ">", "tensor", ";", "bits", "<", "<NUM_LIT>", ">", "value", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "coords", ";", "let", "SrcB", "=", "tensor", ";", "let", "SrcExtra", "=", "value", ";", "let", "Switches", "=", "sw", ";" ]

[ "N", ",", "Convert", ")", ";" ]

[ "MVT", "LoadVT", "=", "MVT", "::", "getVectorVT", "(", "MemVT", ",", "<NUM_LIT>", "/", "NumBits", ")", ";", "if", "(", "SDValue", "VZLoad", "=", "narrowLoadToVZLoad", "(", "LN", ",", "MemVT", ",", "LoadVT", ",", "DAG", ")", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "IsStrict", ")", "{", "SDValue", "Convert", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "{", "VT", ",", "MVT", "::", "Other", "}", ",", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getBitcast", "(", "InVT", ",", "VZLoad", ")", "}", ")", ";", "DCI", ".", "CombineTo", "(", "N", ",", "Convert", ",", "Convert", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "SDValue", "Convert", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VT", ",", "DAG", ".", "getBitcast", "(", "InVT", ",", "VZLoad", ")", ")", ";", "DCI", ".", "CombineTo", "(" ]

[ "}" ]

[ "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "}" ]

[ "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "count_op", "!=", "count_ideal", ")", "return", "false", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "count_ideal", ";", "i", "++", ")", "{", "rtx", "elt_op", "=", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "i", ")", ";", "rtx", "elt_ideal", "=", "XVECEXP", "(", "ideal", ",", "<NUM_LIT>", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt_op", ")", "||", "INTVAL", "(", "elt_ideal", ")", "!=", "INTVAL", "(", "elt_op", ")", ")", "return", "false", ";" ]

[ "}" ]

[ "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

[ "$", "idx", ")", ";" ]

[ "let", "ParserMatchClass", "=", "VecListFourDByteIndexAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd", ",", "i32imm", ":" ]

[ "SDValue", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i64", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "MVT", "::", "i64", ")", ")", ";" ]

[ "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "EVT", "ArgVT", "=", "MVT", "::", "getIntegerVT", "(", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "SDValue", "BasePtr", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "MRI", ".", "getLiveInVirtReg", "(", "AMDGPU", "::", "SGPR0_SGPR1", ")", ",", "MVT", "::", "i64", ")", ";" ]

[ "<FIXS>", "if", "(", "n", ">=", "<NUM_LIT>", ")", "<FIXE>" ]

[ "if", "(", "arg", "==", "error_mark_node", ")", "return", "error_mark_node", ";", "<BUGS>", "if", "(", "n", ">=", "<NUM_LIT>", ")", "<BUGE>", "abort", "(", ")", ";", "arg", "=", "default_conversion", "(", "arg", ")", ";" ]

[ "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask3_fmadd_sh", "(", "_", "_", "m128h", "_", "_", "W", ",", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", ",", "_", "_", "mmask8", "_", "_", "U", ")", "{", "return", "(", "_", "_", "m128h", ")", "_", "_", "builtin_ia32_vfmaddsh3_mask3", "(", "(", "_", "_", "v8hf", ")", "_", "_", "W", ",", "(", "_", "_", "v8hf", ")", "_", "_", "A", ",", "(", "_", "_", "v8hf", ")", "_", "_", "B", ",", "(", "_", "_", "mmask8", ")", "_" ]

[ "let", "Pattern", "=", "pattern", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=", "(", "ins", ")", ";" ]

[ "return", "_", "_", "ev_subfssiaaw", "(", "t", ")", ";" ]

[ "static", "inline", "_", "_", "ev64_opaque__", "_", "_", "internal_ev_mwhssianw", "(", "_", "_", "ev64_opaque__", "a", ",", "_", "_", "ev64_opaque__", "b", ")", "{", "_", "_", "ev64_opaque__", "t", ";", "t", "=", "_", "_", "ev_mwhsmi", "(", "a", ",", "b", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_query_cpu_unit", "<STR_LIT>" ]

[ "<NUM_LIT>", ";" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

[ "<FIXS>", "mep_rtx_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "<FIXE>" ]

[ "}", "static", "bool", "<BUGS>", "mep_rtx_cost", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "<BUGE>", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "ATTRIBUTE_UNUSED", "speed_t", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":" ]

[ "<FIXS>", "<STR_LIT>", ")", "<FIXE>" ]

[ "(", "plus", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "unsigned", "getOpSize", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "unsigned", "SubReg", "=", "MO", ".", "getSubReg", "(", ")", ")", "{", "assert", "(", "RI", ".", "getRegSizeInBits", "(", "*", "RI", ".", "getSubClassWithSubReg", "(", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ",", "SubReg", ")", ")", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Sub-dword subregs are not supported", "<STR_LIT>", ")", ";", "return", "RI", ".", "getNumChannelsFromSubReg", "(", "SubReg", ")", "*", "<NUM_LIT>", ";", "}", "}", "return", "RI", ".", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "MI", ",", "OpNo", ")", ")", "/", "<NUM_LIT>", ";", "}" ]

[ "This", "form", "should", "usually", "be", "preferred", "since", "it", "handles", "operands", "with", "unknown", "register", "classes", "." ]

[ "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AssertSext", ")", "return", "true", ";" ]

[ "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", "&&", "N", ".", "getOperand", "(" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "and", "(", "and", "(", "and" ]

[ "Other", ",", "Ops", ")", ";" ]

[ "bool", "isELFv2ABI", "=", "Subtarget", ".", "isELFv2ABI", "(", ")", ";", "std", "::", "vector", "<", "EVT", ">", "NodeTys", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "unsigned", "CallOpc", "=", "PrepareCall", "(", "DAG", ",", "Callee", ",", "InFlag", ",", "Chain", ",", "dl", ",", "SPDiff", ",", "isTailCall", ",", "RegsToPass", ",", "Ops", ",", "NodeTys", ",", "Subtarget", ")", ";", "if", "(", "isVarArg", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "PPC", "::", "CR1EQ", ",", "MVT", "::", "i32", ")", ")", ";", "int", "BytesCalleePops", "=", "(", "CallConv", "==", "CallingConv", "::", "Fast", "&&", "getTargetMachine", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "?", "NumBytes", ":", "<NUM_LIT>", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "if", "(", "isTailCall", ")", "{", "assert", "(", "(", "(", "Callee", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Register", "&&", "cast", "<", "RegisterSDNode", ">", "(", "Callee", ")", "->", "getReg", "(", ")", "==", "PPC", "::", "CTR", ")", "||", "Callee", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetExternalSymbol", "||", "Callee", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TargetGlobalAddress", "||", "isa", "<", "ConstantSDNode", ">", "(", "Callee", ")", ")", "&&", "<STR_LIT>", "Expecting an global address, external symbol, absolute value or register", "<STR_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::" ]

[ "}" ]

[ "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "cc_mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label_ref", ")", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";" ]

[ ")", ";" ]

[ "assert", "(", "LLTy", ".", "getElementType", "(", ")", "==", "PartLLT", ".", "getElementType", "(", ")", ")", ";", "int", "DstElts", "=", "LLTy", ".", "getNumElements", "(", ")", ";", "int", "PartElts", "=", "PartLLT", ".", "getNumElements", "(", ")", ";", "if", "(", "DstElts", "%", "PartElts", "==", "<NUM_LIT>", ")", "B", ".", "buildConcatVectors", "(", "OrigRegs", "[", "<NUM_LIT>", "]", ",", "Regs", ")", ";", "else", "{", "assert", "(", "PartElts", "==", "<NUM_LIT>", "&&", "DstElts", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", ";", "int", "RoundedElts", "=", "PartElts", "*", "(", "(", "DstElts", "+", "PartElts", "-", "<NUM_LIT>", ")", "/", "PartElts", ")", ";", "LLT", "RoundedDestTy", "=", "LLT", "::", "vector", "(", "RoundedElts", ",", "PartLLT", ".", "getElementType", "(", ")", ")", ";", "auto", "RoundedConcat", "=", "B", ".", "buildConcatVectors", "(", "RoundedDestTy", ",", "Regs", ")", ";", "B", ".", "buildExtract", "(", "OrigRegs", "[", "<NUM_LIT>", "]", ",", "RoundedConcat", ",", "<NUM_LIT>", ")", ";", "}", "return", ";", "}", "assert", "(", "LLTy", ".", "isVector", "(", ")", "&&", "!", "PartLLT", ".", "isVector", "(", ")", ")", ";", "LLT", "DstEltTy", "=", "LLTy", ".", "getElementType", "(", ")", ";", "if", "(", "DstEltTy", "==", "PartLLT", ")", "{", "B", ".", "buildBuildVector", "(", "OrigRegs", "[", "<NUM_LIT>", "]", ",", "Regs", ")", ";", "}", "else", "if", "(", "DstEltTy", ".", "getSizeInBits", "(", ")", ">", "PartLLT", ".", "getSizeInBits", "(", ")", ")", "{", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "EltMerges", ";", "int", "PartsPerElt", "=", "DstEltTy", ".", "getSizeInBits", "(", ")", "/", "PartLLT", ".", "getSizeInBits", "(" ]

[ "}" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Remove:", "<STR_LIT>", ";", "Inst", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "'", "\\n", "'", ")", ";", "Changed", "=", "true", ";", "Inst", "->", "eraseFromParent", "(", ")", ";", "ToErase", "=", "&", "I", ";", "}", "continue", ";", "}", "if", "(", "auto", "*", "LD", "=", "dyn_cast", "<", "LoadInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "!", "LD", "->", "hasOneUser", "(", ")", ")", "continue", ";", "auto", "*", "Call", "=", "dyn_cast", "<", "CallInst", ">", "(", "*", "LD", "->", "user_begin", "(", ")", ")", ";", "if", "(", "!", "Call", ")", "continue", ";", "auto", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "Call", "->", "getCalledOperand", "(", ")", ")", ";", "if", "(", "!", "GV", ")", "continue", ";", "if", "(", "!", "GV", "->", "getName", "(", ")", ".", "equals", "(", "<STR_LIT>", "llvm.stackrestore", "<STR_LIT>", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Remove:", "<STR_LIT>", ";", "I", ".", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Remove:", "<STR_LIT>", ";", "Call", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "'", "\\n", "'", ")", ";", "Changed", "=", "true", ";", "Call", "->", "eraseFromParent", "(", ")", ";", "ToErase", "=", "&", "I", ";", "}" ]

[ "assert", "(", "BotResult", "!=", "NoCand", "&&", "<STR_LIT>", "failed to find the first candidate", "<STR_LIT>", ")", ";" ]

[ "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "<STR_LIT>", "failed to find the first candidate", "<STR_LIT>", ")", ";", "(", "void", ")", "TopResult", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "ForceBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";" ]

[ ",", "imm", ":", "$", "offs", ")", ")", "]", ">", ",", "Requires", "<", "[", "]", ">", ";" ]

[ "def", "STWPtrPiRr", ":", "Pseudo", "<", "(", "outs", "IndexRegs", ":", "$", "base_wb", ")", ",", "(", "ins", "IndexRegs", ":", "$", "ptrreg", ",", "MainRegs", ":", "$", "trh", ",", "i16imm", ":", "$", "offs", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "IndexRegs", ":", "$", "base_wb", ",", "(", "post_store", "MainRegs", ":", "$", "trh", ",", "IndexRegs", ":", "$", "ptrreg" ]

[ "||", "!", "isa", "<", "ConstantSDNode", ">", "(", "N", ")", ")", "return", "false", ";" ]

[ "EVT", "T", "=", "N", ".", "getValueType", "(", ")", ";", "if", "(", "!", "T", ".", "isInteger", "(", ")", "||", "T", ".", "getSizeInBits", "(", ")", "!=", "<NUM_LIT>" ]

[ "MSP430_BUILTIN_DELAY_CYCLES", ":" ]

[ "switch", "(", "code", ")", "{", "case", "MSP430_BUILTIN_BIC_SR", ":", "case", "MSP430_BUILTIN_BIS_SR", ":", "case" ]

[ "call_interrupt_p", "=", "lookup_attribute", "(", "<STR_LIT>", "interrupt", "<STR_LIT>", ",", "TYPE_ATTRIBUTES", "(", "fn_type", ")", ")", "!=", "NULL", ";" ]

[ "tree", "fn_type", "=", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ";", "gcc_assert", "(", "POINTER_TYPE_P", "(", "fn_type", ")", ")", ";", "fn_type", "=", "TREE_TYPE", "(", "fn_type", ")", ";", "gcc_assert", "(", "FUNC_OR_METHOD_TYPE_P", "(", "fn_type", ")", ")", ";" ]

[ "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ISD", "::", "INLINEASM", "||", "Opc", "==", "ISD", "::", "INLINEASM_BR", ")", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "if", "(", "isHvxOperation", "(", "Op", ")", ")", "{", "if", "(", "SDValue", "V", "=", "LowerHvxOperation", "(", "Op", ",", "DAG", ")", ")", "return", "V", ";", "}", "switch", "(", "Opc", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dumpr", "(", "&", "DAG", ")", ";", "if", "(", "Opc", ">", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Opc", "<", "<STR_LIT>", "::", "<STR_LIT>", ")", "errs", "(", ")", "<<", "<STR_LIT>", "Error: check for a non-legal type in this operation\\n", "<STR_LIT>", ";", "llvm_unreachable", "(", "<STR_LIT>", "Should not custom lower this!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "LowerINSERT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "LowerBITCAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UADDO", ":", "case", "ISD", "::", "USUBO", ":", "return", "LowerUAddSubO", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDCARRY", ":", "case", "ISD", "::", "SUBCARRY", ":", "return", "LowerAddSubCarry", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerVECTOR_SHIFT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ROTL", ":", "return", "LowerROTL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "return", "LowerREADCYCLECOUNTER", "(", "Op", ",", "DAG", ")", ";", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "void", "FixupLEAPass", "::", "processInstruction", "(", "MachineBasicBlock", "::", "iterator", "&", "I", ",", "MachineBasicBlock", "&", "MBB", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "int", "AddrOffset", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "AddrOffset", ">=", "<NUM_LIT>", ")", "{", "AddrOffset", "+=", "<STR_LIT>", "::", "<STR_LIT>", "(", "Desc", ")", ";", "MachineOperand", "&", "p", "=", "MI", ".", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "p", ".", "isReg", "(", ")", "&&", "p", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "p", ",", "I", ",", "MBB", ")", ";", "}", "MachineOperand", "&", "q", "=", "MI", ".", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrIndexReg", ")", ";", "if", "(", "q", ".", "isReg", "(", ")", "&&", "q", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "q", ",", "I", ",", "MBB", ")", ";", "}", "}", "}" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "SImmS4XForm", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "/", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "SImmS16XForm", ":", "SDNodeXForm", "<", "imm", ",", "[", "{" ]

[ "}" ]

[ "def", "L4_and_memoph_zomap", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_7186d325", ",", "TypeMAPPING", ">", "{", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";" ]

[ "der", ")", ";" ]

[ "if", "(", "!", "DisableFunctionSplitterRewrite", ")", "rewriteCode", "(", ")", ";", "reorderBlocks", "(", "or" ]

[ "}" ]

[ "static", "bool", "isVGPRToSGPRCopy", "(", "const", "TargetRegisterClass", "*", "SrcRC", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "const", "SIRegisterInfo", "&", "TRI", ")", "{", "return", "TRI", ".", "isSGPRClass", "(", "DstRC", ")", "&&", "TRI", ".", "hasVGPRs", "(", "SrcRC", ")", ";" ]

[ "<STR_LIT>", ")", ";" ]

[ "else", "if", "(", "Imm", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "else", "if", "(", "Imm", "==", "DoubleToBits", "(", "-", "<NUM_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "-0.5", "<STR_LIT>", ";", "else", "if", "(", "Imm", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "else", "if", "(", "Imm", "==", "DoubleToBits", "(", "-", "<NUM_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "-2.0", "<STR_LIT>", ";", "else", "if", "(", "Imm", "==", "DoubleToBits", "(", "<NUM_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "else", "if", "(", "Imm", "==", "DoubleToBits", "(", "-", "<NUM_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "-4.0", "<STR_LIT>", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "<NUM_LIT>" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "I48MODE", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "I48MODE", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "any_extend", ":", "DI", "(", "unspec", ":", "I124MODE", "[", "(", "mem", ":", "I124MODE", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "UNSPEC_LATENCY_L2", ")", ")", ")", "]" ]

[ ")", "]", ")" ]

[ "(", "unsigned_fix", ":", "DI", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "StoreBB", "->", "addSuccessor", "(", "DoneBB", ")", ";" ]

[ "unsigned", "CMPrr", "=", "IsThumb", "?", "ARM", "::", "tCMPhir", ":", "ARM", "::", "CMPrr", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "CMPrr", ")", ")", ".", "addReg", "(", "DestLo", ",", "getKillRegState", "(", "Dest", ".", "isDead", "(", ")", ")", ")", ".", "addReg", "(", "DesiredLo", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "CMPrr", ")", ")", ".", "addReg", "(", "DestHi", ",", "getKillRegState", "(", "Dest", ".", "isDead", "(", ")", ")", ")", ".", "addReg", "(", "DesiredHi", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ",", "RegState", "::", "Kill", ")", ";", "unsigned", "Bcc", "=", "IsThumb", "?", "ARM", "::", "tBcc", ":", "ARM", "::", "Bcc", ";", "BuildMI", "(", "LoadCmpBB", ",", "DL", ",", "TII", "->", "get", "(", "Bcc", ")", ")", ".", "addMBB", "(", "DoneBB", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ",", "RegState", "::", "Kill", ")", ";", "LoadCmpBB", "->", "addSuccessor", "(", "DoneBB", ")", ";", "LoadCmpBB", "->", "addSuccessor", "(", "StoreBB", ")", ";", "unsigned", "STREXD", "=", "IsThumb", "?", "ARM", "::", "t2STREXD", ":", "ARM", "::", "STREXD", ";", "MIB", "=", "BuildMI", "(", "StoreBB", ",", "DL", ",", "TII", "->", "get", "(", "STREXD", ")", ",", "TempReg", ")", ";", "addExclusiveRegPair", "(", "MIB", ",", "New", ",", "<NUM_LIT>", ",", "IsThumb", ",", "TRI", ")", ";", "MIB", ".", "addReg", "(", "AddrReg", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "unsigned", "CMPri", "=", "IsThumb", "?", "ARM", "::", "t2CMPri", ":", "ARM", "::", "CMPri", ";", "BuildMI", "(", "StoreBB", ",", "DL", ",", "TII", "->", "get", "(", "CMPri", ")", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "BuildMI", "(", "StoreBB", ",", "DL", ",", "TII", "->", "get", "(", "Bcc", ")", ")", ".", "addMBB", "(", "LoadCmpBB", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ",", "RegState", "::", "Kill", ")", ";", "StoreBB", "->", "addSuccessor", "(", "LoadCmpBB", ")", ";" ]

[ "(", "match_operand", ":", "FMSA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "FMSA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "div", ":", "FMSA", "(", "match_operand", ":", "FMSA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "return", "CSR_AArch64_CXX_TLS_Darwin_ViaCopy_SaveList", ";" ]

[ "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegsViaCopy", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "<STR_LIT>", "Invalid MachineFunction pointer.", "<STR_LIT>", ")", ";" ]

[ "return", "true", ";" ]

[ "SDValue", "Input0", "=", "(", "OpInputs", ".", "size", "(", ")", ">", "<NUM_LIT>", "?", "OpInputs", "[", "<NUM_LIT>", "]", ":", "SDValue", "(", ")", ")", ";", "SDValue", "Input1", "=", "(", "OpInputs", ".", "size", "(", ")", ">", "<NUM_LIT>", "?", "OpInputs", "[", "<NUM_LIT>", "]", ":", "SDValue", "(", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", "(", "SrcOps", ".", "begin", "(", ")", ",", "SrcOps", ".", "end", "(", ")", ")", ";", "int", "InputIdx0", "=", "-", "<NUM_LIT>", ",", "InputIdx1", "=", "-", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "Ops", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SDValue", "BC", "=", "peekThroughBitcasts", "(", "Ops", "[", "i", "]", ")", ";", "if", "(", "Input0", "&&", "BC", "==", "peekThroughBitcasts", "(", "Input0", ")", ")", "InputIdx0", "=", "i", ";", "if", "(", "Input1", "&&", "BC", "==", "peekThroughBitcasts", "(", "Input1", ")", ")", "InputIdx1", "=", "i", ";", "}", "if", "(", "Input0", "&&", "InputIdx0", "<", "<NUM_LIT>", ")", "{", "InputIdx0", "=", "SrcOpIndex", ";", "Ops", "[", "SrcOpIndex", "]", "=", "Input0", ";", "}", "if", "(", "Input1", "&&", "InputIdx1", "<", "<NUM_LIT>", ")", "{", "InputIdx1", "=", "Ops", ".", "size", "(", ")", ";", "Ops", ".", "push_back", "(", "Input1", ")", ";", "}", "assert", "(", "(", "(", "RootMask", ".", "size", "(", ")", ">", "OpMask", ".", "size", "(", ")", "&&", "RootMask", ".", "size", "(", ")", "%", "OpMask", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "||", "(", "OpMask", ".", "size", "(", ")", ">", "RootMask", ".", "size", "(", ")", "&&", "OpMask", ".", "size", "(", ")", "%", "RootMask", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "||", "OpMask", ".", "size", "(", ")", "==", "RootMask", ".", "size", "(", ")", ")", "&&", "<STR_LIT>", "The smaller number of elements must divide the larger.", "<STR_LIT>", ")", ";", "int", "MaskWidth", "=", "std", "::", "max", "<", "int", ">", "(", "OpMask", ".", "size", "(", ")", ",", "RootMask", ".", "size", "(", ")", ")", ";", "int", "RootRatio", "=", "std", "::", "max", "<", "int", ">", "(", "<NUM_LIT>", ",", "OpMask", ".", "size", "(", ")", "/", "RootMask", ".", "size", "(", ")", ")", ";", "int", "OpRatio", "=", "std", "::", "max", "<", "int", ">", "(", "<NUM_LIT>", ",", "RootMask", ".", "size", "(", ")", "/", "OpMask", ".", "size", "(", ")", ")", ";", "assert", "(", "(", "(", "RootRatio", "==", "<NUM_LIT>", "&&", "OpRatio", "==", "<NUM_LIT>", ")", "||", "(", "RootRatio", "==", "<NUM_LIT>", ")", "!=", "(", "OpRatio", "==", "<NUM_LIT>", ")", ")", "&&", "<STR_LIT>", "Must not have a ratio for both incoming and op masks!", "<STR_LIT>", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", ";", "Mask", ".", "reserve", "(", "MaskWidth", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "MaskWidth", ";", "++", "i", ")", "{", "int", "RootIdx", "=", "i", "/", "RootRatio", ";", "if", "(", "RootMask", "[", "RootIdx", "]", "<", "<NUM_LIT>", ")", "{", "Mask", ".", "push_back", "(", "RootMask", "[", "RootIdx", "]", ")", ";", "continue", ";", "}", "int", "RootMaskedIdx", "=", "RootMask", "[", "RootIdx", "]", "*", "RootRatio", "+", "i", "%", "RootRatio", ";", "if", "(", "(", "RootMaskedIdx", "<", "(", "SrcOpIndex", "*", "MaskWidth", ")", ")", "||", "(", "(", "(", "SrcOpIndex", "+", "<NUM_LIT>", ")", "*", "MaskWidth", ")", "<=", "RootMaskedIdx", ")", ")", "{", "Mask", ".", "push_back", "(", "RootMaskedIdx", ")", ";", "continue", ";", "}", "RootMaskedIdx", "%=", "MaskWidth", ";", "int", "OpIdx", "=", "RootMaskedIdx", "/", "OpRatio", ";", "if", "(", "OpMask", "[", "OpIdx", "]", "<", "<NUM_LIT>", ")", "{", "Mask", ".", "push_back", "(", "OpMask", "[", "OpIdx", "]", ")", ";", "continue", ";", "}", "int", "OpMaskedIdx", "=", "OpMask", "[", "OpIdx", "]", "*", "OpRatio", "+", "RootMaskedIdx", "%", "OpRatio", ";", "OpMaskedIdx", "%=", "MaskWidth", ";", "if", "(", "OpMask", "[", "OpIdx", "]", "<", "(", "int", ")", "OpMask", ".", "size", "(", ")", ")", "{", "assert", "(", "<NUM_LIT>", "<=", "InputIdx0", "&&", "<STR_LIT>", "Unknown target shuffle input", "<STR_LIT>", ")", ";", "OpMaskedIdx", "+=", "InputIdx0", "*", "MaskWidth", ";", "}", "else", "{", "assert", "(", "<NUM_LIT>", "<=", "InputIdx1", "&&", "<STR_LIT>", "Unknown target shuffle input", "<STR_LIT>", ")", ";", "OpMaskedIdx", "+=", "InputIdx1", "*", "MaskWidth", ";", "}", "Mask", ".", "push_back", "(", "OpMaskedIdx", ")", ";", "}", "if", "(", "all_of", "(", "Mask", ",", "[", "]", "(", "int", "Idx", ")", "{", "return", "Idx", "==", "SM_SentinelUndef", ";", "}", ")", ")", "{", "DCI", ".", "CombineTo", "(", "Root", ".", "getNode", "(", ")", ",", "DAG", ".", "getUNDEF", "(", "Root", ".", "getValueType", "(", ")", ")", ")", ";", "return", "true", ";", "}", "if", "(", "all_of", "(", "Mask", ",", "[", "]", "(", "int", "Idx", ")", "{", "return", "Idx", "<", "<NUM_LIT>", ";", "}", ")", ")", "{", "DCI", ".", "CombineTo", "(", "Root", ".", "getNode", "(", ")", ",", "getZeroVector", "(", "Root", ".", "getSimpleValueType", "(", ")", ",", "Subtarget", ",", "DAG", ",", "SDLoc", "(", "Root", ")", ")", ")", ";" ]

[ "<FIXS>", "FeatureSDWA", ",", "FeatureSDWAOutModsVOPC", ",", "FeatureSDWAMac", ",", "FeatureDPP", ",", "FeatureIntClamp", "<FIXE>" ]

[ "FeatureGCN3Encoding", ",", "FeatureCIInsts", ",", "Feature16BitInsts", ",", "FeatureSMemRealTime", ",", "FeatureVGPRIndexMode", ",", "FeatureMovrel", ",", "FeatureScalarStores", ",", "FeatureInv2PiInlineImm", ",", "<BUGS>", "FeatureSDWA", ",", "FeatureSDWAOutModsVOPC", ",", "FeatureSDWAMac", ",", "FeatureDPP", "<BUGE>", "]", ">", ";" ]