Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "let", "isCommutable", "=", "<NUM_LIT>", ";" ]

[ "class", "N3VQIntSh", "<", "bit", "op24", ",", "bit", "op23", ",", "bits", "<", "<NUM_LIT>", ">", "op21_20", ",", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bit", "op4", ",", "Format", "f", ",", "InstrItinClass", "itin", ",", "string", "OpcodeStr", ",", "string", "Dt", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "SDPatternOperator", "IntOp", ">", ":", "N3V", "<", "op24", ",", "op23", ",", "op21_20", ",", "op11_8", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "QPR", ":", "$", "Vm", ",", "QPR", ":", "$", "Vn", ")", ",", "f", ",", "itin", ",", "OpcodeStr", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "QPR", ":", "$", "Vd", ",", "(", "ResTy", "(", "IntOp", "(", "OpTy", "QPR", ":", "$", "Vm", ")", ",", "(", "OpTy", "QPR", ":", "$", "Vn", ")", ")", ")", ")", "]", ">", "{", "let", "TwoOperandAliasConstraint", "=", "<STR_LIT>", ";" ]

[ "static", "rtx_code_label", "*", "add_constant", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "rtx", "last_value", ")", "{", "int", "i", ";", "rtx_code_label", "*", "lab", ",", "*", "new", "_", "rtx", ";", "label_ref_list_t", "ref", ",", "new", "ref", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "pool_size", ";", "i", "++", ")", "{", "if", "(", "x", "->", "code", "==", "pool_vector", "[", "i", "]", ".", "value", "->", "code", "&&", "mode", "==", "pool_vector", "[", "i", "]", ".", "mode", ")", "{", "if", "(", "x", "->", "code", "==", "CODE_LABEL", ")", "{", "if", "(", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "!=", "XINT", "(", "pool_vector", "[", "i", "]", ".", "value", ",", "<NUM_LIT>", ")", ")", "continue", ";", "}", "if", "(", "rtx_equal_p", "(", "x", ",", "pool_vector", "[", "i", "]", ".", "value", ")", ")", "{", "lab", "=", "new", "_", "rtx", "=", "<NUM_LIT>", ";", "if", "(", "!", "last_value", "||", "!", "i", "||", "!", "rtx_equal_p", "(", "last_value", ",", "pool_vector", "[", "i", "-", "<NUM_LIT>", "]", ".", "value", ")", ")", "{", "new", "_", "rtx", "=", "gen_label_rtx", "(", ")", ";", "LABEL_REFS", "(", "new", "_", "rtx", ")", "=", "pool_vector", "[", "i", "]", ".", "label", ";", "pool_vector", "[", "i", "]", ".", "label", "=", "lab", "=", "new", "_", "rtx", ";", "}", "if", "(", "lab", "&&", "pool_window_label", ")", "{", "new", "ref", "=", "(", "label_ref_list_t", ")", "pool_alloc", "(", "label_ref_list_pool", ")", ";", "new", "ref", "->", "label", "=", "pool_window_label", ";", "ref", "=", "pool_vector", "[", "pool_window_last", "]", ".", "wend", ";", "new", "ref", "->", "next", "=", "ref", ";", "pool_vector", "[", "pool_window_last", "]", ".", "wend", "=", "new", "ref", ";", "}", "if", "(", "new", "_", "rtx", ")", "pool_window_label", "=", "new", "_", "rtx", ";", "pool_window_last", "=", "i", ";", "return", "lab", ";", "}", "}", "}", "pool_vector", "[", "pool_size", "]", ".", "value", "=", "x", ";", "if", "(", "last_value", "&&", "rtx_equal_p", "(", "last_value", ",", "pool_vector", "[", "pool_size", "-", "<NUM_LIT>", "]", ".", "value", ")", ")", "{", "lab", "=", "<NUM_LIT>", ";", "pool_vector", "[", "pool_size", "-", "<NUM_LIT>", "]", ".", "part_of_sequence_p", "=", "true", ";", "}", "else", "lab", "=", "gen_label_rtx", "(", ")", ";", "pool_vector", "[", "pool_size", "]", ".", "mode", "=", "mode", ";", "pool_vector", "[", "pool_size", "]", ".", "label", "=", "lab", ";", "pool_vector", "[", "pool_size", "]", ".", "wend", "=", "NULL", ";", "pool_vector", "[", "pool_size", "]", ".", "part_of_sequence_p", "=", "(", "lab", "==", "<NUM_LIT>", ")", ";", "if", "(", "lab", "&&", "pool_window_label", ")", "{", "new", "ref", "=", "(", "label_ref_list_t", ")", "pool_alloc", "(", "label_ref_list_pool", ")", ";", "new", "ref", "->", "label", "=", "pool_window_label", ";", "ref", "=", "pool_vector", "[", "pool_window_last", "]", ".", "wend", ";", "new", "ref", "->", "next", "=", "ref", ";", "pool_vector", "[", "pool_window_last", "]", ".", "wend", "=", "new", "ref", ";", "}", "if", "(", "lab", ")", "pool_window_label", "=", "lab", ";", "pool_window_last", "=", "pool_size", ";", "pool_size", "++", ";", "return", "lab", ";", "}" ]

[ "Add", "a", "constant", "to", "the", "pool", "and", "return", "its", "label", "." ]

[ "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "OpNode", "ROWS", ":", "$", "ws", ",", "immZExt6", ":", "$", "m", ")", ")", "]", ";" ]

[ "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWS", ":", "$", "ws", ",", "uimm6", ":", "$", "m", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";" ]

[ ";" ]

[ "bool", "MipsDAGToDAGISel", "::", "selectAddrRegImm", "(", "SDValue", "Addr", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented function.", "<STR_LIT>", ")" ]

[ "void", "Mips16InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Mips", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Mips", "::", "MoveR3216", ";", "else", "if", "(", "Mips", "::", "CPURegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Mips", "::", "Move32R16", ";", "else", "if", "(", "(", "SrcReg", "==", "Mips", "::", "HI", ")", "&&", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ")", "Opc", "=", "Mips", "::", "Mfhi16", ",", "SrcReg", "=", "<NUM_LIT>", ";", "else", "if", "(", "(", "SrcReg", "==", "Mips", "::", "LO", ")", "&&", "(", "Mips", "::", "CPU16RegsRegClass", ".", "contains", "(", "DestReg", ")", ")", ")", "Opc", "=", "Mips", "::", "Mflo16", ",", "SrcReg", "=", "<NUM_LIT>", ";", "assert", "(", "Opc", "&&", "<STR_LIT>", "Cannot copy registers", "<STR_LIT>", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "}" ]

[ "if", "(", "next", "!=", "NULL", "&&", "GET_CODE", "(", "next", ")", "==", "CODE_LABEL", ")", "base_cost", "-=", "<NUM_LIT>", ";", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "CODE_LABEL", ":", "return", "<NUM_LIT>", ";", "case", "INSN", ":", "case", "CALL_INSN", ":", "return", "base_cost", ";", "case", "JUMP_INSN", ":", "return", "base_cost", "-", "<NUM_LIT>", ";", "default", ":", "return", "base_cost", "+", "<NUM_LIT>", ";" ]

[ "int", "includes_rldic_lshift_p", "(", "rtx", "shiftop", ",", "rtx", "and", "op", ")", "{", "if", "(", "GET_CODE", "(", "and", "op", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "c", ",", "lsb", ",", "shift_mask", ";", "c", "=", "INTVAL", "(", "and", "op", ")", ";", "if", "(", "c", "==", "<NUM_LIT>", "||", "c", "==", "HOST_WIDE_INT_M1U", ")", "return", "<NUM_LIT>", ";", "shift_mask", "=", "HOST_WIDE_INT_M1U", ";", "shift_mask", "<<=", "INTVAL", "(", "shiftop", ")", ";", "lsb", "=", "c", "&", "-", "c", ";", "if", "(", "-", "lsb", "!=", "shift_mask", ")", "return", "<NUM_LIT>", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "lsb", "=", "c", "&", "-", "c", ";", "return", "c", "==", "-", "lsb", ";", "}", "else", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "ANDOP", "is", "a", "mask", "suitable", "for", "use", "with", "an", "rldic", "insn", "to", "perform", "a", "left", "shift", ".", "It", "must", "have", "exactly", "SHIFTOP", "least", "significant", "0", "'s", ",", "then", "one", "or", "more", "1", "'s", ",", "then", "zero", "or", "more", "0", "'s", "." ]

[ "}" ]

[ "sp_adjust", "=", "total_frame_size", "-", "cfun", "->", "machine", "->", "save_regs_offset", ";", "}", "else", "if", "(", "!", "UBYTE_INT", "(", "total_frame_size", ")", ")", "{", "pru_add_to_sp", "(", "cfun", "->", "machine", "->", "save_regs_offset", ",", "REG_CFA_ADJUST_CFA", ")", ";", "save_offset", "=", "<NUM_LIT>", ";", "sp_adjust", "=", "total_frame_size", "-", "cfun", "->", "machine", "->", "save_regs_offset", ";", "}", "else", "{", "save_offset", "=", "cfun", "->", "machine", "->", "save_regs_offset", ";", "sp_adjust", "=", "total_frame_size", ";", "}", "regno_start", "=", "<NUM_LIT>", ";", "do", "regno_start", "=", "xbbo_next_reg_cluster", "(", "regno_start", ",", "&", "save_offset", ",", "false", ")", ";", "while", "(", "regno_start", ">=", "<NUM_LIT>", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "sp_adjust", ")", "pru_add_to_sp", "(", "sp_adjust", ",", "REG_CFA_ADJUST_CFA", ")", ";", "if", "(", "!", "sibcall_p", ")", "emit_jump_insn", "(", "gen_simple_return", "(", ")", ")", ";" ]

[ ")", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")" ]

[ ",", "Four", ")", ";" ]

[ "SDLoc", "dl", "(", "Op", ")", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "if", "(", "Op", ".", "getSimpleValueType", "(", ")", ".", "isVector", "(", ")", ")", "return", "lowerUINT_TO_FP_vec", "(", "Op", ",", "DAG", ")", ";", "if", "(", "DAG", ".", "SignBitIsZero", "(", "N0", ")", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "N0", ")", ";", "MVT", "SrcVT", "=", "N0", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", "&&", "(", "SrcVT", "==", "MVT", "::", "i32", "||", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "is64Bit", "(", ")", ")", ")", ")", "{", "return", "Op", ";", "}", "if", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "DstVT", "==", "MVT", "::", "f64", "&&", "X86ScalarSSEf64", ")", "return", "LowerUINT_TO_FP_i64", "(", "Op", ",", "DAG", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i32", "&&", "X86ScalarSSEf64", ")", "return", "LowerUINT_TO_FP_i32", "(", "Op", ",", "DAG", ")", ";", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "SrcVT", "==", "MVT", "::", "i64", "&&", "DstVT", "==", "MVT", "::", "f32", ")", "return", "SDValue", "(", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "CreateStackTemporary", "(", "MVT", "::", "i64", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i32", ")", "{", "SDValue", "OffsetSlot", "=", "DAG", ".", "getMemBasePlusOffset", "(", "StackSlot", ",", "<NUM_LIT>", ",", "dl", ")", ";", "SDValue", "Store1", "=", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "StackSlot", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Store2", "=", "DAG", ".", "getStore", "(", "Store1", ",", "dl", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "OffsetSlot", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Fild", "=", "BuildFILD", "(", "Op", ",", "MVT", "::", "i64", ",", "Store2", ",", "StackSlot", ",", "DAG", ")", ";", "return", "Fild", ";", "}", "assert", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Unexpected type in UINT_TO_FP", "<STR_LIT>", ")", ";", "SDValue", "ValueToStore", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "isScalarFPTypeInSSEReg", "(", "Op", ".", "getValueType", "(", ")", ")", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "ValueToStore", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "f64", ",", "ValueToStore", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "ValueToStore", ",", "StackSlot", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "int", "SSFI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "StackSlot", ")", "->", "getIndex", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "SSFI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "f80", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Store", ",", "StackSlot", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i64", ")", "}", ";", "SDValue", "Fild", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "MVT", "::", "i64", ",", "MMO", ")", ";", "APInt", "FF", "(", "<NUM_LIT>", ",", "<NUM_LIT>", "ULL", ")", ";", "SDValue", "SignSet", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i64", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i64", ")", ",", "ISD", "::", "SETLT", ")", ";", "SDValue", "FudgePtr", "=", "DAG", ".", "getConstantPool", "(", "ConstantInt", "::", "get", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "FF", ".", "zext", "(", "<NUM_LIT>", ")", ")", ",", "PtrVT", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ";", "SDValue", "Four", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "dl", ",", "Zero", ".", "getValueType", "(", ")", ",", "SignSet", ",", "Zero" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "MRI", "->", "setRegClass", "(", "SrcReg", ",", "MRI", "->", "getRegClass", "(", "DstReg", ")", ")", ";", "<FIXE>", "<FIXS>", "MRI", "->", "setType", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "Register", "SrcReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "auto", "*", "Def", "=", "MRI", "->", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "isTypeFoldingSupported", "(", "Def", "->", "getOpcode", "(", ")", ")", ")", "{", "<BUGS>", "if", "(", "MRI", "->", "getType", "(", "DstReg", ")", ".", "isPointer", "(", ")", ")", "MRI", "->", "setType", "(", "DstReg", ",", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "bool", "Res", "=", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "assert", "(", "Res", "||", "Def", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_CONSTANT", ")", ";", "if", "(", "Res", ")", "return", "Res", ";", "}", "<BUGS>", "MRI", "->", "setRegClass", "(", "DstReg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "MRI", "->", "replaceRegWith", "(", "SrcReg", ",", "DstReg", ")", ";", "I", ".", "removeFromParent", "(", ")", ";", "return", "true", ";", "}", "else", "if", "(", "I", ".", "getNumDefs", "(", ")", "==", "<NUM_LIT>", ")", "{", "<BUGS>", "MRI", "->", "setType", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "return", "constrainSelectedInstRegOperands", "(", "I", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}" ]

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

[ "UNSPECV_BLOCKAGEUNSPECV_SETDUNSPECV_SETI", "<BUGS>", "UNSPECV_MOVMEM", "<BUGE>", "]", ")", "(", "define_constants" ]

[ "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";" ]

[ "case", "Instruction", "::", "Store", ":", "return", "X86SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "X86SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "X86SelectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "return", "X86SelectZExt", "(", "I", ")", ";", "case", "Instruction", "::", "SExt", ":", "return", "X86SelectSExt", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "X86SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "return", "X86SelectShift", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "URem", ":", "return", "X86SelectDivRem", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "X86SelectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "X86SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "X86SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "X86SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "X86SelectSIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "{", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "DstVT", ".", "bitsGT", "(", "SrcVT", ")", ")", "return", "X86SelectZExt", "(", "I", ")", ";", "if", "(", "DstVT", ".", "bitsLT", "(", "SrcVT", ")", ")", "return", "X86SelectTrunc", "(", "I", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "case", "Instruction", "::", "BitCast", ":", "{", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "false", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VAXint", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "VAXint", "(", "match_operand", ":", "VAXfp", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "<STR_LIT>" ]

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

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

[ "if", "(", "!", "REG_P", "(", "in", ")", ")", "in", "=", "copy_to_mode_reg", "(", "QImode", ",", "in", ")", ";", "if", "(", "!", "REG_P", "(", "val", ")", "&&", "!", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "copy_to_mode_reg", "(", "QImode", ",", "val", ")", ";", "if", "(", "!", "REG_P", "(", "out", ")", ")", "out", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "in", "=", "simplify_gen_subreg", "(", "HImode", ",", "in", ",", "QImode", ",", "<NUM_LIT>", ")", ";", "outsub", "=", "simplify_gen_subreg", "(", "HImode", ",", "out", ",", "QImode", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "simplify_gen_subreg", "(", "HImode" ]

[ "Register", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";" ]

[ "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{" ]

[ "<FIXS>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "vec_select", ":", "V8HI", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_merge", ":", "V8HI", "(", "vec_select", ":", "V8HI", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "<BUGE>", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "<BUGS>", "(", "const_int", "<NUM_LIT>", ")", "<BUGE>", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "<BUGS>", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "else", "if", "(", "Flags", "&", "X86", "::", "IP_USE_DISP32", ")", "O", "<<", "<STR_LIT>", "\\t{disp32}", "<STR_LIT>", ";" ]

[ "if", "(", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_LOCK", ")", ")", "O", "<<", "<STR_LIT>", "\\tlock\\t", "<STR_LIT>", ";", "if", "(", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_NOTRACK", ")", ")", "O", "<<", "<STR_LIT>", "\\tnotrack\\t", "<STR_LIT>", ";", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "O", "<<", "<STR_LIT>", "\\trepne\\t", "<STR_LIT>", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "O", "<<", "<STR_LIT>", "\\trep\\t", "<STR_LIT>", ";", "if", "(", "(", "Flags", "&", "X86", "::", "IP_USE_VEX", ")", "||", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "O", "<<", "<STR_LIT>", "\\t{vex}", "<STR_LIT>", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_USE_VEX2", ")", "O", "<<", "<STR_LIT>", "\\t{vex2}", "<STR_LIT>", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_USE_VEX3", ")", "O", "<<", "<STR_LIT>", "\\t{vex3}", "<STR_LIT>", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_USE_EVEX", ")", "O", "<<", "<STR_LIT>", "\\t{evex}", "<STR_LIT>", ";", "if", "(", "Flags", "&", "X86", "::", "IP_USE_DISP8", ")", "O", "<<", "<STR_LIT>", "\\t{disp8}", "<STR_LIT>", ";" ]

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

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")" ]

[ "<FIXS>", "if", "(", "!", "Func", ".", "hasFnAttribute", "(", "<STR_LIT>", "amdgpu-no-completion-action", "<STR_LIT>", ")", ")", "{", "<FIXE>" ]

[ "}", "if", "(", "HiddenArgNumBytes", ">=", "<NUM_LIT>", ")", "{", "<BUGS>", "if", "(", "!", "Func", ".", "hasFnAttribute", "(", "<STR_LIT>", "amdgpu-no-completion-action", "<STR_LIT>", ")", "&&", "Func", ".", "hasFnAttribute", "(", "<STR_LIT>", "calls-enqueue-kernel", "<STR_LIT>", ")", ")", "{", "<BUGE>", "emitKernelArg", "(", "DL", ",", "Int8PtrTy", ",", "Align", "(", "<NUM_LIT>", ")", ",", "ValueKind", "::", "HiddenCompletionAction", ")", ";", "}", "else", "{", "emitKernelArg", "(", "DL", ",", "Int8PtrTy", ",", "Align", "(", "<NUM_LIT>", ")", ",", "ValueKind", "::", "HiddenNone", ")", ";" ]

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

[ "(", "define_subst", "<STR_LIT>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", ")", "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CRIS_CC0_REGNUM", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC_NZ", "CRIS_CC0_REGNUM", ")", "(", "compare", ":", "CC_NZ", "(", "match_dup", "<NUM_LIT>", ")", "(" ]

[ "}" ]

[ "def", "LogicalVecHalfWordShifterOperand", ":", "AsmOperandClass", "{", "let", "SuperClasses", "=", "[", "LogicalVecShifterOperand", "]", ";", "let", "Name", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "RTVEC_ELT", "(", "vec", ",", "<NUM_LIT>", ")", "=", "x", ";", "RTVEC_ELT", "(", "vec", ",", "<NUM_LIT>", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "CRIS_CC0_REGNUM", ")", ")", ";", "return", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ")", ";" ]

[ "}" ]

[ "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", ")", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "mov\\t%1, %3", "<STR_LIT>", ",", "operands", ")", ";" ]

[ ")", ";" ]

[ "if", "(", "ShouldSignReturnAddrWithAKey", ")", "{", "PACI", "=", "Subtarget", ".", "hasPAuth", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBPAC", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "PACI", "=", "Subtarget", ".", "hasPAuth", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "auto", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBPAC", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "PACI", ")", ")", ";", "if", "(", "Subtarget", ".", "hasPAuth", "(", ")", ")", "MI", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "InternalRead", ")", ";", "MI", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_cvtusepi32_epi16", "(", "_", "_", "m128i", "_", "_", "O", ",", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovusdw128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "O", ",", "_", "_", "M", ")", ";" ]

[ "(", ")", ")", ";" ]

[ "void", "addT2SOImmNotOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm" ]

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

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

[ "}" ]

[ "for", "(", "First", "=", "<NUM_LIT>", ";", "First", "!=", "Num", ";", "++", "First", ")", "if", "(", "!", "isUndef", "(", "Elem", "[", "First", "]", ")", ")", "break", ";", "if", "(", "First", "==", "Num", ")", "return", "DAG", ".", "getUNDEF", "(", "VecTy", ")", ";", "if", "(", "AllConst", "&&", "llvm", "::", "all_of", "(", "Consts", ",", "[", "]", "(", "ConstantInt", "*", "CI", ")", "{", "return", "CI", "->", "isZero", "(", ")", ";", "}", ")", ")", "return", "getZero", "(", "dl", ",", "VecTy", ",", "DAG", ")", ";", "if", "(", "ElemTy", "==", "MVT", "::", "i16", ")", "{", "assert", "(", "Elem", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "if", "(", "AllConst", ")", "{", "uint32_t", "V", "=", "(", "Consts", "[", "<NUM_LIT>", "]", "->", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "|", "Consts", "[", "<NUM_LIT>", "]", "->", "getZExtValue", "(", ")", "<<", "<NUM_LIT>", ";", "return", "DAG", ".", "getBitcast", "(", "MVT", "::", "v2i16", ",", "DAG", ".", "getConstant", "(", "V", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "SDValue", "N", "=", "getNode", "(", "Hexagon", "::", "A2_combine_ll", ",", "dl", ",", "MVT", "::", "i32", ",", "{", "Elem", "[", "<NUM_LIT>", "]", ",", "Elem", "[", "<NUM_LIT>", "]", "}", ",", "DAG", ")", ";", "return", "DAG", ".", "getBitcast", "(", "MVT", "::", "v2i16", ",", "N", ")", ";", "}", "if", "(", "ElemTy", "==", "MVT", "::", "i8", ")", "{", "if", "(", "AllConst", ")", "{", "int32_t", "V", "=", "(", "Consts", "[", "<NUM_LIT>", "]", "->", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "|", "(", "Consts", "[", "<NUM_LIT>", "]", "->", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "|", "(", "Consts", "[", "<NUM_LIT>", "]", "->", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", "|", "Consts", "[", "<NUM_LIT>", "]", "->", "getZExtValue", "(", ")", "<<", "<NUM_LIT>", ";", "return", "DAG", ".", "getBitcast", "(", "MVT", "::", "v4i8", ",", "DAG", ".", "getConstant", "(", "V", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "bool", "IsSplat", "=", "true", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Num", ";", "++", "i", ")", "{", "if", "(", "i", "==", "First", ")", "continue", ";", "if", "(", "Elem", "[", "i", "]", "==", "Elem", "[", "First", "]", "||", "isUndef", "(", "Elem", "[", "i", "]", ")", ")", "continue", ";", "IsSplat", "=", "false", ";", "break", ";", "}", "if", "(", "IsSplat", ")", "{", "SDValue", "Ext", "=", "DAG", ".", "getZExtOrTrunc", "(", "Elem", "[", "First", "]", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VecTy", ",", "Ext", ")", ";", "}", "assert", "(", "Elem", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "SDValue", "Vs", "[", "<NUM_LIT>", "]", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "++", "i", ")", "{", "Vs", "[", "i", "]", "=", "DAG", ".", "getZExtOrTrunc", "(", "Elem", "[", "i", "]", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "Vs", "[", "i", "]", "=", "DAG", ".", "getZeroExtendInReg", "(", "Vs", "[", "i", "]", ",", "dl", ",", "MVT", "::", "i8", ")", ";" ]

[ "(", "int", "*", ")", "t", ")", ";" ]

[ "return", "(", "*", "(", "int", "*", ")", "key", ")", "-", "*", "(" ]

[ "}" ]

[ "Inst", ".", "setOpcode", "(", "ARM", "::", "BLXi", ")", ";", "imm", "|=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "if", "(", "!", "tryAddingSymbolicOperand", "(", "Address", ",", "Address", "+", "SignExtend32", "<", "<NUM_LIT>", ">", "(", "imm", ")", "+", "<NUM_LIT>", ",", "true", ",", "<NUM_LIT>", ",", "Inst", ",", "Decoder", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "SignExtend32", "<", "<NUM_LIT>", ">", "(", "imm", ")", ")", ")", ";", "return", "S", ";" ]

[ "bool", "WebAssemblyLowerBrUnless", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Lowering br_unless **********\\n", "<STR_LIT>", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "auto", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MII", "=", "MBB", ".", "begin", "(", ")", ";", "MII", "!=", "MBB", ".", "end", "(", ")", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "BR_UNLESS", ")", "continue", ";", "Register", "Cond", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "Inverted", "=", "false", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "Cond", ")", ")", "{", "assert", "(", "MRI", ".", "hasOneDef", "(", "Cond", ")", ")", ";", "MachineInstr", "*", "Def", "=", "MRI", ".", "getVRegDef", "(", "Cond", ")", ";", "switch", "(", "Def", "->", "getOpcode", "(", ")", ")", "{", "using", "namespace", "WebAssembly", ";", "case", "EQ_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_S_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_S_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_U_I32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_U_I32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_S_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_S_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GT_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LE_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "GE_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "LT_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LT_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GE_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "LE_U_I64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "GT_U_I64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_F32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_F32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_F32", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_F32", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQ_F64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "NE_F64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "NE_F64", ":", "Def", "->", "setDesc", "(", "TII", ".", "get", "(", "EQ_F64", ")", ")", ";", "Inverted", "=", "true", ";", "break", ";", "case", "EQZ_I32", ":", "{", "Cond", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Def", "->", "eraseFromParent", "(", ")", ";", "Inverted", "=", "true", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "if", "(", "!", "Inverted", ")", "{", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "EQZ_I32", ")", ",", "Tmp", ")", ".", "addReg", "(", "Cond", ")", ";", "MFI", ".", "stackifyVReg", "(", "MRI", ",", "Tmp", ")", ";", "Cond", "=", "Tmp", ";", "Inverted", "=", "true", ";", "}", "assert", "(", "Inverted", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addReg", "(", "Cond", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "}", "else", "if", "(", "UseI", ".", "isCopy", "(", ")", "&&", "UseI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "{" ]

[ "void", "AArch64StackTaggingPreRA", "::", "uncheckUsesOf", "(", "unsigned", "TaggedReg", ",", "int", "FI", ")", "{", "for", "(", "MachineInstr", "&", "UseI", ":", "llvm", "::", "make_early_inc_range", "(", "MRI", "->", "use_instructions", "(", "TaggedReg", ")", ")", ")", "{", "if", "(", "isUncheckedLoadOrStoreOpcode", "(", "UseI", ".", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "OpIdx", "=", "TII", "->", "getLoadStoreImmIdx", "(", "UseI", ".", "getOpcode", "(", ")", ")", "-", "<NUM_LIT>", ";", "if", "(", "UseI", ".", "getOperand", "(", "OpIdx", ")", ".", "isReg", "(", ")", "&&", "UseI", ".", "getOperand", "(", "OpIdx", ")", ".", "getReg", "(", ")", "==", "TaggedReg", ")", "{", "UseI", ".", "getOperand", "(", "OpIdx", ")", ".", "ChangeToFrameIndex", "(", "FI", ")", ";", "UseI", ".", "getOperand", "(", "OpIdx", ")", ".", "setTargetFlags", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}" ]

[ "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_inserti32x4", "(", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_inserti32x4_256_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "_", "B", ",", "_", "_", "imm", ",", "(", "_", "_", "v8si", ")", "_", "mm256_setzero_si256", "(", ")", ",", "(" ]

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

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

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

[ "def", "rsi", ":", "AI1", "<", "opcod", ",", "(", "outs", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "so_reg_imm", ":", "$", "shift", ")", ",", "DPSoRegImmFrm", ",", "iis", ",", "opc", ",", "<STR_LIT>", ",", "[", "(", "opnode", "GPR", ":", "$", "Rn", ",", "so_reg_imm", ":", "$", "shift", ")", "]", ">", ",", "Sched", "<", "[", "WriteCMPsi", ",", "ReadALU", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";" ]

[ "(", "Attribute", "::", "SanitizeMemTag", ")", ";" ]

[ "static", "bool", "funcRequiresHostcallPtr", "(", "const", "Function", "&", "F", ")", "{", "return", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "SanitizeAddress", ")", "||", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "SanitizeThread", ")", "||", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "SanitizeMemory", ")", "||", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "SanitizeHWAddress", ")", "||", "F", ".", "hasFnAttribute" ]

[ "WORD_0", ")", ".", "Case", "(", "<STR_LIT>", "WORD_1", "<STR_LIT>", ",", "SdwaSel", "::", "WORD_1", ")", ".", "Case", "(", "<STR_LIT>", "DWORD", "<STR_LIT>", ",", "SdwaSel", "::", "DWORD", ")", ".", "Default", "(", "<NUM_LIT>", ")", ";" ]

[ "SMLoc", "S", "=", "getLoc", "(", ")", ";", "StringRef", "Value", ";", "OperandMatchResultTy", "res", ";", "SMLoc", "StringLoc", ";", "res", "=", "parseStringWithPrefix", "(", "Prefix", ",", "Value", ",", "StringLoc", ")", ";", "if", "(", "res", "!=", "MatchOperand_Success", ")", "{", "return", "res", ";", "}", "int64_t", "Int", ";", "Int", "=", "StringSwitch", "<", "int64_t", ">", "(", "Value", ")", ".", "Case", "(", "<STR_LIT>", "BYTE_0", "<STR_LIT>", ",", "SdwaSel", "::", "BYTE_0", ")", ".", "Case", "(", "<STR_LIT>", "BYTE_1", "<STR_LIT>", ",", "SdwaSel", "::", "BYTE_1", ")", ".", "Case", "(", "<STR_LIT>", "BYTE_2", "<STR_LIT>", ",", "SdwaSel", "::", "BYTE_2", ")", ".", "Case", "(", "<STR_LIT>", "BYTE_3", "<STR_LIT>", ",", "SdwaSel", "::", "BYTE_3", ")", ".", "Case", "(", "<STR_LIT>", "WORD_0", "<STR_LIT>", ",", "SdwaSel", "::" ]

[ "<FIXS>", "addRegisterClass", "(", "MVT", "::", "f32", ",", "PPC32", "::", "FPRCRegisterClass", ")", ";", "<FIXE>" ]

[ "addRegisterClass", "(", "MVT", "::", "i32", ",", "PPC32", "::", "GPRCRegisterClass", ")", ";", "<BUGS>", "addRegisterClass", "(", "MVT", "::", "f32", ",", "PPC32", "::", "GPRCRegisterClass", ")", ";", "<BUGE>", "addRegisterClass", "(", "MVT", "::", "f64", ",", "PPC32", "::", "FPRCRegisterClass", ")", ";", "computeRegisterProperties", "(", ")", ";" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";" ]

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

[ "(", "abs", ":", "VH", "(", "match_operand", ":", "VH", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "abs", ":", "VH", "(", "match_operand", ":", "VH", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "flag_unsafe_math_optimizations", ")", "emit_insn", "(", "gen_neon_vca", "<", "cmp_op", ">", "<", "mode", ">", "_fp16insn" ]

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

[ "(", "match_operator", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "Dispatch", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "BR_TABLE_I32", ")", ")", ";", "<FIXE>" ]

[ "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "<BUGS>", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "Dispatch", ",", "Dispatch", "->", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "BR_TABLE_I32", ")", ")", ";", "<BUGE>" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>" ]

[ "false", ";" ]

[ "if", "(", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "(", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "!=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", "&&", "(", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", "!=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "<NUM_LIT>", "]", ")", "->", "getReg", "(", ")", ")", ")", "{", "Error", "(", "Operands", "[", "<NUM_LIT>", "]", "->", "getStartLoc", "(", ")", ",", "<STR_LIT>", "destination register must match source register", "<STR_LIT>", ")", ";", "return" ]

[ "<FIXS>", "if", "(", "MFI", ".", "isFrameBaseVirtual", "(", ")", "&&", "Reg", "==", "MFI", ".", "getFrameBaseVreg", "(", ")", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", "Allocating local ", "<STR_LIT>", "<<", "CurLocal", "<<", "<STR_LIT>", "for VReg ", "<STR_LIT>", "<<", "Register", "::", "virtReg2Index", "(", "Reg", ")", "<<", "'", "\\n", "'", ";", "}", ")", ";", "<FIXE>" ]

[ "auto", "P", "=", "Reg2Local", ".", "insert", "(", "std", "::", "make_pair", "(", "Reg", ",", "CurLocal", ")", ")", ";", "if", "(", "P", ".", "second", ")", "{", "<BUGS>", "if", "(", "MFI", ".", "isFrameBaseVirtual", "(", ")", "&&", "Reg", "==", "MFI", ".", "getFrameBaseVreg", "(", ")", ")", "<BUGE>", "MFI", ".", "setFrameBaseLocal", "(", "CurLocal", ")", ";", "}", "return", "P", ".", "first", "->", "second", ";" ]

[ "isVirtualRegister", "(", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";" ]

[ "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", "||", "!", "TargetRegisterInfo", "::" ]

[ "<STR_LIT>", ")" ]

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

[ "!=", "ExtractedFromVec", ")", "{" ]

[ "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "!", "TLI", ".", "isOperationLegalOrCustom", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "NumElems", "=", "Op", ".", "getNumOperands", "(", ")", ";", "SDValue", "VecIn1", ";", "SDValue", "VecIn2", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "InsertIndices", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", "(", "NumElems", ",", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "{", "unsigned", "Opc", "=", "Op", ".", "getOperand", "(", "i", ")", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ISD", "::", "UNDEF", ")", "continue", ";", "if", "(", "Opc", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "{", "if", "(", "InsertIndices", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "InsertIndices", ".", "push_back", "(", "i", ")", ";", "continue", ";", "}", "SDValue", "ExtractedFromVec", "=", "Op", ".", "getOperand", "(", "i", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "ExtIdx", "=", "Op", ".", "getOperand", "(", "i", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "ExtIdx", ")", ")", "return", "SDValue", "(", ")", ";", "int", "Idx", "=", "getUnderlyingExtractedFromVec", "(", "ExtractedFromVec", ",", "ExtIdx", ")", ";", "if", "(", "ExtractedFromVec", ".", "getValueType", "(", ")", "!=", "VT", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "VecIn1", ".", "getNode", "(", ")", ")", "VecIn1", "=", "ExtractedFromVec", ";", "else", "if", "(", "VecIn1" ]

[ ")", ";" ]

[ "return", "new", "ELFVEAsmBackend", "(", "T", ",", "STI", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")" ]

[ "}" ]

[ "int", "i", ",", "regno", ";", "rtx", "op", ";", "op", "=", "frv_read_argument", "(", "call", ",", "index", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op", ")", "<", "<NUM_LIT>", "||", "INTVAL", "(", "op", ")", ">", "IACC_LAST", "-", "IACC_FIRST", "||", "(", "(", "INTVAL", "(", "op", ")", "*", "<NUM_LIT>", ")", "&", "(", "GET_MODE_SIZE", "(", "mode", ")", "-", "<NUM_LIT>", ")", ")", "!=", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "invalid IACC argument", "<STR_LIT>", ")", ";", "op", "=", "const0_rtx", ";", "}", "regno", "=", "INTVAL", "(", "op", ")", "+", "IACC_FIRST", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "hard_regno_nregs", "(", "regno", ",", "mode", ")", ";", "i", "++", ")", "global_regs", "[", "regno", "+", "i", "]", "=", "<NUM_LIT>", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";" ]

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

[ "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntr", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "," ]

[ "let", "Itinerary", "=", "IIC_ScalarOp", ";" ]

[ "class", "SpuInst_MovDim", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc", ",", "string", "asmstr", ">", ":", "ScalarInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "i8imm", ":", "$", "dim", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_and_ps", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_andps128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "v4sf", ")", "_", "mm_avx512_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ ",", "asm", ",", "<STR_LIT>", ",", "OpNode", ",", "v4i32", ">", ";" ]

[ "def", "v4i32", ":", "BaseSIMDZipVector", "<", "<NUM_LIT>", ",", "opc", ",", "V128" ]

[ "_", "_", "v8si", ")", "_", "mm256_undefined_si256", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_broadcasti32x2_256_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(" ]

[ "<FIXS>", "static", "bool", "resultTests", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Reg", ")", "{", "<FIXE>", "<FIXS>", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Reg", ")", "<FIXE>" ]

[ "return", "false", ";", "}", "<BUGS>", "static", "bool", "resultTests", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Reg", ",", "unsigned", "SubReg", ")", "{", "<BUGE>", "if", "(", "MI", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isDef", "(", ")", "&&", "<BUGS>", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Reg", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", "==", "SubReg", ")", "<BUGE>", "return", "true", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", "SRF", ":", "$", "dst", ")", ";", "let", "InOperandList", "=", "(", "ins", "SRF", ":", "$", "src", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "let", "isNotUsedInDisasm", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Dest", "=", "dst", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ",", "TargetCC", ",", "Flag", ")", ";" ]

[ "SDValue", "RHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "LPCC", "::", "CondCode", "CC", "=", "IntCondCCodeToICC", "(", "Cond", ",", "DL", ",", "LHS", ",", "RHS", ",", "DAG", ")", ";", "SDValue", "TargetCC", "=", "DAG", ".", "getConstant", "(", "CC", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Flag", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Glue", ",", "LHS", ",", "RHS", ",", "TargetCC", ")", ";" ]

[ "<FIXS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<FIXE>" ]

[ "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGE>", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "reg", ":", "SI", "<NUM_LIT>", ")" ]

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

[ "class", "SPLATI_D_ENC", ":", "MSA_ELM_D_FMT", "<", "<NUM_LIT>", "," ]

[ ")", ")" ]

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

[ "fma_node", "*", "*", "fma_slot", ";" ]

[ "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "dest_op_info", "->", "n_chains", ";", "i", "++", ")", "{", "if", "(", "dest_op_info", "->", "heads", "[", "i", "]", "->", "regno", "!=", "dest_regno", ")", "continue", ";", "head", "=", "dest_op_info", "->", "heads", "[", "i", "]", ";", "if", "(", "!", "head", "->", "first", ")", "head", "=", "regrename_chain_from_id", "(", "head", "->", "id", ")", ";", "forest", "=", "NULL", ";", "for", "(", "chain", "=", "head", "->", "first", ";", "chain", ";", "chain", "=", "chain", "->", "next_use", ")", "{" ]

[ "FGR32Opnd", ",", "GPR32Opnd", ">", ";" ]

[ "class", "INSERT_FW_VIDX_PSEUDO_DESC", ":", "MSA_INSERT_VIDX_PSEUDO_BASE", "<", "vector_insert", ",", "v4f32", ",", "MSA128WOpnd", "," ]

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

[ "def", "CondVariantNE", ":", "CondVariant", "<", "<NUM_LIT>" ]

[ "<STR_LIT>", ")" ]

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

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

[ "(", "not", ":", "I", "(", "match_operand", ":", "I", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "RegBank", "->", "getID", "(", ")", "==", "ARM", "::", "FPRRegBankID", ")", "{", "if", "(", "Size", "==", "<NUM_LIT>", ")", "return", "&", "ARM", "::", "SPRRegClass", ";", "else", "if", "(", "Size", "==", "<NUM_LIT>", ")", "return", "&", "ARM", "::", "DPRRegClass", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported destination size", "<STR_LIT>", ")", ";" ]

[ "void", "X86TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "false", "&&", "<STR_LIT>", "Do not know how to custom type legalize this operation!", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "Vals", "=", "FP_TO_INTHelper", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "DAG", ",", "true", ")", ";", "SDValue", "FIST", "=", "Vals", ".", "first", ",", "StackSlot", "=", "Vals", ".", "second", ";", "if", "(", "FIST", ".", "getNode", "(", ")", "!=", "<NUM_LIT>", ")", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "FIST", ",", "StackSlot", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "return", ";", "}", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ")", ";", "SDValue", "TheChain", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "rd", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "&", "TheChain", ",", "<NUM_LIT>", ")", ";", "SDValue", "eax", "=", "DAG", ".", "getCopyFromReg", "(", "rd", ",", "dl", ",", "X86", "::", "EAX", ",", "MVT", "::", "i32", ",", "rd", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "edx", "=", "DAG", ".", "getCopyFromReg", "(", "eax", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EDX", ",", "MVT", "::", "i32", ",", "eax", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "eax", ",", "edx", "}", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "Ops", ",", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "edx", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "{", "EVT", "T", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "assert", "(", "T", "==", "MVT", "::", "i64", "&&", "<STR_LIT>", "Only know how to expand i64 Cmp and Swap", "<STR_LIT>", ")", ";", "SDValue", "cpInL", ",", "cpInH", ";", "cpInL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "cpInH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "cpInL", "=", "DAG", ".", "getCopyToReg", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EAX", ",", "cpInL", ",", "SDValue", "(", ")", ")", ";", "cpInH", "=", "DAG", ".", "getCopyToReg", "(", "cpInL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EDX", ",", "cpInH", ",", "cpInL", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "swapInL", ",", "swapInH", ";", "swapInL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "swapInH", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "swapInL", "=", "DAG", ".", "getCopyToReg", "(", "cpInH", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EBX", ",", "swapInL", ",", "cpInH", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "swapInH", "=", "DAG", ".", "getCopyToReg", "(", "swapInL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "ECX", ",", "swapInH", ",", "swapInL", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "swapInH", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "swapInH", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ")", ";", "MachineMemOperand", "*", "MMO", "=", "cast", "<", "AtomicSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "<NUM_LIT>", ",", "T", ",", "MMO", ")", ";", "SDValue", "cpOutL", "=", "DAG", ".", "getCopyFromReg", "(", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EAX", ",", "MVT", "::", "i32", ",", "Result", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "cpOutH", "=", "DAG", ".", "getCopyFromReg", "(", "cpOutL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "X86", "::", "EDX", ",", "MVT", "::", "i32", ",", "cpOutL", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "OpsF", "[", "]", "=", "{", "cpOutL", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "cpOutH", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "OpsF", ",", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "cpOutH", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "ReplaceATOMIC_BINARY_64", "(", "N", ",", "Results", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", ";", "}", "}" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "<FIXS>", "MaskVec", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "MaskEVT", ")", ")", ";", "<FIXE>", "<FIXS>", "MaskVec", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "MaskEVT", ")", ")", ";", "<FIXE>" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<NUM_LIT>", ";", "++", "i", ")", "{", "SDValue", "Elt", "=", "V1Elts", "[", "i", "]", ";", "if", "(", "Elt", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "{", "<BUGS>", "MaskVec", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "UNDEF", ",", "dl", ",", "MaskEVT", ")", ")", ";", "<BUGE>", "continue", ";", "}", "unsigned", "EltIdx", "=", "cast", "ConstantSDNode", ">", "(", "Elt", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "EltIdx", ">=", "<NUM_LIT>", ")", "<BUGS>", "MaskVec", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "UNDEF", ",", "dl", ",", "MaskEVT", ")", ")", ";", "<BUGE>", "elseMaskVec", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "EltIdx", ",", "MaskEVT", ")", ")", ";", "}" ]

[ "bool", "SIOptimizeExecMasking", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Exec", "=", "TRI", "->", "getExec", "(", ")", ";", "bool", "Changed", "=", "optimizeExecSequence", "(", ")", ";", "OrXors", ".", "clear", "(", ")", ";", "SaveExecVCmpMapping", ".", "clear", "(", ")", ";", "KillFlagCandidates", ".", "clear", "(", ")", ";", "static", "unsigned", "SearchWindow", "=", "<NUM_LIT>", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "unsigned", "SearchCount", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "MI", ":", "llvm", "::", "reverse", "(", "MBB", ")", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "SearchCount", ">=", "SearchWindow", ")", "{", "break", ";", "}", "tryRecordOrSaveexecXorSequence", "(", "MI", ")", ";", "tryRecordVCmpxAndSaveexecSequence", "(", "MI", ")", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "Exec", ",", "TRI", ")", ")", "{", "break", ";", "}", "++", "SearchCount", ";", "}", "}", "Changed", "|=", "optimizeOrSaveexecXorSequences", "(", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "SaveExecVCmpMapping", ")", "{", "MachineInstr", "*", "SaveExecInstr", "=", "Entry", ".", "getFirst", "(", ")", ";", "MachineInstr", "*", "VCmpInstr", "=", "Entry", ".", "getSecond", "(", ")", ";", "Changed", "|=", "optimizeVCMPSaveExecSequence", "(", "*", "SaveExecInstr", ",", "*", "VCmpInstr", ",", "Exec", ")", ";", "}", "return", "Changed", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

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

[ "def", "C4_and_orn", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", ",", "TypeCR", ">", ",", "Enc_9ac432", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "(", "cond", "[", "(", "ne", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")", "]", "(", "const_string", "<STR_LIT>", ")" ]

[ "}" ]

[ "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "V", "(", "NumElts", ",", "DAG", ".", "getConstant", "(", "uint8_t", "(", "-", "<NUM_LIT>", "U", ")", ">>", "ShiftAmt", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "SRL", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "V", ")", ")", ";", "}", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "{", "if", "(", "ShiftAmt", "==", "<NUM_LIT>", ")", "{", "SDValue", "Zeros", "=", "getZeroVector", "(", "VT", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Zeros", ",", "R", ")", ";", "}", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "VT", ",", "R", ",", "Amt", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "V", "(", "NumElts", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ">>", "ShiftAmt", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Mask", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "dl", ",", "VT", ",", "V", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "dl", ",", "VT", ",", "Res", ",", "Mask", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "VT", ",", "Res", ",", "Mask", ")", ";", "return", "Res", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Unknown shift opcode.", "<STR_LIT>", ")", ";", "}", "}", "}", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v2i64", "||", "(", "Subtarget", "->", "hasInt256", "(", ")", "&&", "VT", "==", "MVT", "::", "v4i64", ")", ")", ")", "{", "int", "SplatIndex", "=", "-", "<NUM_LIT>", ";", "if", "(", "ShuffleVectorSDNode", "*", "SVN", "=", "dyn_cast", "<", "ShuffleVectorSDNode", ">", "(", "Amt", ".", "getNode", "(", ")", ")", ")", "if", "(", "SVN", "->", "isSplat", "(", ")", ")", "{", "SplatIndex", "=", "SVN", "->", "getSplatIndex", "(", ")", ";", "Amt", "=", "Amt", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "SplatIndex", "<", "(", "int", ")", "VT", ".", "getVectorNumElements", "(", ")", "&&", "<STR_LIT>", "Splat shuffle referencing second operand", "<STR_LIT>", ")", ";", "}", "if", "(", "Amt", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BITCAST", "||", "Amt", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BUILD_VECTOR", ")", "return", "SDValue", "(", ")", ";", "Amt", "=", "Amt", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Ratio", "=", "Amt", ".", "getSimpleValueType", "(", ")", ".", "getVectorNumElements", "(", ")", "/", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "RatioInLog2", "=", "Log2_32_Ceil", "(", "Ratio", ")", ";", "uint64_t", "ShiftAmt", "=", "<NUM_LIT>", ";", "unsigned", "BaseOp", "=", "(", "SplatIndex", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "SplatIndex", "*", "Ratio", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Ratio", ";", "++", "i", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Amt", ".", "getOperand", "(", "i", "+", "BaseOp", ")", ")", ";", "if", "(", "!", "C", ")", "return", "SDValue", "(", ")", ";", "ShiftAmt", "|=", "C", "->", "getZExtValue", "(", ")", "<<", "(", "i", "*", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "RatioInLog2", ")", ")", ")", ";", "}", "if", "(", "SplatIndex", "<", "<NUM_LIT>", ")", "{", "for", "(", "unsigned", "i", "=", "Ratio", ";", "i", "!=", "Amt", ".", "getNumOperands", "(", ")", ";", "i", "+=", "Ratio", ")", "{", "uint64_t", "ShAmt", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "!=", "Ratio", ";", "++", "j", ")", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Amt", ".", "getOperand", "(", "i", "+", "j", ")", ")", ";", "if", "(", "!", "C", ")", "return", "SDValue", "(", ")", ";", "ShAmt", "|=", "C", "->", "getZExtValue", "(", ")", "<<", "(", "j", "*", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "RatioInLog2", ")", ")", ")", ";", "}", "if", "(", "ShAmt", "!=", "ShiftAmt", ")", "return", "SDValue", "(", ")", ";", "}", "}", "if", "(", "SupportedVectorShiftWithImm", "(", "VT", ",", "Subtarget", ",", "Op", ".", "getOpcode", "(", ")", ")", ")", "return", "getTargetVShiftByConstNode", "(", "X86Opc", ",", "dl", ",", "VT", ",", "R", ",", "ShiftAmt", ",", "DAG", ")", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "return", "ArithmeticShiftRight64", "(", "ShiftAmt", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

[ "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseRegOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

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

[ "if", "(", "IsFunction", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "auto", "Section", "=", "static_cast", "<", "const", "MCSectionWasm", "*", ">", "(", "GetFixupSection", "(", "Fixup", ".", "getValue", "(", ")", ")", ")", ")", "{", "if", "(", "Section", "->", "getKind", "(", ")", ".", "isText", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "!", "Section", "->", "isWasmData", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "return", "<STR_LIT>" ]

[ ")", ";" ]

[ "}", "if", "(", "ARITHMETIC_P", "(", "plus0", ")", "||", "ARITHMETIC_P", "(", "plus1", ")", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "else", "if", "(", "REG_P", "(", "plus0", ")", "&&", "REG_P", "(", "plus1", ")", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "default", ":", "break", ";", "}", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>" ]

[ ")", "_", "_", "c", ")", ";" ]

[ "vmla_u8", "(", "uint8x8_t", "_", "_", "a", ",", "uint8x8_t", "_", "_", "b", ",", "uint8x8_t", "_", "_", "c", ")", "{", "return", "(", "uint8x8_t", ")", "_", "_", "builtin_neon_vmlav8qi", "(", "(", "int8x8_t", ")", "_", "_", "a", ",", "(", "int8x8_t", ")", "_", "_", "b", ",", "(", "int8x8_t" ]

[ "}" ]

[ "bool", "hasWorkGroupInfo", "(", ")", "const", "{", "return", "WorkGroupInfo", ";" ]

[ ";" ]

[ "def", "J4_cmpgtn1_fp0_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "n1Const", ":", "$", "n1", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_a42857", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>" ]

[ "}" ]

[ "MachineBasicBlock", "*", "MBB2", "=", "*", "std", "::", "next", "(", "MBB", "->", "succ_begin", "(", ")", ")", ";", "if", "(", "MBB1", "!=", "MBB2", ")", "return", ";", "MachineInstr", "*", "BranchMI", "=", "getNormalBlockBranchInstr", "(", "MBB", ")", ";", "assert", "(", "BranchMI", "&&", "isCondBranch", "(", "BranchMI", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Removing unneeded cond branch instr: ", "<STR_LIT>", "<<", "*", "BranchMI", ")", ";", "BranchMI", "->", "eraseFromParent", "(", ")", ";", "SHOWNEWBLK", "(", "MBB1", ",", "<STR_LIT>", "Removing redundant successor", "<STR_LIT>", ")", ";", "MBB", "->", "removeSuccessor", "(", "MBB1", ",", "true", ")", ";" ]

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

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

[ "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "VSELECT", ":", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformAddCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSubCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformADCCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformAndCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "PerformLOADCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "PerformSINT_TO_FPCombine", "(", "N", ",", "DAG", ",", "this", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "PerformFADDCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "PerformFSUBCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFMinFMaxCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformFANDNCombine", "(", "N", ",", "DAG", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "PerformSExtCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "PerformSIGN_EXTEND_INREGCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "PerformTruncateCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "PerformISDSETCCCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformBrCondCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "performVZEXTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FMA", ":", "return", "PerformFMACombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformINTRINSIC_WO_CHAINCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "PerformINSERTPSCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "PerformBUILD_VECTORCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "zero_reg", ",", "const0_rtx", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<FIXE>" ]

[ "{", "rtx", "zero_reg", "=", "gen_reg_rtx", "(", "SImode", ")", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "SImode", ",", "zero_reg", ",", "const0_rtx", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<BUGE>", "gen_rtx_MINUS", "(", "SImode", ",", "zero_reg", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "DONE" ]

[ ")", ")" ]

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

[ "const", "char", "*", "AMDGPUPeepholeOpt", "::", "getPassName", "(", ")", "const", "{", "return", "<STR_LIT>", "AMDGPU PeepHole Optimization Pass", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

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

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

[ "def", "A2_pandtnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_05c070ec", ",", "TypeALU32_3op", ">", ",", "Enc_ea4c54", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "break", ";" ]

[ "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v16i8", ":", "if", "(", "ArgRegIdx", "!=", "NumArgRegs", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "ArgRegIdx", "++", "]", ",", "Arg", ")", ")", ";", "}", "else", "{", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "ArgOffset", "+=", "StackSlotSize", ";", "}", "break", ";", "}", "}", "unsigned", "NumStackBytes", "=", "ArgOffset", "-", "SPUFrameInfo", "::", "minStackSize", "(", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "NumStackBytes", ",", "true", ")", ")", ";", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "{", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "MemOpChains", "[", "<NUM_LIT>", "]", ",", "MemOpChains", ".", "size", "(", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "unsigned", "CallOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "EVT", "CalleeVT", "=", "Callee", ".", "getValueType", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrVT", ")", ";", "SDValue", "GA", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "CalleeVT", ")", ";", "if", "(", "!", "ST", "->", "usingLargeMem", "(", ")", ")", "{", "if", "(", "GV", "->", "isDeclaration", "(", ")", ")", "{", "Callee", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "CalleeVT", ",", "GA", ",", "Zero", ")", ";", "}", "else", "{", "Callee", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "CalleeVT", ",", "GA", ",", "Zero", ")", ";", "}", "}", "else", "{", "Callee", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "PtrVT", ",", "GA", ",", "Zero", ")", ";", "}", "}", "else", "if", "(", "ExternalSymbolSDNode", "*", "S", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "EVT", "CalleeVT", "=", "Callee", ".", "getValueType", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrVT", ")", ";", "SDValue", "ExtSym", "=", "DAG", ".", "getTargetExternalSymbol", "(", "S", "->", "getSymbol", "(", ")", ",", "Callee", ".", "getValueType", "(", ")", ")", ";", "if", "(", "!", "ST", "->", "usingLargeMem", "(", ")", ")", "{", "Callee", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "CalleeVT", ",", "ExtSym", ",", "Zero", ")", ";", "}", "else", "{", "Callee", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "PtrVT", ",", "ExtSym", ",", "Zero", ")", ";", "}", "}", "else", "if", "(", "SDNode", "*", "Dest", "=", "isLSAAddress", "(", "Callee", ",", "DAG", ")", ")", "{", "Callee", "=", "SDValue", "(", "Dest", ",", "<NUM_LIT>", ")", ";", "}", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "CallOpc", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ")", ",", "&", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", ".", "size", "(", ")", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "NumStackBytes", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "true", ")", ",", "InFlag", ")", ";", "if", "(", "!", "Ins", ".", "empty", "(", ")", ")", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "switch", "(", "Ins", "[", "<NUM_LIT>", "]", ".", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected ret value!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "Other", ":", "break", ";", "case", "MVT", "::", "i32", ":", "if", "(", "Ins", ".", "size", "(", ")", ">", "<NUM_LIT>", "&&", "Ins", "[", "<NUM_LIT>", "]", ".", "VT", "==", "MVT", "::", "i32", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ",", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "break", ";", "case", "MVT", "::", "i64", ":", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i64", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "StartIndex", ";" ]

[ "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "PassConfig", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AliasAnalysis", ">", "(", ")", ";", "RegClassInfo", "->", "runOnMachineFunction", "(", "*", "MF", ")", ";", "AntiDepMode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_NONE", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "mf", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "TargetSubtargetInfo", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "enablePostRAScheduler", "(", "PassConfig", "->", "getOptLevel", "(", ")", ",", "AntiDepMode", ",", "CriticalPathRCs", ")", ")", "return", "false", ";", "if", "(", "EnableAntiDepBreaking", ".", "getPosition", "(", ")", ">", "<NUM_LIT>", ")", "{", "AntiDepMode", "=", "(", "EnableAntiDepBreaking", "==", "<STR_LIT>", "all", "<STR_LIT>", ")", "?", "TargetSubtargetInfo", "::", "ANTIDEP_ALL", ":", "(", "(", "EnableAntiDepBreaking", "==", "<STR_LIT>", "critical", "<STR_LIT>", ")", "?", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ":", "TargetSubtargetInfo", "::", "ANTIDEP_NONE", ")", ";", "}", "const", "PatmosTargetMachine", "*", "PTM", "=", "static_cast", "<", "const", "PatmosTargetMachine", "*", ">", "(", "&", "mf", ".", "getTarget", "(", ")", ")", ";", "PostRASchedStrategy", "*", "S", "=", "new", "PatmosPostRASchedStrategy", "(", "*", "PTM", ")", ";", "OwningPtr", "<", "ScheduleDAGPostRA", ">", "Scheduler", "(", "new", "ScheduleDAGPostRA", "(", "this", ",", "S", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", "->", "begin", "(", ")", ",", "MBBEnd", "=", "MF", "->", "end", "(", ")", ";", "MBB", "!=", "MBBEnd", ";", "++", "MBB", ")", "{", "Scheduler", "->", "startBlock", "(", "MBB", ")", ";", "unsigned", "EndIndex", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", "RegionEnd", "=", "Scheduler", "->", "begin", "(", ")", ")", "{", "if", "(", "!", "Scheduler", "->", "canHandleTerminators", "(", ")", ")", "{", "if", "(", "RegionEnd", "!=", "MBB", "->", "end", "(", ")", "||", "Scheduler", "->", "isSchedulingBoundary", "(", "RegionEnd", ",", "MBB", ",", "*", "MF", ")", ")", "{", "RegionEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "--", "EndIndex", ";", "Scheduler", "->", "observe", "(", "RegionEnd", ",", "EndIndex", ")", ";", "}", "}", "MachineBasicBlock", "::", "iterator", "I", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "unsigned", "StartIndex", "=", "EndIndex", "-", "<NUM_LIT>", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "StartIndex", ")", "{", "if", "(", "Scheduler", "->", "isSchedulingBoundary", "(", "llvm", "::", "prior", "(", "I", ")", ",", "MBB", ",", "*", "MF", ")", ")", "break", ";", "assert", "(", "!", "I", "->", "isBundled", "(", ")", "&&", "<STR_LIT>", "Rescheduling bundled code is not supported.", "<STR_LIT>", ")", ";", "}", "assert", "(", "!", "I", "->", "isBundled", "(", ")", "&&", "<STR_LIT>", "Rescheduling bundled code is not supported.", "<STR_LIT>", ")", ";", "Scheduler", "->", "enterRegion", "(", "MBB", ",", "I", ",", "RegionEnd", ",", "EndIndex", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "Scheduler", "->", "exitRegion", "(", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** PostRA MI Scheduling **********\\n", "<STR_LIT>", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "MF", "->", "getName", "(", ")", "<<", "<STR_LIT>", ":BB#", "<STR_LIT>", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "MBB", "->", "getName", "(", ")", "<<", "<STR_LIT>", "\\n From: ", "<STR_LIT>", "<<", "*", "I", "<<", "<STR_LIT>", " To: ", "<STR_LIT>", ";", "if", "(", "RegionEnd", "!=", "MBB", "->", "end", "(", ")", ")", "dbgs", "(", ")", "<<", "*", "RegionEnd", ";", "else", "dbgs", "(", ")", "<<", "<STR_LIT>", "End", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", " [", "<STR_LIT>", "<<", "StartIndex", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "EndIndex", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "Scheduler", "->", "schedule", "(", ")", ";", "Scheduler", "->", "exitRegion", "(", ")", ";", "RegionEnd", "=", "Scheduler", "->", "begin", "(", ")", ";", "EndIndex", "=" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

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

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

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>" ]

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

[ "def", "_8H", ":", "N2VShiftIns", "<", "<NUM_LIT>", ",", "u", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "VPR128", ",", "v8i16", ",", "shr_imm16", ",", "int_aarch64_neon_vsri", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-" ]

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

[ "(", "define_int_attr", "sha1_op", "[", "(", "UNSPEC_SHA1C", "<STR_LIT>", ")", "(", "UNSPEC_SHA1P", "<STR_LIT>", ")", "(", "UNSPEC_SHA1M", "<STR_LIT>" ]

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

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "*", "TII", ")", ";" ]

[ "MachineBasicBlock", "::", "iterator", "SILoadStoreOptimizer", "::", "mergeTBufferStorePair", "(", "CombineInfo", "&", "CI", ",", "CombineInfo", "&", "Paired", ",", "const", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "InstsToMove", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "CI", ".", "I", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "CI", ".", "I", "->", "getDebugLoc", "(", ")", ";", "const", "unsigned", "Opcode", "=", "getNewOpcode", "(", "CI", ",", "Paired", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "SubRegIdx", "=", "getSubRegIdxs", "(", "CI", ",", "Paired", ")", ";", "const", "unsigned", "SubRegIdx0", "=", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "SubRegIdx", ")", ";", "const", "unsigned", "SubRegIdx1", "=", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "SubRegIdx", ")", ";", "const", "TargetRegisterClass", "*", "SuperRC", "=", "getTargetRegisterClass", "(", "CI", ",", "Paired", ")", ";", "Register", "SrcReg", "=", "MRI", "->", "createVirtualRegister", "(", "SuperRC", ")", ";", "const", "auto", "*", "Src0", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "const", "auto", "*", "Src1", "=", "TII", "->", "getNamedOperand", "(", "*", "Paired", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Paired", ".", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "SrcReg", ")", ".", "add", "(", "*", "Src0", ")", ".", "addImm", "(", "SubRegIdx0", ")", ".", "add", "(", "*", "Src1", ")", ".", "addImm", "(", "SubRegIdx1", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "Paired", ".", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Kill", ")", ";", "AddressRegs", "Regs", "=", "getRegs", "(", "Opcode", "," ]

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

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_lsx_vsrln_h_w", "(", "(", "v4i32", ")", "_", "<NUM_LIT>", ",", "(" ]

[ ",", "_", "_", "bu", ".", "_", "_", "o", ")", ";" ]

[ "_", "_", "builtin_neon_vst1q_x3v8hi", "(", "(", "_", "_", "builtin_neon_hi", "*", ")", "_", "_", "a" ]

[ "<FIXS>", "def", "TEQ", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ",", "uimm10", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TGE", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ",", "uimm10", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TGEU", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ",", "uimm10", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TLT", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ",", "uimm10", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TLTU", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ",", "uimm10", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TNE", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ",", "uimm10", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "<FIXE>" ]

[ "def", "SYNCI", ":", "MMRel", ",", "StdMMR6Rel", ",", "SYNCI_FT", "<STR_LIT>", ">", ",", "SYNCI_FM", ",", "ISA_MIPS32R2", ";", "let", "AdditionalPredicates", "=", "[", "NotInMicroMips", "]", "in", "{", "<BUGS>", "def", "TEQ", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TGE", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TGEU", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TLT", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TLTU", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "def", "TNE", ":", "MMRel", ",", "TEQ_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQ_FM", "<NUM_LIT>", ">", ",", "ISA_MIPS2", ";", "<BUGE>", "}", "def", "TEQI", ":", "MMRel", ",", "TEQI_FT", "<STR_LIT>", ",", "GPR32Opnd", ">", ",", "TEQI_FM", "<NUM_LIT>", ">", "," ]