Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "bits", "<", "<NUM_LIT>", ">", "MaxVersion", "=", "maxVersion", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Value", "=", "value", ";", "string", "Mnemonic", "=", "mnemonic", ";", "bits", "<", "<NUM_LIT>", ">", "MinVersion", "=", "minVersion", ";" ]

[ ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "DI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "DF", "<NUM_LIT>" ]

[ "return", "(", "_", "_", "m64", ")", "_", "_", "res", ".", "as_m64", ";" ]

[ "_", "_", "vector", "_", "_", "bool", "short", "_", "_", "c", ";", "_", "_", "a", "=", "(", "_", "_", "vector", "signed", "short", ")", "vec_splats", "(", "_", "_", "A", ")", ";", "_", "_", "b", "=", "(", "_", "_", "vector", "signed", "short", ")", "vec_splats", "(", "_", "_", "B", ")", ";", "_", "_", "c", "=", "(", "_", "_", "vector", "_", "_", "bool", "short", ")", "vec_cmplt", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";", "_", "_", "r", "=", "vec_sel", "(", "_", "_", "b", ",", "_", "_", "a", ",", "_", "_", "c", ")", ";", "return", "(", "_", "_", "m64", ")", "(", "(", "_", "_", "vector", "long", "long", ")", "_", "_", "r", ")", "[", "<NUM_LIT>", "]", ";", "_", "_", "m64_union", "_", "_", "m1", ",", "_", "_", "m2", ",", "_", "_", "res", ";", "_", "_", "m1", ".", "as_m64", "=", "_", "_", "A", ";", "_", "_", "m2", ".", "as_m64", "=", "_", "_", "B", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "(", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", "<", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ")", "?", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", ":", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "(", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", "<", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ")", "?", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", ":", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "(", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", "<", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ")", "?", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", ":", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ";", "_", "_", "res", ".", "as_short", "[", "<NUM_LIT>", "]", "=", "(", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", "<", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ")", "?", "_", "_", "m1", ".", "as_short", "[", "<NUM_LIT>", "]", ":", "_", "_", "m2", ".", "as_short", "[", "<NUM_LIT>", "]", ";" ]

[ "}" ]

[ "def", "KryoWrite_3cyc_XY_XY_166ln", ":", "SchedWriteRes", "<", "[", "KryoUnitXY", ",", "KryoUnitXY", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "data", "->", "ready_try_change", "=", "NULL", ";" ]

[ "ix86_first_cycle_multipass_data_t", "data", "=", "(", "ix86_first_cycle_multipass_data_t", ")", "_", "data", ";", "data", "->", "ifetch_block_len", "=", "<NUM_LIT>", ";", "data", "->", "ifetch_block_n_insns", "=", "<NUM_LIT>", ";" ]

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

[ "def", "A2_abs", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_cf8126ae", ",", "TypeS_2op", ">", ",", "Enc_5e2823", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "w", "<STR_LIT>", "(", "c", ")", ":", ")", ";" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "smlsl2 %0.2d,%2.4s,%3.4s", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "(", "a", ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(", "b", ")", ",", "<STR_LIT>" ]

[ "}" ]

[ "MOVI", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MOVI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "DestReg", ")", ")", ";", "MOVI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "MOVI", ")", ";", "}", "else", "{", "MCInst", "FMov", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected opcode", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "FMov", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "FMov", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "DestReg", ")", ")", ";", "FMov", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "FMov", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "FMov", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "DestReg", ")", ")", ";", "FMov", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "FMov", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "FMov", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "DestReg", ")", ")", ";", "FMov", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "break", ";", "}", "EmitToStreamer", "(", "*", "OutStreamer", ",", "FMov", ")", ";", "}" ]

[ ",", "MCContext", "&", "Ctx", ")", "{" ]

[ "static", "MCDisassembler", "*", "createTPCDisassembler", "(", "const", "Target", "&", "T", ",", "const", "MCSubtargetInfo", "&", "STI" ]

[ "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "PHINodeSet", "PromotablePHINodes", "=", "getPromotablePHINodes", "(", "F", ")", ";", "B2IMap", "Bool2IntMap", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "auto", "*", "R", "=", "dyn_cast", "<", "ReturnInst", ">", "(", "&", "I", ")", ")", "if", "(", "F", ".", "getReturnType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "Changed", "|=", "runOnUse", "(", "R", "->", "getOperandUse", "(", "<NUM_LIT>", ")", ",", "PromotablePHINodes", ",", "Bool2IntMap", ")", ";", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ")", "for", "(", "auto", "&", "U", ":", "CI", "->", "operands", "(", ")", ")", "if", "(", "U", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "Changed", "|=", "runOnUse", "(", "U", ",", "PromotablePHINodes", ",", "Bool2IntMap", ")", ";", "}", "}", "return", "Changed", ";", "}" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

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

[ "FlipSigns", "=", "true", ";", "Invert", "=", "true", ";", "break", ";" ]

[ "CC0", "=", "<NUM_LIT>", ";", "CC1", "=", "<NUM_LIT>", ";", "CombineOpc", "=", "ISD", "::", "OR", ";", "}", "else", "{", "assert", "(", "SetCCOpcode", "==", "ISD", "::", "SETONE", ")", ";", "CC0", "=", "<NUM_LIT>", ";", "CC1", "=", "<NUM_LIT>", ";", "CombineOpc", "=", "ISD", "::", "AND", ";", "}", "SDValue", "Cmp0", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "CC0", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "SDValue", "Cmp1", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "CC1", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "CombineOpc", ",", "dl", ",", "VT", ",", "Cmp0", ",", "Cmp1", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "SSECC", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "}", "MVT", "VTOp0", "=", "Op0", ".", "getSimpleValueType", "(", ")", ";", "assert", "(", "VTOp0", "==", "Op1", ".", "getSimpleValueType", "(", ")", "&&", "<STR_LIT>", "Expected operands with same type!", "<STR_LIT>", ")", ";", "assert", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "VTOp0", ".", "getVectorNumElements", "(", ")", "&&", "<STR_LIT>", "Invalid number of packed elements for source and destination!", "<STR_LIT>", ")", ";", "if", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "VTOp0", ".", "is256BitVector", "(", ")", ")", "{", "SDValue", "NewOp", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "VTOp0", ",", "Op0", ",", "Op1", ",", "SetCCOpcode", ")", ";", "return", "DAG", ".", "getZExtOrTrunc", "(", "NewOp", ",", "dl", ",", "VT", ")", ";", "}", "assert", "(", "(", "Subtarget", ".", "hasAVX512", "(", ")", "||", "(", "VT", "==", "VTOp0", ")", ")", "&&", "<STR_LIT>", "Value types for source and destination must be the same!", "<STR_LIT>", ")", ";", "if", "(", "VT", ".", "is256BitVector", "(", ")", "&&", "!", "Subtarget", ".", "hasInt256", "(", ")", ")", "return", "Lower256IntVSETCC", "(", "Op", ",", "DAG", ")", ";", "MVT", "OpVT", "=", "Op1", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "OpVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "LowerBoolVSETCC_AVX512", "(", "Op", ",", "DAG", ")", ";", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "{", "bool", "UseAVX512Inst", "=", "(", "OpVT", ".", "is512BitVector", "(", ")", "||", "OpVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", "||", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", ")", ";", "if", "(", "UseAVX512Inst", ")", "return", "LowerIntVSETCC_AVX512", "(", "Op", ",", "DAG", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SETCC", ",", "dl", ",", "OpVT", ",", "Op0", ",", "Op1", ",", "CC", ")", ")", ";", "}", "if", "(", "(", "VT", "==", "MVT", "::", "v16i8", "||", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v4i32", "||", "VT", "==", "MVT", "::", "v2i64", ")", "&&", "Subtarget", ".", "hasXOP", "(", ")", ")", "{", "unsigned", "CmpMode", "=", "<NUM_LIT>", ";", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected SETCC condition", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETLT", ":", "CmpMode", "=", "<NUM_LIT>", ";", "break", ";", "case", "ISD", "::", "SETULE", ":", "case", "ISD", "::", "SETLE", ":", "CmpMode", "=", "<NUM_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETGT", ":", "CmpMode", "=", "<NUM_LIT>", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "case", "ISD", "::", "SETGE", ":", "CmpMode", "=", "<NUM_LIT>", ";", "break", ";", "case", "ISD", "::", "SETEQ", ":", "CmpMode", "=", "<NUM_LIT>", ";", "break", ";", "case", "ISD", "::", "SETNE", ":", "CmpMode", "=", "<NUM_LIT>", ";", "break", ";", "}", "unsigned", "Opc", "=", "ISD", "::", "isUnsignedIntSetCC", "(", "SetCCOpcode", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "CmpMode", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "}", "unsigned", "Opc", ";", "bool", "Swap", "=", "false", ",", "Invert", "=", "false", ",", "FlipSigns", "=", "false", ",", "MinMax", "=", "false", ";", "bool", "Subus", "=", "false", ";", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected SETCC condition", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SETNE", ":", "Invert", "=", "true", ";", "case", "ISD", "::", "SETEQ", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETLT", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETGT", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SETGE", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETLE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Invert", "=", "true", ";", "break", ";", "case", "ISD", "::", "SETULT", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETUGT", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "FlipSigns", "=", "true", ";", "break", ";", "case", "ISD", "::", "SETUGE", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETULE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ ")" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{" ]

[ ".", "find", "(", "VReg", ")", ";" ]

[ "auto", "t", "=", "VRegToTypeMap", ".", "find", "(", "CurMF", ")", ";", "if", "(", "t", "!=", "VRegToTypeMap", ".", "end", "(", ")", ")", "{", "auto", "tt", "=", "t", "->", "second" ]

[ "return", "SDValue", "(", ")", ";" ]

[ "if", "(", "SextVal", "==", "(", "int", ")", "(", "(", "unsigned", ")", "i", ">>", "TypeShiftAmt", ")", ")", "{", "SDValue", "Res", "=", "BuildSplatI", "(", "i", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "static", "const", "unsigned", "IIDs", "[", "]", "=", "{", "Intrinsic", "::", "ppc_altivec_vsrb", ",", "Intrinsic", "::", "ppc_altivec_vsrh", ",", "<NUM_LIT>", ",", "Intrinsic", "::", "ppc_altivec_vsrw", "}", ";", "Res", "=", "BuildIntrinsicOp", "(", "IIDs", "[", "SplatSize", "-", "<NUM_LIT>", "]", ",", "Res", ",", "Res", ",", "DAG", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Res", ")", ";", "}", "if", "(", "SextVal", "==", "(", "int", ")", "(", "(", "unsigned", ")", "i", ">>", "TypeShiftAmt", ")", ")", "{", "SDValue", "Res", "=", "BuildSplatI", "(", "i", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "static", "const", "unsigned", "IIDs", "[", "]", "=", "{", "Intrinsic", "::", "ppc_altivec_vsrab", ",", "Intrinsic", "::", "ppc_altivec_vsrah", ",", "<NUM_LIT>", ",", "Intrinsic", "::", "ppc_altivec_vsraw", "}", ";", "Res", "=", "BuildIntrinsicOp", "(", "IIDs", "[", "SplatSize", "-", "<NUM_LIT>", "]", ",", "Res", ",", "Res", ",", "DAG", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Res", ")", ";", "}", "if", "(", "SextVal", "==", "(", "int", ")", "(", "(", "(", "unsigned", ")", "i", "<<", "TypeShiftAmt", ")", "|", "(", "(", "unsigned", ")", "i", ">>", "(", "SplatBitSize", "-", "TypeShiftAmt", ")", ")", ")", ")", "{", "SDValue", "Res", "=", "BuildSplatI", "(", "i", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "static", "const", "unsigned", "IIDs", "[", "]", "=", "{", "Intrinsic", "::", "ppc_altivec_vrlb", ",", "Intrinsic", "::", "ppc_altivec_vrlh", ",", "<NUM_LIT>", ",", "Intrinsic", "::", "ppc_altivec_vrlw", "}", ";", "Res", "=", "BuildIntrinsicOp", "(", "IIDs", "[", "SplatSize", "-", "<NUM_LIT>", "]", ",", "Res", ",", "Res", ",", "DAG", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Res", ")", ";", "}", "if", "(", "SextVal", "==", "(", "int", ")", "(", "(", "(", "unsigned", ")", "i", "<<", "<NUM_LIT>", ")", "|", "(", "i", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "T", "=", "BuildSplatI", "(", "i", ",", "SplatSize", ",", "MVT", "::", "v16i8", ",", "DAG", ",", "dl", ")", ";", "return", "BuildVSLDOI", "(", "T", ",", "T", ",", "<NUM_LIT>", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ",", "dl", ")", ";", "}", "if", "(", "SextVal", "==", "(", "int", ")", "(", "(", "(", "unsigned", ")", "i", "<<", "<NUM_LIT>", ")", "|", "(", "i", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "T", "=", "BuildSplatI", "(", "i", ",", "SplatSize", ",", "MVT", "::", "v16i8", ",", "DAG", ",", "dl", ")", ";", "return", "BuildVSLDOI", "(", "T", ",", "T", ",", "<NUM_LIT>", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ",", "dl", ")", ";", "}", "if", "(", "SextVal", "==", "(", "int", ")", "(", "(", "(", "unsigned", ")", "i", "<<", "<NUM_LIT>", ")", "|", "(", "i", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "T", "=", "BuildSplatI", "(", "i", ",", "SplatSize", ",", "MVT", "::", "v16i8", ",", "DAG", ",", "dl", ")", ";", "return", "BuildVSLDOI", "(", "T", ",", "T", ",", "<NUM_LIT>", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ",", "dl", ")", ";", "}", "}", "if", "(", "SextVal", ">=", "<NUM_LIT>", "&&", "SextVal", "<=", "<NUM_LIT>", ")", "{", "SDValue", "LHS", "=", "BuildSplatI", "(", "SextVal", "-", "<NUM_LIT>", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "SDValue", "RHS", "=", "BuildSplatI", "(", "-", "<NUM_LIT>", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "LHS", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "LHS", ")", ";", "}", "if", "(", "SextVal", ">=", "-", "<NUM_LIT>", "&&", "SextVal", "<=", "<NUM_LIT>", ")", "{", "SDValue", "LHS", "=", "BuildSplatI", "(", "SextVal", "+", "<NUM_LIT>", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "SDValue", "RHS", "=", "BuildSplatI", "(", "-", "<NUM_LIT>", ",", "SplatSize", ",", "MVT", "::", "Other", ",", "DAG", ",", "dl", ")", ";", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "LHS", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "LHS", ")", ";", "}" ]

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

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

[ ";" ]

[ "if", "(", "!", "ST", ".", "hasSDWASdst", "(", ")", ")", "{", "const", "MachineOperand", "*", "SDst", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "if", "(", "SDst", "&&", "SDst", "->", "getReg", "(", ")", "!=", "AMDGPU", "::", "VCC", ")", "return", "false", ";", "}", "if", "(", "!", "ST", ".", "hasSDWAClampVOPC", "(", ")", "&&", "TII", "->", "hasModifiersSet", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "clamp", ")", ")", "return", "false", ";", "}", "else", "if", "(", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "ST", ".", "hasSDWAMac", "(", ")", "&&", "(", "Opc", "==", "AMDGPU", "::", "V_MAC_F16_e32", "||", "Opc", "==", "AMDGPU", "::", "V_MAC_F32_e32", ")", ")", "return", "false", ";", "return", "true" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_memory_constraint", "<STR_LIT>", "<STR_LIT>", "(", "and", "(", "match_code" ]

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

[ "def", "A2_tfrrcr", ":", "HInst", "<", "(", "outs", "CtrRegs", ":", "$", "Cd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_434c8e1e", ",", "TypeCR", ">", ",", "Enc_bd811a", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v16i8", "(", "load", "am_indexed128", ":", "$", "addr", ")", ")", ",", "(", "LDRQui", "am_indexed128" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "extend", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";" ]

[ "}" ]

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

[ ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ",", "isLittle", "(", "isLittle", ")", "{" ]

[ "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")" ]

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

[ "def", "A4_cmpbeq", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeS_3op", ">", ",", "Enc_c2b48e", ",", "ImmRegRel", "{", "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", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "BuildMI", "(", "MBB", ",", "InsertBefore", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "Out", ")", ".", "addReg", "(", "Reg1", ")", ".", "addImm", "(", "ARM", "::", "dsub_0", ")", ".", "addReg", "(", "Reg2", ")", ".", "addImm", "(", "ARM", "::", "dsub_1", ")", ";", "return", "Out", ";" ]

[ "O", "<<", "<STR_LIT>", "ge", "<STR_LIT>", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unsupported CC code", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "eq", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "ne", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "hs", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "lo", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "_", "_", "o", "=", "_", "_", "builtin_aarch64_set_qregciv2di", "(", "_", "_", "o", ",", "(", "int64x2_t", ")", "val", ".", "val", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";" ]

[ "vst3q_u64", "(", "uint64_t", "*", "_", "_", "a", ",", "uint64x2x3_t", "val", ")", "{", "_", "_", "builtin_aarch64_simd_ci", "_", "_", "o", ";", "_", "_", "o", "=", "_", "_", "builtin_aarch64_set_qregciv2di", "(", "_", "_", "o", ",", "(", "int64x2_t", ")", "val", ".", "val", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isReMaterializable", "=", "<NUM_LIT>", ";", "let", "isAsCheapAsAMove", "=", "<NUM_LIT>", ";" ]

[ "end", "(", "Match", ")", ",", "Match_MissingFeature", ")", "==", "<NUM_LIT>", ")", "{" ]

[ "if", "(", "NumSuccessfulMatches", ">", "<NUM_LIT>", ")", "{", "char", "MatchChars", "[", "<NUM_LIT>", "]", ";", "unsigned", "NumMatches", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "array_lengthof", "(", "Match", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "Match", "[", "I", "]", "==", "Match_Success", ")", "MatchChars", "[", "NumMatches", "++", "]", "=", "Suffixes", "[", "I", "]", ";", "SmallString", "<", "<NUM_LIT>", ">", "Msg", ";", "raw_svector_ostream", "OS", "(", "Msg", ")", ";", "OS", "<<", "<STR_LIT>", "ambiguous instructions require an explicit suffix (could be ", "<STR_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumMatches", ";", "++", "i", ")", "{", "if", "(", "i", "!=", "<NUM_LIT>", ")", "OS", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "if", "(", "i", "+", "<NUM_LIT>", "==", "NumMatches", ")", "OS", "<<", "<STR_LIT>", "or ", "<STR_LIT>", ";", "OS", "<<", "<STR_LIT>", "'", "<STR_LIT>", "<<", "Base", "<<", "MatchChars", "[", "i", "]", "<<", "<STR_LIT>", "'", "<STR_LIT>", ";", "}", "OS", "<<", "<STR_LIT>", ")", "<STR_LIT>", ";", "Error", "(", "IDLoc", ",", "OS", ".", "str", "(", ")", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "return", "true", ";", "}", "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_MnemonicFail", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "OriginalError", "==", "Match_MnemonicFail", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction mnemonic '", "<STR_LIT>", "+", "Base", "+", "<STR_LIT>", "'", "<STR_LIT>", ",", "Op", ".", "getLocRange", "(", ")", ",", "MatchingInlineAsm", ")", ";", "if", "(", "OriginalError", "==", "Match_Unsupported", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "unsupported instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "assert", "(", "OriginalError", "==", "Match_InvalidOperand", "&&", "<STR_LIT>", "Unexpected error", "<STR_LIT>", ")", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "X86Operand", "&", "Operand", "=", "(", "X86Operand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ";", "if", "(", "Operand", ".", "getStartLoc", "(", ")", ".", "isValid", "(", ")", ")", "{", "SMRange", "OperandRange", "=", "Operand", ".", "getLocRange", "(", ")", ";", "return", "Error", "(", "Operand", ".", "getStartLoc", "(", ")", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ",", "OperandRange", ",", "MatchingInlineAsm", ")", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "}", "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::", "end", "(", "Match", ")", ",", "Match_Unsupported", ")", "==", "<NUM_LIT>", ")", "{", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "unsupported instruction", "<STR_LIT>", ",", "EmptyRange", ",", "MatchingInlineAsm", ")", ";", "}", "if", "(", "std", "::", "count", "(", "std", "::", "begin", "(", "Match", ")", ",", "std", "::" ]

[ "]", ")", "&", "GET_MODE_MASK", "(", "<", "MODE", ">", "mode", ")", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SHORT", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "SHORT", "(", "match_operand", ":", "SHORT", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>" ]

[ "return", "Size", "==", "<NUM_LIT>", "||", "Size", "==", "<NUM_LIT>", ";" ]

[ "int", "Size", "=", "HVC", ".", "getSizeOf", "(", "Ty", ")", ";", "if", "(", "HVC", ".", "HST", ".", "isTypeForHVX", "(", "Ty", ")", ")", "return", "Size", "==", "static_cast", "<", "int", ">", "(", "HVC", ".", "HST", ".", "getVectorLength", "(", ")", ")", ";" ]

[ "static", "reg_class_t", "sh_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "GBR_REG", ")", "return", "rclass", "==", "R0_REGS", "?", "NO_REGS", ":", "R0_REGS", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "GBR_REG", ")", "return", "rclass", "==", "R0_REGS", "?", "NO_REGS", ":", "R0_REGS", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "GBR_REG", ")", "return", "NO_REGS", ";", "if", "(", "in_p", ")", "{", "if", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "!", "TARGET_SHMEDIA", "&&", "immediate_operand", "(", "(", "x", ")", ",", "mode", ")", "&&", "!", "(", "(", "fp_zero_operand", "(", "x", ")", "||", "fp_one_operand", "(", "x", ")", ")", "&&", "mode", "==", "SFmode", ")", ")", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insf__frn", ";", "return", "NO_REGS", ";", "case", "DFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indf__frn", ";", "return", "NO_REGS", ";", "case", "SImode", ":", "return", "FPUL_REGS", ";", "default", ":", "abort", "(", ")", ";", "}", "if", "(", "rclass", "==", "FPUL_REGS", "&&", "(", "(", "REG_P", "(", "x", ")", "&&", "(", "REGNO", "(", "x", ")", "==", "MACL_REG", "||", "REGNO", "(", "x", ")", "==", "MACH_REG", "||", "REGNO", "(", "x", ")", "==", "T_REG", ")", ")", "||", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "rclass", "==", "FPUL_REGS", "&&", "immediate_operand", "(", "x", ",", "mode", ")", ")", "{", "if", "(", "satisfies_constraint_I08", "(", "x", ")", "||", "fp_zero_operand", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "mode", "==", "SFmode", ")", "return", "FP_REGS", ";", "sri", "->", "icode", "=", "CODE_FOR_reload_insi__i_fpul", ";", "return", "NO_REGS", ";", "}", "if", "(", "rclass", "==", "FPSCR_REGS", "&&", "(", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "||", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "TARGET_SHMEDIA", "&&", "immediate_operand", "(", "x", ",", "mode", ")", "&&", "x", "!=", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", "&&", "GET_MODE", "(", "x", ")", "!=", "V4SFmode", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "TARGET_SHMEDIA", "&&", "inqhi_operand", "(", "x", ",", "mode", ")", ")", "{", "sri", "->", "icode", "=", "(", "(", "mode", "==", "QImode", ")", "?", "CODE_FOR_reload_inqi", ":", "CODE_FOR_reload_inhi", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "TARGET_SHMEDIA", "&&", "rclass", "==", "GENERAL_REGS", "&&", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "PIC_ADDR_P", "(", "x", ")", ")", ")", "return", "TARGET_REGS", ";", "}", "if", "(", "(", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "(", "REG_P", "(", "x", ")", "&&", "(", "GENERAL_OR_AP_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", "||", "(", "FP_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", "&&", "mode", "==", "SImode", "&&", "TARGET_FMOVD", ")", ")", ")", ")", "||", "(", "REGCLASS_HAS_GENERAL_REG", "(", "rclass", ")", "&&", "REG_P", "(", "x", ")", "&&", "FP_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", "&&", "!", "TARGET_SHMEDIA", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", ")", "return", "FPUL_REGS", ";", "if", "(", "(", "rclass", "==", "FPUL_REGS", "||", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "!", "TARGET_SHMEDIA", "&&", "mode", "==", "SImode", ")", ")", "&&", "(", "MEM_P", "(", "x", ")", "||", "(", "REG_P", "(", "x", ")", "&&", "(", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", "||", "REGNO", "(", "x", ")", "==", "T_REG", "||", "system_reg_operand", "(", "x", ",", "VOIDmode", ")", ")", ")", ")", ")", "{", "if", "(", "rclass", "==", "FPUL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "if", "(", "(", "rclass", "==", "TARGET_REGS", "||", "(", "TARGET_SHMEDIA", "&&", "rclass", "==", "SIBCALL_REGS", ")", ")", "&&", "!", "satisfies_constraint_Csy", "(", "x", ")", "&&", "(", "!", "REG_P", "(", "x", ")", "||", "!", "GENERAL_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "rclass", "==", "MAC_REGS", "||", "rclass", "==", "PR_REGS", ")", "&&", "REG_P", "(", "x", ")", "&&", "!", "GENERAL_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", "&&", "rclass", "!=", "REGNO_REG_CLASS", "(", "REGNO", "(", "x", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "rclass", "!=", "GENERAL_REGS", "&&", "REG_P", "(", "x", ")", "&&", "TARGET_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "rclass", "==", "FPUL_REGS", "&&", "true_regnum", "(", "x", ")", "==", "-", "<NUM_LIT>", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "rclass", "!=", "R0_REGS", "&&", "satisfies_constraint_Sdd", "(", "x", ")", "&&", "sh_disp_addr_displacement", "(", "x", ")", "<=", "sh_max_mov_insn_displacement", "(", "mode", ",", "false", ")", ")", "return", "R0_REGS", ";", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "rclass", "!=", "R0_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "true_regnum", "(", "x", ")", "==", "-", "<NUM_LIT>", ")", "return", "R0_REGS", ";", "return", "NO_REGS", ";", "}" ]

[ "Implement", "TARGET_SECONDARY_RELOAD", "." ]

[ "<FIXS>", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "<FIXE>" ]

[ "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "<BUGS>", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "||", "GET_MODE", "(", "x", ")", "==", "HImode", ")", "<BUGE>", "*", "total", "=", "COSTS_N_INSNS", "(", "DIVW_COST", ")", ";", "else", "if", "(", "TARGET_CF_HWDIV", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";" ]

[ "{" ]

[ "MCRegister", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ",", "bool", "ReserveHighestRegister", ")", "const", "{", "if", "(", "ReserveHighestRegister", ")" ]

[ "char", "*", "construct_restore_jr", "(", "rtx", "op", ")", "{", "int", "count", "=", "XVECLEN", "(", "op", ",", "<NUM_LIT>", ")", ";", "int", "stack_bytes", ";", "unsigned", "long", "int", "mask", ";", "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "<NUM_LIT>", "]", ";", "if", "(", "count", "<=", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "bogus JR construction: %d", "<STR_LIT>", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ",", "<NUM_LIT>", ")", ")", ";", "stack_bytes", "-=", "(", "count", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ";", "if", "(", "stack_bytes", "!=", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "bad amount of stack space removal: %d", "<STR_LIT>", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_DEST", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_DEST", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "<NUM_LIT>", "<<", "REGNO", "(", "SET_DEST", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "<NUM_LIT>", ";", "first", "<", "<NUM_LIT>", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "<NUM_LIT>", ")", ";", "if", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", ";", "last", "=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_LONG_CALLS", ")", "{", "char", "name", "[", "<NUM_LIT>", "]", ";", "if", "(", "first", "==", "last", ")", "sprintf", "(", "name", ",", "<STR_LIT>", "__return_%s", "<STR_LIT>", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "name", ",", "<STR_LIT>", "__return_%s_%s", "<STR_LIT>", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "sprintf", "(", "buff", ",", "<STR_LIT>", "movhi hi(%s), r0, r6\\n\\tmovea lo(%s), r6, r6\\n\\tjmp r6", "<STR_LIT>", ",", "name", ",", "name", ")", ";", "}", "else", "{", "if", "(", "first", "==", "last", ")", "sprintf", "(", "buff", ",", "<STR_LIT>", "jr __return_%s", "<STR_LIT>", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "buff", ",", "<STR_LIT>", "jr __return_%s_%s", "<STR_LIT>", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "}", "return", "buff", ";", "}" ]

[ "Construct", "a", "JR", "instruction", "to", "a", "routine", "that", "will", "perform", "the", "equivalent", "of", "the", "RTL", "passed", "in", "as", "an", "argument", ".", "This", "RTL", "is", "a", "function", "epilogue", "that", "pops", "registers", "off", "the", "stack", "and", "possibly", "releases", "some", "extra", "stack", "space", "as", "well", ".", "The", "code", "has", "already", "verified", "that", "the", "RTL", "matches", "these", "requirements", "." ]

[ "<STR_LIT>" ]

[ "(", "eq", ":", "SI", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "FPSCR_STAT_REG", ")", ")", "(", "use", "(", "reg", ":", "SI", "FPSCR_MODES_REG", ")", ")", "]" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_permutex2var_ps", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "I", ",", "_", "_", "m256", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_vpermt2varps256_maskz", "(", "(", "_", "_", "v8si", ")", "_", "_", "I", ",", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "B", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "{" ]

[ "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]" ]

[ "_", "v2df", ")", "_", "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_unpckhpd", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "(", "_" ]

[ "const", "char", "*", "avr_out_cpymem", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "addr_space_t", "as", "=", "(", "addr_space_t", ")", "INTVAL", "(", "op", "[", "<NUM_LIT>", "]", ")", ";", "machine_mode", "loop_mode", "=", "GET_MODE", "(", "op", "[", "<NUM_LIT>", "]", ")", ";", "bool", "sbiw_p", "=", "test_hard_reg_class", "(", "ADDW_REGS", ",", "op", "[", "<NUM_LIT>", "]", ")", ";", "rtx", "xop", "[", "<NUM_LIT>", "]", ";", "if", "(", "plen", ")", "*", "plen", "=", "<NUM_LIT>", ";", "xop", "[", "<NUM_LIT>", "]", "=", "op", "[", "<NUM_LIT>", "]", ";", "xop", "[", "<NUM_LIT>", "]", "=", "op", "[", "<NUM_LIT>", "]", ";", "xop", "[", "<NUM_LIT>", "]", "=", "tmp_reg_rtx", ";", "avr_asm_len", "(", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "switch", "(", "as", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ADDR_SPACE_GENERIC", ":", "avr_asm_len", "(", "<STR_LIT>", "ld %2,Z+", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "ADDR_SPACE_FLASH", ":", "if", "(", "AVR_HAVE_LPMX", ")", "avr_asm_len", "(", "<STR_LIT>", "lpm %2,Z+", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "else", "avr_asm_len", "(", "<STR_LIT>", "lpm", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "adiw r30,1", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "ADDR_SPACE_FLASH1", ":", "case", "ADDR_SPACE_FLASH2", ":", "case", "ADDR_SPACE_FLASH3", ":", "case", "ADDR_SPACE_FLASH4", ":", "case", "ADDR_SPACE_FLASH5", ":", "if", "(", "AVR_HAVE_ELPMX", ")", "avr_asm_len", "(", "<STR_LIT>", "elpm %2,Z+", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "else", "avr_asm_len", "(", "<STR_LIT>", "elpm", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "adiw r30,1", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "break", ";", "}", "avr_asm_len", "(", "<STR_LIT>", "st X+,%2", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "if", "(", "QImode", "==", "loop_mode", ")", "{", "avr_asm_len", "(", "<STR_LIT>", "dec %1", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "sbiw_p", ")", "{", "avr_asm_len", "(", "<STR_LIT>", "sbiw %1,1", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "avr_asm_len", "(", "<STR_LIT>", "subi %A1,1", "<STR_LIT>", "CR_TAB", "<STR_LIT>", "sbci %B1,0", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "}", "return", "avr_asm_len", "(", "<STR_LIT>", "brne 0b", "<STR_LIT>", ",", "xop", ",", "plen", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "Print", "assembler", "for", "cpymem_qi", ",", "cpymem_hi", "insns", "...", "$", "0", ":", "Address", "Space", "$", "1", ",", "$", "2", ":", "Loop", "register", "Z", ":", "Source", "address", "X", ":", "Destination", "address" ]

[ "SchedModel", "(", "SM", ")", "{" ]

[ "SystemZHazardRecognizer", "(", "const", "SystemZInstrInfo", "*", "tii", ",", "const", "TargetSchedModel", "*", "SM", ")", ":", "TII", "(", "tii", ")", "," ]

[ ",", "GPR32Opnd", ",", "MSA128WOpnd", ">", ";" ]

[ "class", "COPY_U_W_DESC", ":", "MSA_COPY_DESC_BASE", "<", "<STR_LIT>", ",", "vextract_zext_i32", ",", "v4i32" ]

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

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

[ "}" ]

[ "if", "(", "isa", "<", "StoreInst", ">", "(", "I", ")", "||", "isa", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "Value", "*", "Ptr", "=", "getLoadStorePointerOperand", "(", "&", "I", ")", ";", "Type", "*", "AccessTy", "=", "getLoadStoreType", "(", "&", "I", ")", ";", "int64_t", "NextStride", "=", "getPtrStride", "(", "PSE", ",", "AccessTy", ",", "Ptr", ",", "L", ")", ";", "if", "(", "NextStride", "==", "<NUM_LIT>", ")", "{", "continue", ";", "}", "else", "if", "(", "NextStride", "==", "-", "<NUM_LIT>", "||", "(", "NextStride", "==", "<NUM_LIT>", "&&", "MVEMaxSupportedInterleaveFactor", ">=", "<NUM_LIT>", ")", "||", "(", "NextStride", "==", "<NUM_LIT>", "&&", "MVEMaxSupportedInterleaveFactor", ">=", "<NUM_LIT>", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Consecutive strides of 2 found, vld2/vstr2 can't ", "<STR_LIT>", "<STR_LIT>", "be tail-predicated\\n.", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "else", "if", "(", "EnableMaskedGatherScatters", ")", "{", "const", "SCEV", "*", "PtrScev", "=", "PSE", ".", "getSE", "(", ")", "->", "getSCEV", "(", "Ptr", ")", ";", "if", "(", "auto", "AR", "=", "dyn_cast", "<", "SCEVAddRecExpr", ">", "(", "PtrScev", ")", ")", "{", "const", "SCEV", "*", "Step", "=", "AR", "->", "getStepRecurrence", "(", "*", "PSE", ".", "getSE", "(", ")", ")", ";", "if", "(", "PSE", ".", "getSE", "(", ")", "->", "isLoopInvariant", "(", "Step", ",", "L", ")", ")", "continue", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "void", "useExtLoopInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "::", "iterator", "&", "MII", ")", ";", "<FIXE>" ]

[ "}", "private", ":", "<BUGS>", "static", "const", "unsigned", "MAX_LOOP_DISTANCE", "=", "<NUM_LIT>", ";", "<BUGE>", "bool", "fixupLoopInstrs", "(", "MachineFunction", "&", "MF", ")", ";", "<BUGS>", "void", "convertLoopInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "::", "iterator", "&", "MII", ",", "RegScavenger", "&", "RS", ")", ";", "<BUGE>", "}", ";", "char", "HexagonFixupHwLoops", "::", "ID", "=", "<NUM_LIT>", ";" ]

[ "default", ":" ]

[ "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "arg1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "arg2", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "index", "=", "NULL_RTX", ";", "if", "(", "REG_P", "(", "arg1", ")", "&&", "RTX_OK_FOR_BASE", "(", "arg1", ",", "strict", ")", ")", "index", "=", "arg2", ";", "else", "if", "(", "REG_P", "(", "arg2", ")", "&&", "RTX_OK_FOR_BASE", "(", "arg2", ",", "strict", ")", ")", "index", "=", "arg1", ";", "else", "return", "false", ";", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "index", ")", ";", "int", "factor", ";", "if", "(", "val", "<", "<NUM_LIT>", ")", "return", "false", ";", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{" ]

[ "case", "Hexagon", "::", "A2_tfrpt", ":" ]

[ "case", "Hexagon", "::", "A2_tfrt", ":", "case", "Hexagon", "::", "A2_tfrf", ":", "case", "Hexagon", "::", "C2_cmoveit", ":", "case", "Hexagon", "::", "C2_cmoveif", ":", "case", "Hexagon", "::", "A2_tfrtnew", ":", "case", "Hexagon", "::", "A2_tfrfnew", ":", "case", "Hexagon", "::", "C2_cmovenewit", ":", "case", "Hexagon", "::", "C2_cmovenewif", ":" ]

[ "}" ]

[ "_", "_", "asm__", "(", "<STR_LIT>", "mls %0.16b,%2.16b,%3.16b", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "(", "a", ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(", "b", ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(", "c", ")", ":", ")", ";", "return", "result", ";" ]

[ "CalleeFn", "=", "M", "->", "getFunction", "(", "E", "->", "getSymbol", "(", ")", ")", ";" ]

[ "unsigned", "SparcTargetLowering", "::", "getSRetArgSize", "(", "SelectionDAG", "&", "DAG", ",", "SDValue", "Callee", ")", "const", "{", "const", "Function", "*", "CalleeFn", "=", "<NUM_LIT>", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "CalleeFn", "=", "dyn_cast", "<", "Function", ">", "(", "G", "->", "getGlobal", "(", ")", ")", ";", "}", "else", "if", "(", "ExternalSymbolSDNode", "*", "E", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "const", "Function", "*", "Fn", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "const", "Module", "*", "M", "=", "Fn", "->", "getParent", "(", ")", ";" ]

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

[ "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>" ]

[ "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "loop", "->", "iter_reg", ",", "const0_rtx", ")", ";" ]

[ "rtx_insn", "*", "insn", "=", "loop", "->", "loop_end", ";", "emit_insn_before", "(", "gen_addsi3", "(", "loop", "->", "iter_reg", ",", "loop", "->", "iter_reg", ",", "constm1_rtx", ")", ",", "loop", "->", "loop_end", ")", ";" ]

[ ",", "FPR64", ":", "$", "src1", ")", ",", "<NUM_LIT>", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "CMHSv1i64", "FPR64", ":", "$", "dst", ",", "FPR64", ":", "$", "src2" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "(", "zero_extend", ":", "DI", "(", "ashiftrt", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "}", "=", "Pt", ";" ]

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

[ "i32", ")", ";" ]

[ "EVT", "OpVT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDValue", "TVal", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "OpVT", ")", ";", "SDValue", "FVal", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "OpVT", ")", ";", "ISD", "::", "CondCode", "Cond", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "ISD", "::", "CondCode", "CondInv", "=", "ISD", "::", "getSetCCInverse", "(", "Cond", ",", "VT", ")", ";", "SDValue", "CCVal", "=", "DAG", ".", "getConstant", "(", "changeIntCCToAArch64CC", "(", "CondInv", ")", ",", "DL", ",", "MVT", "::" ]

[ ",", "_", "_", "b", ")", ";" ]

[ "return", "(", "float32x2_t", ")", "_", "_", "builtin_neon_vpaddv2sf", "(", "_", "_", "a" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "QIHI", "<NUM_LIT>", "<STR_LIT>", ")", ")" ]

[ "if", "(", "code", "==", "LEU", ")", "emit_insn", "(", "gen_sltu_insn", "(", "op0", ",", "op1", ",", "op2", ")", ")", ";" ]

[ "emit_insn", "(", "gen_slt_insn", "(", "op0", ",", "op1", ",", "op2", ")", ")", ";", "return", "true", ";", "case", "LTU", ":", "case", "GTU", ":", "if", "(", "code", "==", "GTU", ")", "{", "rtx", "tmp", "=", "op2", ";", "op2", "=", "op1", ";", "op1", "=", "tmp", ";", "code", "=", "LTU", ";", "}", "if", "(", "!", "register_operand", "(", "op1", ",", "mode", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "!", "reg_or_int16_operand", "(", "op2", ",", "mode", ")", ")", "op2", "=", "force_reg", "(", "mode", ",", "op2", ")", ";", "emit_insn", "(", "gen_sltu_insn", "(", "op0", ",", "op1", ",", "op2", ")", ")", ";", "return", "true", ";", "case", "GE", ":", "case", "GEU", ":", "if", "(", "!", "register_operand", "(", "op1", ",", "mode", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "!", "reg_or_int16_operand", "(", "op2", ",", "mode", ")", ")", "op2", "=", "force_reg", "(", "mode", ",", "op2", ")", ";", "if", "(", "code", "==", "GE", ")", "emit_insn", "(", "gen_sge_insn", "(", "op0", ",", "op1", ",", "op2", ")", ")", ";", "else", "emit_insn", "(", "gen_sgeu_insn", "(", "op0", ",", "op1", ",", "op2", ")", ")", ";", "return", "true", ";", "case", "LE", ":", "case", "LEU", ":", "if", "(", "!", "register_operand", "(", "op1", ",", "mode", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "CONST_INT_P", "(", "op2", ")", ")", "{", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "op2", ")", ";", "if", "(", "value", ">=", "<NUM_LIT>", ")", "{", "emit_move_insn", "(", "op0", ",", "const1_rtx", ")", ";", "return", "true", ";", "}", "op2", "=", "GEN_INT", "(", "value", "+", "<NUM_LIT>", ")", ";", "if", "(", "value", "<", "-", "<NUM_LIT>", "||", "value", ">=", "<NUM_LIT>", ")", "op2", "=", "force_reg", "(", "mode", ",", "op2", ")", ";" ]

[ "bool", "sh_is_logical_t_store_expr", "(", "rtx", "op", ",", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "logical_operator", "(", "op", ",", "SImode", ")", ")", "return", "false", ";", "rtx", "ops", "[", "<NUM_LIT>", "]", "=", "{", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", "}", ";", "int", "op_is_t_count", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "if", "(", "t_reg_operand", "(", "ops", "[", "i", "]", ",", "VOIDmode", ")", "||", "negt_reg_operand", "(", "ops", "[", "i", "]", ",", "VOIDmode", ")", ")", "op_is_t_count", "++", ";", "else", "{", "set_of_reg", "op_set", "=", "sh_find_set_of_reg", "(", "ops", "[", "i", "]", ",", "insn", ",", "prev_nonnote_nondebug_insn_bb", ")", ";", "if", "(", "op_set", ".", "set_src", "==", "NULL_RTX", ")", "continue", ";", "if", "(", "t_reg_operand", "(", "op_set", ".", "set_src", ",", "VOIDmode", ")", "||", "negt_reg_operand", "(", "op_set", ".", "set_src", ",", "VOIDmode", ")", "||", "sh_is_logical_t_store_expr", "(", "op_set", ".", "set_src", ",", "op_set", ".", "insn", ")", ")", "op_is_t_count", "++", ";", "}", "}", "return", "op_is_t_count", "==", "<NUM_LIT>", ";", "}" ]

[ "Given", "an", "op", "rtx", "and", "an", "insn", ",", "try", "to", "find", "out", "whether", "the", "result", "of", "the", "specified", "op", "consists", "only", "of", "logical", "operations", "on", "T", "bit", "stores", "." ]

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

[ "return", "output_return", "(", "insn", ")", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", "(", "ior", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "}", "auto", "FirstElt", "=", "Srcs", ".", "begin", "(", ")", ";", "auto", "SecondElt", "=", "std", "::", "next", "(", "FirstElt", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Perms", ";", "while", "(", "true", ")", "{", "auto", "FirstMask", "=", "FirstElt", "->", "PermMask", ";", "auto", "SecondMask", "=", "SecondElt", "->", "PermMask", ";", "unsigned", "FirstCs", "=", "FirstMask", "&", "<NUM_LIT>", ";", "unsigned", "FirstPlusFour", "=", "FirstMask", "|", "<NUM_LIT>", ";", "FirstMask", "=", "(", "FirstPlusFour", "&", "<NUM_LIT>", ")", "|", "FirstCs", ";", "auto", "PermMask", "=", "addPermMasks", "(", "FirstMask", ",", "SecondMask", ")", ";", "auto", "FirstVal", "=", "getDWordFromOffset", "(", "DAG", ",", "SL", ",", "FirstElt", "->", "SrcOp", ",", "FirstElt", "->", "DWordOffset", ")", ";", "auto", "SecondVal", "=", "getDWordFromOffset", "(", "DAG", ",", "SL", ",", "SecondElt", "->", "SrcOp", ",", "SecondElt", "->", "DWordOffset", ")", ";", "Perms", ".", "push_back", "(", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SL", ",", "MVT", "::", "i32", ",", "FirstVal", ",", "SecondVal", ",", "DAG", ".", "getConstant", "(", "PermMask", ",", "SL", ",", "MVT", "::", "i32", ")", ")", ")", ";", "FirstElt", "=", "std", "::", "next", "(", "SecondElt", ")", ";", "if", "(", "FirstElt", "==", "Srcs", ".", "end", "(", ")", ")", "break", ";", "SecondElt", "=", "std", "::", "next" ]

[ ";" ]

[ "bool", "detect_cmse_nonsecure_call", "(", "tree", "addr", ")", "{", "if", "(", "!", "addr", ")", "return", "FALSE", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "addr", ")", ";", "if", "(", "use_cmse", "&&", "lookup_attribute", "(", "<STR_LIT>", "cmse_nonsecure_call", "<STR_LIT>", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "return", "TRUE", ";", "return", "FALSE" ]

[ ">", ",", "IsCommutable", ";" ]

[ "class", "AVE_U_D_DESC", ":", "MSA_3R_DESC_BASE", "<", "<STR_LIT>", ",", "int_mips_ave_u_d", ",", "MSA128DOpnd" ]

[ ";" ]

[ "unsigned", "X86FastISel", "::", "fastEmitInst_rrrr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ",", "unsigned", "Op1", ",", "bool", "Op1IsKill", ",", "unsigned", "Op2", ",", "bool", "Op2IsKill", ",", "unsigned", "Op3", ",", "bool", "Op3IsKill", ")", "{", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "II", ".", "getNumDefs", "(", ")", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "II", ".", "getNumDefs", "(", ")", "+", "<NUM_LIT>", ")", ";", "Op2", "=", "constrainOperandRegClass", "(", "II", ",", "Op2", ",", "II", ".", "getNumDefs", "(", ")", "+", "<NUM_LIT>", ")", ";", "Op3", "=", "constrainOperandRegClass", "(", "II", ",", "Op3", ",", "II", ".", "getNumDefs", "(", ")", "+", "<NUM_LIT>", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "<NUM_LIT>", ")", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "getKillRegState", "(", "Op0IsKill", ")", ")", ".", "addReg", "(", "Op1", ",", "getKillRegState", "(", "Op1IsKill", ")", ")", ".", "addReg", "(", "Op2", ",", "getKillRegState", "(", "Op2IsKill", ")", ")", ".", "addReg", "(", "Op3", ",", "getKillRegState", "(", "Op3IsKill", ")", ")", ";", "else", "{", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "getKillRegState", "(", "Op0IsKill", ")", ")", ".", "addReg", "(", "Op1", ",", "getKillRegState", "(", "Op1IsKill", ")", ")", ".", "addReg", "(", "Op2", ",", "getKillRegState", "(", "Op2IsKill", ")", ")", ".", "addReg", "(", "Op3", ",", "getKillRegState", "(", "Op3IsKill", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "<NUM_LIT>", "]", ")", ";", "}", "return", "ResultReg" ]

[ "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ";" ]

[ "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "RC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "abort", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";" ]

[ "(", "unsigned", "int", "_", "_", "X", ")", "{" ]

[ "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "blsi_u32" ]

[ "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "TopMBB", "->", "begin", "(", ")", ",", "E", "=", "TopMBB", "->", "end", "(", ")", ";" ]

[ "void", "PPCCTRLoops", "::", "getCanonicalInductionVariable", "(", "MachineLoop", "*", "L", ",", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "&", "IVars", ",", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "&", "IOps", ")", "const", "{", "MachineBasicBlock", "*", "TopMBB", "=", "L", "->", "getTopBlock", "(", ")", ";", "MachineBasicBlock", "::", "pred_iterator", "PI", "=", "TopMBB", "->", "pred_begin", "(", ")", ";", "assert", "(", "PI", "!=", "TopMBB", "->", "pred_end", "(", ")", "&&", "<STR_LIT>", "Loop must have more than one incoming edge!", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "Backedge", "=", "*", "PI", "++", ";", "if", "(", "PI", "==", "TopMBB", "->", "pred_end", "(", ")", ")", "return", ";", "MachineBasicBlock", "*", "Incoming", "=", "*", "PI", "++", ";", "if", "(", "PI", "!=", "TopMBB", "->", "pred_end", "(", ")", ")", "return", ";", "if", "(", "L", "->", "contains", "(", "Incoming", ")", ")", "{", "if", "(", "L", "->", "contains", "(", "Backedge", ")", ")", "return", ";", "std", "::", "swap", "(", "Incoming", ",", "Backedge", ")", ";", "}", "else", "if", "(", "!", "L", "->", "contains", "(", "Backedge", ")", ")", "return", ";" ]

[ "return", "x", ";" ]

[ "rtx", "function_expander", "::", "convert_to_pmode", "(", "rtx", "x", ")", "{", "if", "(", "ptr_mode", "==", "SImode", ")", "x", "=", "simplify_gen_unary", "(", "ZERO_EXTEND", ",", "DImode", ",", "x", ",", "SImode", ")", ";" ]

[ ")" ]

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

[ "<FIXS>", "bit", "Commutable", "=", "<NUM_LIT>", ">", "{", "<FIXE>" ]

[ "multiclass", "NeonI_3VSame_HS_sizes", "bit", "u", ",", "bits", "<NUM_LIT>", ">", "opcode", ",", "string", "asmop", ",", "SDPatternOperator", "opnode", ",", "<BUGS>", "bit", "Commutable", "=", "<NUM_LIT>", ">", "{", "<BUGE>", "let", "isCommutable", "=", "Commutable", "in", "{", "def", "_4H", ":", "NeonI_3VSame", "<NUM_LIT>", ",", "u", ",", "<NUM_LIT>", ",", "opcode", ",", "(", "outs", "VPR64", ":", "$", "Rd", ")", ",", "(", "ins", "VPR64", ":", "$", "Rn", ",", "VPR64", ":", "$", "Rm", ")", "," ]

[ "<FIXS>", "if", "(", "auto", "MemModel", "=", "M", ".", "getNamedMetadata", "(", "<STR_LIT>", "spirv.MemoryModel", "<STR_LIT>", ")", ")", "{", "auto", "MemMD", "=", "MemModel", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MAI", ".", "Addr", "=", "static_cast", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "getMetadataUInt", "(", "MemMD", ",", "<NUM_LIT>", ")", ")", ";", "MAI", ".", "Mem", "=", "static_cast", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "getMetadataUInt", "(", "MemMD", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "MAI", ".", "Mem", "=", "<STR_LIT>", "::", "<STR_LIT>", "::", "OpenCL", ";", "unsigned", "PtrSize", "=", "ST", "->", "getPointerSize", "(", ")", ";", "MAI", ".", "Addr", "=", "PtrSize", "==", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", "::", "Physical32", ":", "PtrSize", "==", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", "::", "Physical64", ":", "<STR_LIT>", "::", "<STR_LIT>", "::", "Logical", ";", "}", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "MAI", ".", "SrcLang", "=", "<STR_LIT>", "::", "<STR_LIT>", "::", "OpenCL_C", ";", "assert", "(", "VerNode", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid SPIR", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "MAI", ".", "SrcLangVersion", "=", "(", "MajorNum", "*", "<NUM_LIT>", "+", "MinorNum", ")", "*", "<NUM_LIT>", "+", "RevNum", ";", "}", "else", "{", "MAI", ".", "SrcLang", "=", "<STR_LIT>", "::", "<STR_LIT>", "::", "Unknown", ";", "MAI", ".", "SrcLangVersion", "=", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "if", "(", "auto", "ExtNode", "=", "M", ".", "getNamedMetadata", "(", "<STR_LIT>", "opencl.used.extensions", "<STR_LIT>", ")", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "ExtNode", "->", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MDNode", "*", "MD", "=", "ExtNode", "->", "getOperand", "(", "I", ")", ";", "if", "(", "!", "MD", "||", "MD", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", "continue", ";", "for", "(", "unsigned", "J", "=", "<NUM_LIT>", ",", "N", "=", "MD", "->", "getNumOperands", "(", ")", ";", "J", "!=", "N", ";", "++", "J", ")", "MAI", ".", "SrcExt", ".", "insert", "(", "cast", "MDString", ">", "(", "MD", "->", "getOperand", "(", "J", ")", ")", "->", "getString", "(", ")", ")", ";", "<FIXE>", "<FIXS>", "MAI", ".", "ExtInstSetMap", "[", "static_cast", "unsigned", ">", "(", "<STR_LIT>", "::", "<STR_LIT>", "::", "OpenCL_std", ")", "]", "=", "Register", "::", "index2VirtReg", "(", "MAI", ".", "getNextID", "(", ")", ")", ";", "<FIXE>" ]

[ "MAI", ".", "InstrsToDelete", ".", "clear", "(", ")", ";", "MAI", ".", "FuncNameMap", ".", "clear", "(", ")", ";", "MAI", ".", "GlobalVarList", ".", "clear", "(", ")", ";", "<BUGS>", "MAI", ".", "Mem", "=", "<STR_LIT>", "::", "<STR_LIT>", "::", "OpenCL", ";", "MAI", ".", "SrcLang", "=", "<STR_LIT>", "::", "<STR_LIT>", "::", "OpenCL_C", ";", "unsigned", "PtrSize", "=", "ST", "->", "getPointerSize", "(", ")", ";", "MAI", ".", "Addr", "=", "PtrSize", "==", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", "::", "Physical32", ":", "PtrSize", "==", "<NUM_LIT>", "?", "<STR_LIT>", "::", "<STR_LIT>", "::", "Physical64", ":", "<STR_LIT>", "::", "<STR_LIT>", "::", "Logical", ";", "<BUGE>", "<BUGS>", "MAI", ".", "SrcLangVersion", "=", "<NUM_LIT>", ";", "<BUGE>", "if", "(", "auto", "VerNode", "=", "M", ".", "getNamedMetadata", "(", "<STR_LIT>", "opencl.ocl.version", "<STR_LIT>", ")", ")", "{", "<BUGS>", "<BUGE>", "auto", "VersionMD", "=", "VerNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "MajorNum", "=", "getMetadataUInt", "(", "VersionMD", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "MinorNum", "=", "getMetadataUInt", "(", "VersionMD", ",", "<NUM_LIT>", ")", ";", "unsigned", "RevNum", "=", "getMetadataUInt", "(", "VersionMD", ",", "<NUM_LIT>", ")", ";", "<BUGS>", "MAI", ".", "SrcLangVersion", "=", "<NUM_LIT>", "|", "(", "MajorNum", "<<", "<NUM_LIT>", ")", "|", "(", "MinorNum", "<<", "<NUM_LIT>", ")", "|", "RevNum", ";", "<BUGE>", "}", "<BUGS>", "}", "static", "bool", "findSameInstrInMS", "(", "const", "MachineInstr", "&", "A", ",", "<STR_LIT>", "::", "<STR_LIT>", "MSType", ",", "<STR_LIT>", "::", "<STR_LIT>", "&", "MAI", ",", "bool", "UpdateRegAliases", ",", "unsigned", "StartOpIndex", "=", "<NUM_LIT>", ")", "{", "for", "(", "const", "auto", "*", "B", ":", "MAI", ".", "MS", "[", "MSType", "]", ")", "{", "const", "unsigned", "NumAOps", "=", "A", ".", "getNumOperands", "(", ")", ";", "if", "(", "NumAOps", "==", "B", "->", "getNumOperands", "(", ")", "&&", "A", ".", "getNumDefs", "(", ")", "==", "B", "->", "getNumDefs", "(", ")", ")", "{", "bool", "AllOpsMatch", "=", "true", ";", "for", "(", "unsigned", "i", "=", "StartOpIndex", ";", "i", "NumAOps", "&&", "AllOpsMatch", ";", "++", "i", ")", "{", "if", "(", "A", ".", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", "&&", "B", "->", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "{", "Register", "RegA", "=", "A", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "Register", "RegB", "=", "B", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "AllOpsMatch", "=", "MAI", ".", "getRegisterAlias", "(", "A", ".", "getMF", "(", ")", ",", "RegA", ")", "==", "MAI", ".", "getRegisterAlias", "(", "B", "->", "getMF", "(", ")", ",", "RegB", ")", ";", "}", "else", "{", "AllOpsMatch", "=", "A", ".", "getOperand", "(", "i", ")", ".", "isIdenticalTo", "(", "B", "->", "getOperand", "(", "i", ")", ")", ";", "}", "}", "if", "(", "AllOpsMatch", ")", "{", "if", "(", "UpdateRegAliases", ")", "{", "assert", "(", "A", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "B", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", ";", "Register", "LocalReg", "=", "A", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "GlobalReg", "=", "MAI", ".", "getRegisterAlias", "(", "B", "->", "getMF", "(", ")", ",", "B", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "MAI", ".", "setRegisterAlias", "(", "A", ".", "getMF", "(", ")", ",", "LocalReg", ",", "GlobalReg", ")", ";", "}", "return", "true", ";", "}", "<BUGE>", "}", "}", "<BUGS>", "return", "false", ";", "<BUGE>", "}" ]

[ "}" ]

[ "vqrshlb_s8", "(", "int8_t", "_", "_", "a", ",", "int8_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_aarch64_sqrshlqi", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "_", "v4si", ")", "_", "_", "Y", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_hadd_epi32", "(", "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_phaddd128", "(", "(", "_", "_", "v4si", ")", "_", "_", "X", ",", "(", "_" ]

[ "asm", ",", "OpNode", ">", "{" ]

[ "def", "Wr", ":", "BaseAddSubCarry", "<", "isSub", ",", "GPR32", "," ]

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

[ "def", "J4_cmpgti_t_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bd8382d1", ",", "TypeNCJ", ">", ",", "Enc_eafd18", ",", "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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated" ]

[ "case", "ISD", "::", "FMAXNAN", ":" ]

[ "case", "ISD", "::", "FP_EXTEND", ":", "return", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "!=", "MVT", "::", "f16", "||", "ST", "->", "hasFP16Denormals", "(", ")", ";", "case", "ISD", "::", "FP16_TO_FP", ":", "case", "ISD", "::", "FP_TO_FP16", ":", "return", "ST", "->", "hasFP16Denormals", "(", ")", ";", "case", "ISD", "::", "FNEG", ":", "case", "ISD", "::", "FABS", ":", "return", "(", "MaxDepth", ">", "<NUM_LIT>", ")", "&&", "isCanonicalized", "(", "DAG", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "ST", ",", "MaxDepth", "-", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "case", "ISD", "::", "FSINCOS", ":", "return", "Op", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "!=", "MVT", "::", "f16", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "case", "ISD", "::", "FMINNAN", ":" ]

[ "}", "]", ">", ">", "{", "let", "ParserMatchClass", "=", "SIMDImmType10Operand", ";" ]

[ "}", "]", ",", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "InVal", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "uint32_t", "enc", "=", "ARM64_AM", ":", ":", "encodeAdvSIMDModImmType10", "(", "N", "-", ">", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "MVT", ":", ":", "i32", ")", ";" ]

[ "return", "nullptr", ";" ]

[ "static", "const", "Function", "*", "getCalleeFunction", "(", "const", "MachineOperand", "&", "Op", ")", "{", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "assert", "(", "Op", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", ";" ]

[ ";" ]

[ "tree", "arg", "=", "m_args", "[", "argno", "]", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", ")", "{", "report_non_ice", "(", "location", ",", "fndecl", ",", "argno", ")", ";", "return", "false", ";", "}", "value_out", "=", "tree_to_uhwi", "(", "arg", ")", ";", "return", "true" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "VCVTTSS2SI64rr", "GR64", ":", "$", "dst", ",", "FR32", ":", "$", "src" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ":", "$", "addr", ",", "i32imm", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "AddrMode6AsmOperand", ";" ]

[ "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AS", ")", "{", "case", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ":", "{", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "}", "case", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ":", "{", "if", "(", "AM", ".", "BaseOffs", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "DL", ".", "getTypeStoreSize", "(", "Ty", ")", "<", "<NUM_LIT>", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AM", ".", "BaseOffs", "/", "<NUM_LIT>", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AM", ".", "BaseOffs", "/", "<NUM_LIT>", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "unhandled generation", "<STR_LIT>", ")", ";", "if", "(", "AM", ".", "Scale", "==", "<NUM_LIT>", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "<NUM_LIT>", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "REGION_ADDRESS", ":", "{", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "<NUM_LIT>", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "<NUM_LIT>", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "FLAT_ADDRESS", ":", "case", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ":", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unhandled address space", "<STR_LIT>", ")", ";", "}", "}" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "<FIXS>", "(", "unspec", ":", "V2DI", "[", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "unspec", ":", "V2DI", "[", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", "UNSPEC_VSX_CVSPUXDS", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "OpsVT", ",", "MulLo", ",", "MulHi", ")", ";" ]

[ "if", "(", "Mode", "==", "MULU8", "||", "Mode", "==", "MULS8", ")", "{", "return", "DAG", ".", "getNode", "(", "(", "Mode", "==", "MULU8", ")", "?", "ISD", "::", "ZERO_EXTEND", ":", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VT", ",", "MulLo", ")", ";", "}", "else", "{", "MVT", "ResVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i32", ",", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ")", ";", "SDValue", "MulHi", "=", "DAG", ".", "getNode", "(", "Mode", "==", "MULS16", "?", "ISD", "::", "MULHS", ":", "ISD", "::", "MULHU", ",", "DL", ",", "ReducedVT", ",", "NewN0", ",", "NewN1", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleMask", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ";", "i", "++", ")", "{", "ShuffleMask", "[", "<NUM_LIT>", "*", "i", "]", "=", "i", ";", "ShuffleMask", "[", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", "]", "=", "i", "+", "VT", ".", "getVectorNumElements", "(", ")", ";", "}", "SDValue", "ResLo", "=", "DAG", ".", "getVectorShuffle", "(", "ReducedVT", ",", "DL", ",", "MulLo", ",", "MulHi", ",", "ShuffleMask", ")", ";", "ResLo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "ResVT", ",", "ResLo", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ";", "i", "++", ")", "{", "ShuffleMask", "[", "<NUM_LIT>", "*", "i", "]", "=", "i", "+", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ";", "ShuffleMask", "[", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", "]", "=", "i", "+", "VT", ".", "getVectorNumElements", "(", ")", "*", "<NUM_LIT>", "/", "<NUM_LIT>", ";", "}", "SDValue", "ResHi", "=", "DAG", ".", "getVectorShuffle", "(", "ReducedVT", ",", "DL", ",", "MulLo", ",", "MulHi", ",", "ShuffleMask", ")", ";", "ResHi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "ResVT", ",", "ResHi", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "DL", ",", "VT", ",", "ResLo", ",", "ResHi", ")", ";", "}", "}", "else", "{", "unsigned", "ReducedSizeInBits", "=", "ReducedVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "(", "RegSize", "%", "ReducedSizeInBits", ")", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", "(", "RegSize", "/", "ReducedSizeInBits", ",", "DAG", ".", "getUNDEF", "(", "ReducedVT", ")", ")", ";", "Ops", "[", "<NUM_LIT>", "]", "=", "NewN0", ";", "NewN0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "DL", ",", "OpsVT", ",", "Ops", ")", ";", "Ops", "[", "<NUM_LIT>", "]", "=", "NewN1", ";", "NewN1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "DL", ",", "OpsVT", ",", "Ops", ")", ";", "if", "(", "Mode", "==", "MULU8", "||", "Mode", "==", "MULS8", ")", "{", "SDValue", "Mul", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "DL", ",", "OpsVT", ",", "NewN0", ",", "NewN1", ")", ";", "MVT", "ResVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i32", ",", "RegSize", "/", "<NUM_LIT>", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "Mode", "==", "MULU8", "?", "ISD", "::", "ZERO_EXTEND_VECTOR_INREG", ":", "ISD", "::", "SIGN_EXTEND_VECTOR_INREG", ",", "DL", ",", "ResVT", ",", "Mul", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "VT", ",", "Res", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ")", ";", "}", "else", "{", "SDValue", "MulLo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MUL", ",", "DL", ",", "OpsVT", ",", "NewN0", ",", "NewN1", ")", ";", "SDValue", "MulHi", "=", "DAG", ".", "getNode", "(", "Mode", "==", "MULS16", "?", "ISD", "::", "MULHS", ":", "ISD", "::", "MULHU", ",", "DL", ",", "OpsVT", ",", "NewN0", ",", "NewN1", ")", ";", "MVT", "ResVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i32", ",", "RegSize", "/", "<NUM_LIT>", ")", ";" ]

[ "static", "void", "remove_useless_addtr_insns", "(", "int", "check_notes", ")", "{", "rtx_insn", "*", "insn", ";", "static", "int", "pass", "=", "<NUM_LIT>", ";", "if", "(", "optimize", ">", "<NUM_LIT>", ")", "{", "int", "fcmp_count", "=", "<NUM_LIT>", ";", "int", "fbranch_count", "=", "<NUM_LIT>", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next_insn", "(", "insn", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "!", "JUMP_P", "(", "insn", ")", ")", "continue", ";", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "!=", "SET", ")", "continue", ";", "tmp", "=", "SET_DEST", "(", "tmp", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "REG", "&&", "REGNO", "(", "tmp", ")", "==", "<NUM_LIT>", ")", "{", "fcmp_count", "++", ";", "continue", ";", "}", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "==", "SET", "&&", "SET_DEST", "(", "tmp", ")", "==", "pc_rtx", "&&", "GET_CODE", "(", "SET_SRC", "(", "tmp", ")", ")", "==", "IF_THEN_ELSE", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "tmp", ")", ",", "<NUM_LIT>", ")", ")", "==", "NE", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "tmp", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "tmp", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", "{", "fbranch_count", "++", ";", "continue", ";", "}", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next_insn", "(", "insn", ")", ")", "{", "rtx", "tmp", ";", "rtx_insn", "*", "next", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "!=", "SET", ")", "continue", ";", "tmp", "=", "SET_DEST", "(", "tmp", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "!=", "REG", "||", "REGNO", "(", "tmp", ")", "!=", "<NUM_LIT>", ")", "continue", ";", "next", "=", "next_insn", "(", "insn", ")", ";", "while", "(", "next", ")", "{", "if", "(", "JUMP_P", "(", "next", ")", "||", "CALL_P", "(", "next", ")", "||", "LABEL_P", "(", "next", ")", ")", "break", ";", "if", "(", "NONJUMP_INSN_P", "(", "next", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "PATTERN", "(", "next", ")", ")", ")", "==", "REG", "&&", "REGNO", "(", "SET_DEST", "(", "PATTERN", "(", "next", ")", ")", ")", "==", "<NUM_LIT>", ")", "break", ";", "next", "=", "next_insn", "(", "next", ")", ";", "}", "if", "(", "next", "&&", "JUMP_P", "(", "next", ")", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", "&&", "SET_DEST", "(", "pattern", ")", "==", "pc_rtx", "&&", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "IF_THEN_ELSE", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ")", "==", "NE", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ")", "==", "PC", "&&", "(", "fcmp_count", "==", "fbranch_count", "||", "(", "check_notes", "&&", "find_regno_note", "(", "next", ",", "REG_DEAD", ",", "<NUM_LIT>", ")", ")", ")", ")", "{", "tmp", "=", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ";", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", "=", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ";", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", "=", "tmp", ";", "INSN_CODE", "(", "next", ")", "=", "-", "<NUM_LIT>", ";", "tmp", "=", "PATTERN", "(", "insn", ")", ";", "PUT_CODE", "(", "XEXP", "(", "tmp", ",", "<NUM_LIT>", ")", ",", "(", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "XEXP", "(", "tmp", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", ";", "}", "}", "}", "}", "pass", "=", "!", "pass", ";", "}" ]

[ "Try", "to", "rewrite", "floating", "point", "comparisons", "&", "branches", "to", "avoid", "useless", "add", ",", "tr", "insns", ".", "CHECK_NOTES", "is", "nonzero", "if", "we", "should", "examine", "REG_DEAD", "notes", "to", "see", "if", "FPCC", "is", "dead", ".", "CHECK_NOTES", "is", "nonzero", "for", "the", "first", "attempt", "to", "remove", "useless", "add", ",", "tr", "insns", ".", "It", "is", "zero", "for", "the", "second", "pass", "as", "reorg", "sometimes", "leaves", "bogus", "REG_DEAD", "notes", "lying", "around", ".", "When", "CHECK_NOTES", "is", "zero", "we", "can", "only", "eliminate", "add", ",", "tr", "insns", "when", "there", "'s", "a", "1:1", "correspondence", "between", "fcmp", "and", "ftest/fbranch", "instructions", "." ]

[ "<FIXS>", "_", ".", "info128", ".", "ImmAllZerosV", ")", ")", ",", "<FIXE>" ]

[ "def", ":", "Pat", "(", "_", ".", "info128", ".", "VT", "(", "masked_load", "addr", ":", "$", "srcAddr", ",", "Mask128", ",", "<BUGS>", "(", "_", ".", "info128", ".", "VT", "(", "bitconvert", "(", "v4i32", "immAllZerosV", ")", ")", ")", ")", ")", ",", "<BUGE>", "(", "!", "cast", "Instruction", ">", "(", "InstrStr", "#", "rmkz", ")", "(", "COPY_TO_REGCLASS", "(", "i32", "(", "INSERT_SUBREG", "(", "IMPLICIT_DEF", ")", ",", "MaskRC", ":", "$", "mask", ",", "subreg", ")", ")", ",", "VK1WM", ")", ",", "addr", ":", "$", "srcAddr", ")", ">", ";" ]

[ "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "this", ",", "Slot", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyInterpSlot", ")", ")", ";" ]

[ "if", "(", "Slot", "==", "-", "<NUM_LIT>", ")", "{", "Error", "(", "S", ",", "<STR_LIT>", "invalid interpolation slot", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}" ]

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

[ "(", "set", "(", "match_operand", ":", "VSX_F", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "gt", ":", "VSX_F", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "<FIXS>", "ia64_function_arg", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "<FIXE>" ]

[ "static", "rtx", "<BUGS>", "ia64_function_arg", "(", "cumulative_args_t", "cum", ",", "enum", "machine_mode", "mode", ",", "<BUGE>", "const_tree", "type", ",", "bool", "named", ")", "{", "return", "ia64_function_arg_1", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "false", ")", ";" ]

[ "const", "{" ]

[ "bool", "isKImmFP32", "(", ")" ]

[ "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "class", "MVEIntSingleSrc", "<", "string", "iname", ",", "string", "suffix", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_p", "<", "(", "outs", "MQPR", ":", "$", "Qd", ")", ",", "(", "ins", "MQPR", ":", "$", "Qm", ")", ",", "NoItinerary", ",", "iname", ",", "suffix", ",", "<STR_LIT>", ",", "vpred_r", ",", "<STR_LIT>", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Qd", ";", "bits", "<", "<NUM_LIT>", ">", "Qm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qm" ]

[ "}" ]

[ "break", ";", "}", "SDValue", "StackPtr", "=", "DAG", ".", "CreateStackTemporary", "(", "MVT", "::", "f64", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "Val", ",", "StackPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "Store", ",", "StackPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "StackPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "StackPtr", ".", "getValueType", "(", ")", ",", "StackPtr", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "Store", ",", "StackPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "RegsToPass", ".", "size", "(", ")", "]", ",", "Hi", ")", ")", ";", "if", "(", "RegsToPass", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "ValToStore", "=", "Lo", ";", "ArgOffset", "+=", "<NUM_LIT>", ";", "ObjSize", "=", "<NUM_LIT>", ";", "}", "else", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "RegsToPass", ".", "size", "(", ")", "]", ",", "Lo", ")", ")", ";", "}", "break", ";", "}", "case", "MVT", "::", "i64", ":", "{", "ObjSize", "=", "<NUM_LIT>", ";", "if", "(", "RegsToPass", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "ValToStore", "=", "Val", ";", "break", ";", "}", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "Val", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "i32", ",", "Val", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "RegsToPass", ".", "size", "(", ")", "]", ",", "Hi", ")", ")", ";", "if", "(", "RegsToPass", ".", "size", "(", ")", ">=", "<NUM_LIT>", ")", "{", "ValToStore", "=", "Lo", ";", "ArgOffset", "+=", "<NUM_LIT>", ";", "ObjSize", "=", "<NUM_LIT>", ";", "}", "else", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "ArgRegs", "[", "RegsToPass", ".", "size", "(", ")", "]", ",", "Lo", ")", ")", ";", "}", "break", ";", "}", "}", "if", "(", "ValToStore", ".", "getNode", "(", ")", ")", "{", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getConstant", "(", "ArgOffset", ",", "MVT", "::", "i32", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "ValToStore", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "ArgOffset", "+=", "ObjSize", ";", "}", "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", ")", "{", "unsigned", "Reg", "=", "RegsToPass", "[", "i", "]", ".", "first", ";", "if", "(", "Reg", ">=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Reg", "<=", "<STR_LIT>", "::", "<STR_LIT>", ")", "Reg", "=", "Reg", "-", "<STR_LIT>", "::", "<STR_LIT>", "+", "<STR_LIT>", "::", "<STR_LIT>", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "G", "->", "getGlobal", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "else", "if", "(", "ExternalSymbolSDNode", "*", "E", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "E", "->", "getSymbol", "(", ")", ",", "MVT", "::", "i32", ")", ";", "std", "::", "vector", "<", "EVT", ">", "NodeTys", ";", "NodeTys", ".", "push_back", "(", "MVT", "::", "Other", ")", ";", "NodeTys", ".", "push_back", "(", "MVT", "::", "Flag", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "Callee", ",", "InFlag", "}", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "NodeTys", ",", "Ops", ",", "InFlag", ".", "getNode", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "ArgsSize", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "true", ")", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "RVInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RVInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Sparc32", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ";", "if", "(", "Reg", ">=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Reg", "<=", "<STR_LIT>", "::", "<STR_LIT>", ")", "Reg", "=", "Reg", "-", "<STR_LIT>", "::", "<STR_LIT>", "+", "<STR_LIT>", "::", "<STR_LIT>", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "return", "Chain", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_slli_epi32", "(", "_", "_", "m256i", "_", "_", "A", ",", "int", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_pslldi256", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "_", "_", "B", ")", ";" ]

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

[ "def", "WAIT", ":", "WAIT_FT", "<" ]

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

[ "virtual", "bool", "addPreEmitPass", "(", ")", "{", "if", "(", "!", "getPatmosSubtarget", "(", ")", ".", "usePatmosPostRAScheduler", "(", "getOptLevel", "(", ")", ")", ")", "{", "addPass", "(", "createPatmosDelaySlotFillerPass", "(", "getPatmosTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ")", ";", "}", "if", "(", "getPatmosSubtarget", "(", ")", ".", "hasMethodCache", "(" ]

[ "if", "(", "CachedConsts", ".", "empty", "(", ")", ")", "{" ]

[ "}", "if", "(", "CachedConsts", "[", "<NUM_LIT>", "]", "==", "BankLine", ")", "{", "UsedKCache", ".", "push_back", "(", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "(", "<NUM_LIT>", ",", "KCacheIndex", ")", ")", ";", "continue", ";", "}", "return", "false", ";", "}", "if", "(", "!", "UpdateInstr", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "j", "=", "<NUM_LIT>", ",", "n", "=", "Consts", ".", "size", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "if", "(", "Consts", "[", "i", "]", ".", "first", "->", "getReg", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "switch", "(", "UsedKCache", "[", "j", "]", ".", "first", ")", "{", "case", "<NUM_LIT>", ":", "Consts", "[", "i", "]", ".", "first", "->", "setReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "getRegister", "(", "UsedKCache", "[", "j", "]", ".", "second", ")", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "Consts", "[", "i", "]", ".", "first", "->", "setReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "getRegister", "(", "UsedKCache", "[", "j", "]", ".", "second", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Wrong Cache Line", "<STR_LIT>", ")", ";", "}", "j", "++", ";", "}", "return", "true", ";", "}", "bool", "SubstituteKCacheBank", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">>", "&", "CachedConsts", ",", "bool", "UpdateInstr", "=", "true", ")", "const", "{", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">>", "UsedKCache", ";", "if", "(", "!", "TII", "->", "isALUInstr", "(", "MI", ".", "getOpcode", "(", ")", ")", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "true", ";", "const", "SmallVectorImpl", "<", "std", "::", "pair", "<", "MachineOperand", "*", ",", "int64_t", ">>", "&", "Consts", "=", "TII", "->", "getSrcs", "(", "MI", ")", ";", "assert", "(", "(", "TII", "->", "isALUInstr", "(", "MI", ".", "getOpcode", "(", ")", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "<STR_LIT>", "Can't assign Const", "<STR_LIT>", ")", ";", "for", "(", "auto", "&", "[", "Op", ",", "Sel", "]", ":", "Consts", ")", "{", "if", "(", "Op", "->", "getReg", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "unsigned", "Chan", "=", "Sel", "&", "<NUM_LIT>", ",", "Index", "=", "(", "(", "Sel", ">>", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "unsigned", "KCacheIndex", "=", "Index", "*", "<NUM_LIT>", "+", "Chan", ";", "const", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "&", "BankLine", "=", "getAccessedBankLine", "(", "Sel", ")", ";" ]

[ "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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";" ]

[ "class", "T1sIGenEncode", "<", "bits", "<", "<NUM_LIT>", ">", "opA", ",", "dag", "oops", ",", "dag", "iops", ",", "InstrItinClass", "itin", ",", "string", "opc", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "T1sI", "<", "oops", ",", "iops", ",", "itin", ",", "opc", ",", "asm", ",", "pattern", ">", ",", "T1General", "<", "opA", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rd", ";" ]