Datasets:

docz1105

/

ComBack_Plus_Plus

like 0

[ "]", ")" ]

[ "(", "define_code_iterator", "eqne_cond", "[", "eq", "ne" ]

[ "artificial__", ")", ")", "_", "mm_add_ps", "(", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_" ]

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

[ "def", "A2_andir", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_140c83", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "_", "_", "ev64_opaque__", "t", ";", "t", "=", "_", "_", "ev_mwhsmi", "(", "a", ",", "b", ")", ";", "return", "_", "_", "ev_mwsmiaa", "(", "t", ",", "(", "(", "_", "_", "ev64_s32__", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ")", ";" ]

[ "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_max_pd", "(", "_" ]

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

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

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

[ "(", "ANDOR", ":", "GPR", "(", "not", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "TRI", ",", "RBI", ")", ";" ]

[ "return", "BuildMI", "(", "BB", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addDef", "(", "ResVReg", ")", ".", "addUse", "(", "GR", ".", "getSPIRVTypeID", "(", "ResType", ")", ")", ".", "constrainAllUses", "(", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "auto", "MIB", "=", "BuildMI", "(", "BB", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addDef", "(", "ResVReg", ")", ".", "addUse", "(", "GR", ".", "getSPIRVTypeID", "(", "ResType", ")", ")", ";", "assert", "(", "Imm", ".", "getBitWidth", "(", ")", ">", "<NUM_LIT>", ")", ";", "addNumImm", "(", "Imm", ",", "MIB", ")", ";", "return", "MIB", ".", "constrainAllUses", "(", "TII", "," ]

[ "NumTargetFixupKinds", "]", "=", "{" ]

[ "const", "static", "MCFixupKindInfo", "InfosBE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "<STR_LIT>", "fixup_ppc_br24", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_br24_notoc", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_brcond14", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_br24abs", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_brcond14abs", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_half16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_half16ds", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_pcrel34", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_imm34", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_nofixup", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ";", "const", "static", "MCFixupKindInfo", "InfosLE", "[", "PPC", "::" ]

[ "g", "=", "gimple_build_assign", "(", "lhs", ",", "BIT_NOT_EXPR", ",", "temp", ")", ";" ]

[ "case", "P8V_BUILTIN_VADDUDM", ":", "case", "ALTIVEC_BUILTIN_VADDFP", ":", "case", "VSX_BUILTIN_XVADDDP", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "PLUS_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "ALTIVEC_BUILTIN_VSUBUBM", ":", "case", "ALTIVEC_BUILTIN_VSUBUHM", ":", "case", "ALTIVEC_BUILTIN_VSUBUWM", ":", "case", "P8V_BUILTIN_VSUBUDM", ":", "case", "ALTIVEC_BUILTIN_VSUBFP", ":", "case", "VSX_BUILTIN_XVSUBDP", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "MINUS_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "VSX_BUILTIN_XVMULSP", ":", "case", "VSX_BUILTIN_XVMULDP", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "MULT_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "ALTIVEC_BUILTIN_VMULESB", ":", "case", "ALTIVEC_BUILTIN_VMULESH", ":", "case", "ALTIVEC_BUILTIN_VMULEUB", ":", "case", "ALTIVEC_BUILTIN_VMULEUH", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "VEC_WIDEN_MULT_EVEN_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "ALTIVEC_BUILTIN_VMULOSB", ":", "case", "ALTIVEC_BUILTIN_VMULOSH", ":", "case", "ALTIVEC_BUILTIN_VMULOUB", ":", "case", "ALTIVEC_BUILTIN_VMULOUH", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "VEC_WIDEN_MULT_ODD_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "VSX_BUILTIN_DIV_V2DI", ":", "case", "VSX_BUILTIN_UDIV_V2DI", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "TRUNC_DIV_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "VSX_BUILTIN_XVDIVSP", ":", "case", "VSX_BUILTIN_XVDIVDP", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "RDIV_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "ALTIVEC_BUILTIN_VAND", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "BIT_AND_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "ALTIVEC_BUILTIN_VANDC", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "temp", "=", "create_tmp_reg_or_ssa_name", "(", "TREE_TYPE", "(", "arg1", ")", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "temp", ",", "BIT_NOT_EXPR", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_insert_before", "(", "gsi", ",", "g", ",", "GSI_SAME_STMT", ")", ";", "g", "=", "gimple_build_assign", "(", "lhs", ",", "BIT_AND_EXPR", ",", "arg0", ",", "temp", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "return", "true", ";", "}", "case", "P8V_BUILTIN_VEC_NAND", ":", "case", "P8V_BUILTIN_NAND_V16QI", ":", "case", "P8V_BUILTIN_NAND_V8HI", ":", "case", "P8V_BUILTIN_NAND_V4SI", ":", "case", "P8V_BUILTIN_NAND_V4SF", ":", "case", "P8V_BUILTIN_NAND_V2DF", ":", "case", "P8V_BUILTIN_NAND_V2DI", ":", "{", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "<NUM_LIT>", ")", ";", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "temp", "=", "create_tmp_reg_or_ssa_name", "(", "TREE_TYPE", "(", "arg1", ")", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "temp", ",", "BIT_AND_EXPR", ",", "arg0", ",", "arg1", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_insert_before", "(", "gsi", ",", "g", ",", "GSI_SAME_STMT", ")", ";" ]

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

[ "def", "SDT_PPCstfiwx", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<", "<NUM_LIT>", ",", "f64", ">", ",", "SDTCisPtrTy", "<" ]

[ "_", "_", "m", ",", "int", "_", "_", "count", ")", "{" ]

[ "static", "_", "_", "inline", "_", "_", "m64", "_", "mm_slli_pi16", "(", "_", "_", "m64" ]

[ "(", "_", "_", "v8si", ")", "_", "_", "A", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_si512_256si", "(" ]

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

[ "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "udiv", ":", "SI", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "umod", ":", "SI", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "HI" ]

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

[ "let", "isReMaterializable", "=", "<NUM_LIT>", ";", "let", "isAsCheapAsAMove", "=", "<NUM_LIT>", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "sf", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "C", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";", "let", "Predicates", "=", "[", "HasCRC", "]", ";" ]

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

[ "class", "BaseLogicalSReg", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bit", "N", ",", "RegisterClass", "regtype", ",", "logical_shifted_reg", "shifted_regtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "shifted_regtype", ":", "$", "Rm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteISReg", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "SDNode", "*", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";" ]

[ "static", "bool", "isAddSubZExt", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "{", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ISD", "::", "ADD", "||", "Opcode", "==", "ISD", "::", "SUB", ")", "{", "SDNode", "*", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";" ]

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

[ "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MinOp", ";" ]

[ "<FIXS>", "let", "isStore", "=", "<NUM_LIT>", ",", "noResults", "=", "<NUM_LIT>", "in", "{", "<FIXE>" ]

[ "<STR_LIT>", ",", "LdStLD", ",", "[", "]", ">", ",", "isPPC64", ";", "}", "<BUGS>", "let", "isStore", "=", "<NUM_LIT>", "in", "{", "<BUGE>", "def", "STD", ":", "DSForm_2", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "ops", "GPRC", ":", "$", "rT", ",", "s16immX4", ":", "$", "DS", ",", "GPRC", ":", "$", "rA", ")", ",", "<STR_LIT>", ",", "LdStSTD", ",", "[", "]", ">", ",", "isPPC64", ";" ]

[ "OPTAB_DIRECT", ")", ";" ]

[ "void", "ia64_expand_widen_sum", "(", "rtx", "operands", "[", "<NUM_LIT>", "]", ",", "bool", "unsignedp", ")", "{", "machine_mode", "wmode", ";", "rtx", "l", ",", "h", ",", "t", ",", "sign", ";", "sign", "=", "ia64_unpack_sign", "(", "operands", "[", "<NUM_LIT>", "]", ",", "unsignedp", ")", ";", "wmode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "l", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "h", "=", "gen_reg_rtx", "(", "wmode", ")", ";", "ia64_unpack_assemble", "(", "l", ",", "operands", "[", "<NUM_LIT>", "]", ",", "sign", ",", "false", ")", ";", "ia64_unpack_assemble", "(", "h", ",", "operands", "[", "<NUM_LIT>", "]", ",", "sign", ",", "true", ")", ";", "t", "=", "expand_binop", "(", "wmode", ",", "add_optab", ",", "l", ",", "operands", "[", "<NUM_LIT>", "]", ",", "NULL", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "t", "=", "expand_binop", "(", "wmode", ",", "add_optab", ",", "h", ",", "t", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", "," ]

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

[ "(", "zero_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CCX", "<NUM_LIT>", ")" ]

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

[ "unsigned", "Datasize", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "ShifterVal", "=", "(", "Imm", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "unsigned", "ImmVal", "=", "Imm", "&", "<NUM_LIT>", ";", "if", "(", "ShifterVal", "!=", "<NUM_LIT>", "&&", "ShifterVal", "!=", "<NUM_LIT>", ")", "return", "Fail", ";", "if", "(", "Datasize", ")", "{", "if", "(", "Rd", "==", "<NUM_LIT>", "&&", "!", "S", ")", "DecodeGPR64spRegisterClass", "(", "Inst", ",", "Rd", ",", "Addr", ",", "Decoder", ")", ";", "else", "DecodeGPR64RegisterClass", "(", "Inst", ",", "Rd", ",", "Addr", ",", "Decoder", ")", ";", "DecodeGPR64spRegisterClass", "(", "Inst", ",", "Rn", ",", "Addr", ",", "Decoder", ")", ";", "}", "else", "{", "if", "(", "Rd", "==", "<NUM_LIT>", "&&", "!", "S", ")", "DecodeGPR32spRegisterClass", "(", "Inst", ",", "Rd", ",", "Addr", ",", "Decoder", ")", ";", "else", "DecodeGPR32RegisterClass", "(", "Inst", ",", "Rd", ",", "Addr", ",", "Decoder", ")", ";", "DecodeGPR32spRegisterClass", "(", "Inst", ",", "Rn", ",", "Addr", ",", "Decoder", ")", ";", "}", "if", "(", "!", "Decoder", "->", "tryAddingSymbolicOperand", "(", "Inst", ",", "Imm", ",", "Addr", ",", "Fail", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "ImmVal", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", "*", "ShifterVal" ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p1", "-", "isa", "(", "SLOTS", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpmadla1u_w", "<STR_LIT>", ")", "(", "CPTYPE", "V2USI", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "<NUM_LIT>", "qqqqq", "ppppp", "<NUM_LIT>", "cpmadla1u", ".", "w", "crqp", ",", "crpp", "(", "p0_1", ")", "(", "dni", "cpmadla1u_w_P1", "<STR_LIT>", "cpmadla1u.w $crqp,$crpp Pn", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p1", "-", "isa", "(", "SLOTS", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpmadla1u_w", "<STR_LIT>", ")", "(", "CPTYPE", "V2USI", ")", ")", "<BUGE>", "<STR_LIT>", "cpmadla1u.w $crqp,$crpp", "<STR_LIT>", "(", "+", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u0", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u8", "#", "x1e", ")", "crqp", "crpp", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u23", "#", "x15", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u28", "<NUM_LIT>", ")", ")", "(", "sequence", "(", ")" ]

[ ";" ]

[ "static", "bool", "CanXFormVExtractWithShuffleIntoLoad", "(", "SDValue", "V", ",", "SelectionDAG", "&", "DAG", ",", "const", "TargetLowering", "&", "TLI", ")", "{", "EVT", "VT", "=", "V", ".", "getValueType", "(", ")", ";", "ShuffleVectorSDNode", "*", "SVOp", "=", "dyn_cast", "<", "ShuffleVectorSDNode", ">", "(", "V", ")", ";", "if", "(", "!", "V", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "SDNode", "*", "N", "=", "*", "V", ".", "getNode", "(", ")", "->", "use_begin", "(", ")", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "false", ";", "SDValue", "EltNo", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "EltNo", ")", ")", "return", "false", ";", "bool", "HasShuffleIntoBitcast", "=", "false" ]

[ "true", ";" ]

[ "++", "Next", ";", "Register", "SrcReg", ",", "SrcReg2", ";", "int64_t", "CmpMask", ",", "CmpValue", ";", "bool", "IsThumb1", ";", "if", "(", "Next", "!=", "MI", ".", "getParent", "(", ")", "->", "end", "(", ")", "&&", "analyzeCompare", "(", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpMask", ",", "CmpValue", ")", "&&", "isRedundantFlagInstr", "(", "&", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpValue", ",", "&", "MI", ",", "IsThumb1", ")", ")", "return", "false", ";", "return" ]

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

[ "return", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "/", "UNITS_PER_VREG", ")" ]

[ "signed", "short", ")", "a2", ")", ";" ]

[ "return", "(", "vector", "signed", "short", ")", "_", "_", "builtin_altivec_vaddshs", "(", "(", "vector", "signed", "short", ")", "a1", ",", "(", "vector" ]

[ "MI", ".", "eraseFromParent", "(", ")", ";" ]

[ "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "MO", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "continue", ";", "if", "(", "MRI", ".", "getRegClassOrNull", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MRI", ".", "setRegBank", "(", "Reg", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "for", "(", "MachineInstr", "&", "MI", ":", "make_early_inc_range", "(", "mbb_reverse", "(", "MIS", ")", ")", ")", "{", "if", "(", "isTriviallyDead", "(", "MI", ",", "MRI", ")", ")", "{" ]

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

[ "(", "minus", ":", "VWHB", "(", "match_operand", ":", "VWHB", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VWHB", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", ")", "<BUGE>" ]

[ "LHS", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "OpVT", ",", "LHS", ",", "Amt", ")", ";" ]

[ "PackMask", ".", "push_back", "(", "I", "+", "Offset", ")", ";", "PackMask", ".", "push_back", "(", "I", "+", "Offset", "+", "<NUM_LIT>", ")", ";", "PackMask", ".", "push_back", "(", "I", "+", "Offset", "+", "NumElts", ")", ";", "PackMask", ".", "push_back", "(", "I", "+", "Offset", "+", "NumElts", "+", "<NUM_LIT>", ")", ";", "}", "return", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "dl", ",", "DAG", ".", "getBitcast", "(", "VT", ",", "LHS", ")", ",", "DAG", ".", "getBitcast", "(", "VT", ",", "RHS", ")", ",", "PackMask", ")", ";", "}", "if", "(", "!", "PackHiHalf", ")", "{", "if", "(", "UsePackUS", "&&", "DAG", ".", "computeKnownBits", "(", "LHS", ")", ".", "countMaxActiveBits", "(", ")", "<=", "EltSizeInBits", "&&", "DAG", ".", "computeKnownBits", "(", "RHS", ")", ".", "countMaxActiveBits", "(", ")", "<=", "EltSizeInBits", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "LHS", ",", "RHS", ")", ";", "if", "(", "DAG", ".", "ComputeMaxSignificantBits", "(", "LHS", ")", "<=", "EltSizeInBits", "&&", "DAG", ".", "ComputeMaxSignificantBits", "(", "RHS", ")", "<=", "EltSizeInBits", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "LHS", ",", "RHS", ")", ";", "}", "SDValue", "Amt", "=", "DAG", ".", "getTargetConstant", "(", "EltSizeInBits", ",", "dl", ",", "MVT", "::", "i8", ")", ";", "if", "(", "UsePackUS", ")", "{", "if", "(", "PackHiHalf", ")", "{" ]

[ "<FIXS>", "gcc_assert", "(", "n_elt", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "n_elt", ";", "++", "i", ")", "<FIXE>", "<FIXS>", "rtx", "x", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "i", ")", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "rtvec", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "<BUGS>", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "n_elt", ";", "++", "i", ",", "arglist", "=", "TREE_CHAIN", "(", "arglist", ")", ")", "<BUGE>", "{", "<BUGS>", "rtx", "x", "=", "expand_normal", "(", "TREE_VALUE", "(", "arglist", ")", ")", ";", "<BUGE>", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_lowpart", "(", "inner_mode", ",", "x", ")", ";", "}", "<BUGS>", "gcc_assert", "(", "arglist", "==", "NULL", ")", ";", "<BUGE>", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";" ]

[ "::", "i32", ",", "false", ")", ";" ]

[ "if", "(", "RegIn", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "unsigned", "RegOut", "=", "getX86SubSuperRegister", "(", "RegIn", ",", "MVT" ]

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

[ "(", "_", "_", "v8si", ")", "_", "_", "A", ")", ";" ]

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_cvtd2mask256", "(" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "New occupancy = ", "<STR_LIT>", "<<", "NewOcc", "<<", "<STR_LIT>", ", prev occupancy = ", "<STR_LIT>", "<<", "Occ", "<<", "'", "\\n", "'", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Occupancy improvement attempt:\\n", "<STR_LIT>", ";", "printSchedRP", "(", "dbgs", "(", ")", ",", "R", "->", "MaxPressure", ",", "MaxRP", ")", ")", ";", "NewOcc", "=", "std", "::", "min", "(", "NewOcc", ",", "MaxRP", ".", "getOccupancy", "(", "ST", ")", ")", ";", "if", "(", "NewOcc", "<=", "Occ", ")", "break", ";", "setBestSchedule", "(", "*", "R", ",", "MinSchedule", ",", "MaxRP", ")", ";", "}" ]

[ "case", "Intrinsic", "::", "ppc_qpx_qvstfd", ":" ]

[ "VT", "=", "MVT", "::", "v4f64", ";", "break", ";", "case", "Intrinsic", "::", "ppc_qpx_qvlfs", ":", "VT", "=", "MVT", "::", "v4f32", ";", "break", ";", "case", "Intrinsic", "::", "ppc_qpx_qvlfcd", ":", "VT", "=", "MVT", "::", "v2f64", ";", "break", ";", "case", "Intrinsic", "::", "ppc_qpx_qvlfcs", ":", "VT", "=", "MVT", "::", "v2f32", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "-", "VT", ".", "getStoreSize", "(", ")", "+", "<NUM_LIT>", ";", "Info", ".", "size", "=", "<NUM_LIT>", "*", "VT", ".", "getStoreSize", "(", ")", "-", "<NUM_LIT>", ";", "Info", ".", "align", "=", "<NUM_LIT>", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_qpx_qvlfda", ":", "case", "Intrinsic", "::", "ppc_qpx_qvlfsa", ":", "case", "Intrinsic", "::", "ppc_qpx_qvlfcda", ":", "case", "Intrinsic", "::", "ppc_qpx_qvlfcsa", ":", "case", "Intrinsic", "::", "ppc_qpx_qvlfiwaa", ":", "case", "Intrinsic", "::", "ppc_qpx_qvlfiwza", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_qpx_qvlfda", ":", "VT", "=", "MVT", "::", "v4f64", ";", "break", ";", "case", "Intrinsic", "::", "ppc_qpx_qvlfsa", ":", "VT", "=", "MVT", "::", "v4f32", ";", "break", ";", "case", "Intrinsic", "::", "ppc_qpx_qvlfcda", ":", "VT", "=", "MVT", "::", "v2f64", ";", "break", ";", "case", "Intrinsic", "::", "ppc_qpx_qvlfcsa", ":", "VT", "=", "MVT", "::", "v2f32", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "v4i32", ";", "break", ";", "}", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "VT", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "offset", "=", "<NUM_LIT>", ";", "Info", ".", "size", "=", "VT", ".", "getStoreSize", "(", ")", ";", "Info", ".", "align", "=", "<NUM_LIT>", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "ppc_qpx_qvstfd", ":", "case", "Intrinsic", "::", "ppc_qpx_qvstfs", ":", "case", "Intrinsic", "::", "ppc_qpx_qvstfcd", ":", "case", "Intrinsic", "::", "ppc_qpx_qvstfcs", ":", "case", "Intrinsic", "::", "ppc_qpx_qvstfiw", ":", "case", "Intrinsic", "::", "ppc_altivec_stvx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvxl", ":", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x", ":", "case", "Intrinsic", "::", "ppc_vsx_stxvw4x", ":", "{", "EVT", "VT", ";", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "ppc_altivec_stvebx", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvehx", ":", "VT", "=", "MVT", "::", "i16", ";", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_stvewx", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "case", "Intrinsic", "::", "ppc_vsx_stxvd2x", ":", "VT", "=", "MVT", "::", "v2f64", ";", "break", ";" ]

[ "setCondCodeAction", "(", "ISD", "::", "SETGT", ",", "Ty", ",", "Expand", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "OR", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMAX", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMIN", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMAX", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMIN", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VSELECT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "XOR", ",", "Ty", ",", "Legal", ")", ";", "if", "(", "Ty", "==", "MVT", "::", "v4i32", "||", "Ty", "==", "MVT", "::", "v2i64", ")", "{", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SINT_TO_FP", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "Ty", ",", "Legal", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "Ty", ",", "Legal", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETNE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETGE", ",", "Ty", ",", "Expand", ")", ";" ]

[ "SDValue", "MipsSETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHS", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHU", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "false", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "lowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "lowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "lowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "}", "return", "MipsTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "}" ]

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

[ "<NUM_LIT>", ")" ]

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

[ "AnalyzeCondBr", "(", "SecondLastInst", ",", "SecondLastOpc", ",", "TBB", ",", "Cond", ")", ";" ]

[ "}", "if", "(", "!", "SecondLastOpc", ")", "{", "if", "(", "LastOpc", "==", "UncondBrOpc", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "BT_Uncond", ";", "}", "AnalyzeCondBr", "(", "LastInst", ",", "LastOpc", ",", "TBB", ",", "Cond", ")", ";", "return", "BT_Cond", ";", "}", "if", "(", "++", "I", "!=", "REnd", "&&", "isUnpredicatedTerminator", "(", "&", "*", "I", ")", ")", "return", "BT_None", ";", "BranchInstrs", ".", "insert", "(", "BranchInstrs", ".", "begin", "(", ")", ",", "SecondLastInst", ")", ";", "if", "(", "SecondLastOpc", "==", "UncondBrOpc", ")", "{", "if", "(", "!", "AllowModify", ")", "return", "BT_None", ";", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "LastInst", "->", "eraseFromParent", "(", ")", ";", "BranchInstrs", ".", "pop_back", "(", ")", ";", "return", "BT_Uncond", ";", "}", "if", "(", "LastOpc", "!=", "UncondBrOpc", ")", "return", "BT_None", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]" ]

[ "<FIXS>", "if", "(", "(", "TARGET_64BIT", "|", "|", "TARGET_SSE2", ")", "&", "&", "!", "TARGET_AVOID_MFENCE", ")", "<FIXE>" ]

[ "rtx", "(", "*", "mfence_insn", ")", "(", "rtx", ")", "rtx", "mem", "<BUGS>", "if", "(", "TARGET_64BIT", "|", "|", "TARGET_SSE2", ")", "<BUGE>", "mfence_insn", "=", "gen_mfence_sse2elsemfence_insn", "=", "gen_mfence_nosse" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=" ]

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

[ "class", "VpuInstUncond", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "VectorInstGeneric", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=" ]

[ "<STR_LIT>" ]

[ "(", "ior", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]" ]

[ ")", ";" ]

[ "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "RegisterSubReg", "DefR", "(", "MO", ")", ";", "if", "(", "!", "DefR", ".", "Reg", ".", "isVirtual", "(", ")", ")", "continue", ";", "bool", "Changed", "=", "false", ";", "if", "(", "!", "Eval", ")", "{", "const", "LatticeCell", "&", "T", "=", "Cells", ".", "get", "(", "DefR", ".", "Reg", ")", ";", "Changed", "=", "!", "T", ".", "isBottom", "(", ")", ";", "Cells", ".", "update", "(", "DefR", ".", "Reg", ",", "Bottom", ")", ";", "}", "else", "{", "if", "(", "!", "Outputs", ".", "has", "(", "DefR", ".", "Reg", ")", ")", "continue", ";", "LatticeCell", "RC", "=", "Cells", ".", "get", "(", "DefR", ".", "Reg", ")", ";", "Changed", "=", "RC", ".", "meet", "(", "Outputs", ".", "get", "(", "DefR", ".", "Reg", ")", ")", ";", "Cells", ".", "update", "(", "DefR", ".", "Reg", ",", "RC", ")", ";", "}", "if", "(", "Changed", ")", "visitUsesOf", "(", "DefR", ".", "Reg" ]

[ "DCI", ".", "recursivelyDeleteUnusedNodes", "(", "LN", ")", ";" ]

[ "if", "(", "TLI", ".", "SimplifyDemandedVectorElts", "(", "Src", ",", "DemandedElts", ",", "DCI", ")", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "DELETED_NODE", ")", "DCI", ".", "AddToWorklist", "(", "N", ")", ";", "return", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "ISD", "::", "isNormalLoad", "(", "Src", ".", "getNode", "(", ")", ")", "&&", "Src", ".", "hasOneUse", "(", ")", ")", "{", "LoadSDNode", "*", "LN", "=", "cast", "<", "LoadSDNode", ">", "(", "N", "->", "getOperand", "(", "IsStrict", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "if", "(", "SDValue", "VZLoad", "=", "narrowLoadToVZLoad", "(", "LN", ",", "MVT", "::", "i64", ",", "MVT", "::", "v2i64", ",", "DAG", ")", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "IsStrict", ")", "{", "SDValue", "Convert", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "{", "MVT", "::", "v4f32", ",", "MVT", "::", "Other", "}", ",", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v8i16", ",", "VZLoad", ")", "}", ")", ";", "DCI", ".", "CombineTo", "(", "N", ",", "Convert", ",", "Convert", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "SDValue", "Convert", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "MVT", "::", "v4f32", ",", "DAG", ".", "getBitcast", "(", "MVT", "::", "v8i16", ",", "VZLoad", ")", ")", ";", "DCI", ".", "CombineTo", "(", "N", ",", "Convert", ")", ";", "}", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "LN", ",", "<NUM_LIT>", ")", ",", "VZLoad", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "rtx", "alpha_emit_setcc", "(", "enum", "rtx_code", "code", ")", "{", "enum", "rtx_code", "cmp_code", ";", "rtx", "op0", "=", "alpha_compare", ".", "op0", ",", "op1", "=", "alpha_compare", ".", "op1", ";", "int", "fp_p", "=", "alpha_compare", ".", "fp_p", ";", "rtx", "tmp", ";", "memset", "(", "&", "alpha_compare", ",", "<NUM_LIT>", ",", "sizeof", "(", "alpha_compare", ")", ")", ";", "if", "(", "fp_p", "&&", "GET_MODE", "(", "op0", ")", "==", "TFmode", ")", "{", "op0", "=", "alpha_emit_xfloating_compare", "(", "&", "code", ",", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "fp_p", "=", "<NUM_LIT>", ";", "}", "if", "(", "fp_p", "&&", "!", "TARGET_FIX", ")", "return", "NULL_RTX", ";", "cmp_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "case", "UNORDERED", ":", "if", "(", "fp_p", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "break", ";", "case", "NE", ":", "if", "(", "!", "fp_p", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition", "(", "code", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "!", "fp_p", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "fp_p", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "fp_p", ")", "{", "if", "(", "!", "register_operand", "(", "op0", ",", "DImode", ")", ")", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_8bit_operand", "(", "op1", ",", "DImode", ")", ")", "op1", "=", "force_reg", "(", "DImode", ",", "op1", ")", ";", "}", "if", "(", "cmp_code", "!=", "UNKNOWN", ")", "{", "enum", "machine_mode", "mode", "=", "fp_p", "?", "DFmode", ":", "DImode", ";", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "fp_p", "?", "gen_lowpart", "(", "DImode", ",", "tmp", ")", ":", "tmp", ";", "op1", "=", "const0_rtx", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ";", "}" ]

[ "Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "." ]

[ "let", "MIOperandInfo", "=", "(", "ops", "GPR", ",", "i32imm", ")", ";" ]

[ "def", "ShiftedImmAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "so_reg_imm", ":", "Operand", "<", "i32", ">", ",", "ComplexPattern", "<", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "shl", ",", "srl", ",", "sra", ",", "rotr", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "ShiftedImmAsmOperand", ";" ]

[ "VT", ",", "Mulh", ")", ";" ]

[ "unsigned", "ExtOpc", "=", "LHS", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "ExtOpc", "!=", "ISD", "::", "SIGN_EXTEND", "&&", "ExtOpc", "!=", "ISD", "::", "ZERO_EXTEND", ")", "||", "RHS", ".", "getOpcode", "(", ")", "!=", "ExtOpc", ")", "return", "SDValue", "(", ")", ";", "LHS", "=", "LHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "RHS", "=", "RHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "MulVT", "=", "LHS", ".", "getValueType", "(", ")", ";", "if", "(", "MulVT", ".", "getVectorElementType", "(", ")", "!=", "MVT", "::", "i16", "||", "RHS", ".", "getValueType", "(", ")", "!=", "MulVT", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Opc", "=", "ExtOpc", "==", "ISD", "::", "SIGN_EXTEND", "?", "ISD", "::", "MULHS", ":", "ISD", "::", "MULHU", ";", "SDValue", "Mulh", "=", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MulVT", ",", "LHS", ",", "RHS", ")", ";", "ExtOpc", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ";", "return", "DAG", ".", "getNode", "(", "ExtOpc", ",", "DL", "," ]

[ "void", "AArch64InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "bool", "Offset", "=", "true", ";", "switch", "(", "RC", "->", "getSize", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "DestReg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "assert", "(", "DestReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "DestReg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "assert", "(", "DestReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "}", "assert", "(", "Opc", "&&", "<STR_LIT>", "Unknown register class", "<STR_LIT>", ")", ";", "const", "MachineInstrBuilder", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "if", "(", "Offset", ")", "MI", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addMemOperand", "(", "MMO", ")", ";", "}" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "addPreEmitPass", "(", ")", "{" ]

[ "bool", "LEGPassConfig", "::" ]

[ "}" ]

[ "t", "->", "dump", "(", ")", ";", "outs", "(", ")", "<<", "<STR_LIT>", "LowerCallResult IsPointer: ", "<STR_LIT>", "<<", "t", "->", "isPointerTy", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_TriCore", ")", ";", "for", "(", "auto", "&", "Loc", ":", "RVLocs", ")", "{", "if", "(", "t", "->", "isPointerTy", "(", ")", ")", "Loc", ".", "convertToReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Loc", ".", "getLocReg", "(", ")", ",", "Loc", ".", "getValVT", "(", ")", ",", "InGlue", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InGlue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "return", "Chain", ";" ]

[ "<FIXS>", "case", "Hexagon", "::", "L2_loadrb_io", ":", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "case", "Hexagon", "::", "LDriuh_indexed", ":", "return", "isShiftedUInt", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "<BUGS>", "case", "Hexagon", "::", "LDrib", ":", "<BUGE>", "case", "Hexagon", "::", "L2_loadrub_io", ":", "<BUGS>", "case", "Hexagon", "::", "LDrib_indexed", ":", "<BUGE>", "return", "isUInt", "<NUM_LIT>", ">", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "case", "Hexagon", "::", "POST_LDrid", ":" ]

[ "cfun_frame_layout", ".", "last_save_gpr", "=", "<NUM_LIT>", "+", "max_gpr", "-", "<NUM_LIT>", ";" ]

[ "cfun_frame_layout", ".", "last_restore_gpr", "=", "-", "<NUM_LIT>", ";", "}", "else", "{", "cfun_frame_layout", ".", "first_save_gpr_slot", "=", "i", ";", "cfun_frame_layout", ".", "last_save_gpr_slot", "=", "j", ";", "for", "(", "i", "=", "cfun_frame_layout", ".", "first_save_gpr_slot", ";", "i", "<", "cfun_frame_layout", ".", "last_save_gpr_slot", "+", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "clobbered_regs", "[", "i", "]", ")", "break", ";", "for", "(", "j", "=", "cfun_frame_layout", ".", "last_save_gpr_slot", ";", "j", ">", "i", ";", "j", "--", ")", "if", "(", "clobbered_regs", "[", "j", "]", ")", "break", ";", "if", "(", "i", "==", "cfun_frame_layout", ".", "last_save_gpr_slot", "+", "<NUM_LIT>", ")", "{", "cfun_frame_layout", ".", "first_save_gpr", "=", "-", "<NUM_LIT>", ";", "cfun_frame_layout", ".", "first_restore_gpr", "=", "-", "<NUM_LIT>", ";", "cfun_frame_layout", ".", "last_save_gpr", "=", "-", "<NUM_LIT>", ";", "cfun_frame_layout", ".", "last_restore_gpr", "=", "-", "<NUM_LIT>", ";", "}", "else", "{", "cfun_frame_layout", ".", "first_save_gpr", "=", "i", ";", "cfun_frame_layout", ".", "first_restore_gpr", "=", "i", ";", "cfun_frame_layout", ".", "last_save_gpr", "=", "j", ";", "cfun_frame_layout", ".", "last_restore_gpr", "=", "j", ";", "}", "}", "if", "(", "current_function_stdarg", ")", "{", "if", "(", "cfun", "->", "va_list_gpr_size", "&&", "current_function_args_info", ".", "gprs", "<", "GP_ARG_NUM_REG", ")", "{", "int", "min_gpr", "=", "current_function_args_info", ".", "gprs", ";", "int", "max_gpr", "=", "min_gpr", "+", "cfun", "->", "va_list_gpr_size", ";", "if", "(", "max_gpr", ">", "GP_ARG_NUM_REG", ")", "max_gpr", "=", "GP_ARG_NUM_REG", ";", "if", "(", "cfun_frame_layout", ".", "first_save_gpr", "==", "-", "<NUM_LIT>", "||", "cfun_frame_layout", ".", "first_save_gpr", ">", "<NUM_LIT>", "+", "min_gpr", ")", "{", "cfun_frame_layout", ".", "first_save_gpr", "=", "<NUM_LIT>", "+", "min_gpr", ";", "cfun_frame_layout", ".", "first_save_gpr_slot", "=", "<NUM_LIT>", "+", "min_gpr", ";", "}", "if", "(", "cfun_frame_layout", ".", "last_save_gpr", "==", "-", "<NUM_LIT>", "||", "cfun_frame_layout", ".", "last_save_gpr", "<", "<NUM_LIT>", "+", "max_gpr", "-", "<NUM_LIT>", ")", "{" ]

[ "}" ]

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

[ "StringRef", "CPU", ",", "StringRef", "FS", ")", "{" ]

[ "static", "MCSubtargetInfo", "*", "createTVMMCSubtargetInfo", "(", "const", "Triple", "&", "TT", "," ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

[ "def", "tBLXr", ":", "TI", "<", "(", "outs", ")", ",", "(", "ins", "pred", ":", "$", "p", ",", "GPR", ":", "$", "func", ")", ",", "IIC_Br", ",", "<STR_LIT>", ",", "[", "(", "ARMcall", "GPR", ":", "$", "func", ")", "]", ">", ",", "Requires", "<", "[", "IsThumb", ",", "HasV5T", "]", ">", ",", "T1Special", "<", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", "}", ">", ",", "Sched", "<", "[", "WriteBrL", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "func", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "func", ";" ]

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

[ "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")" ]

[ ")", ")" ]

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

[ "]", ")" ]

[ "(", "bswap", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_DSBH", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_DSHD", ")", ")", "]", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "const", "char", "*", "SystemZTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "SIBCALL", ")", ";", "OPCODE", "(", "TLS_GDCALL", ")", ";", "OPCODE", "(", "TLS_LDCALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "PCREL_OFFSET", ")", ";", "OPCODE", "(", "IABS", ")", ";", "OPCODE", "(", "ICMP", ")", ";", "OPCODE", "(", "FCMP", ")", ";", "OPCODE", "(", "TM", ")", ";", "OPCODE", "(", "BR_CCMASK", ")", ";", "OPCODE", "(", "SELECT_CCMASK", ")", ";", "OPCODE", "(", "ADJDYNALLOC", ")", ";", "OPCODE", "(", "POPCNT", ")", ";", "OPCODE", "(", "UMUL_LOHI", ")", ";", "OPCODE", "(", "SDIVREM", ")", ";", "OPCODE", "(", "UDIVREM", ")", ";", "OPCODE", "(", "MVC", ")", ";", "OPCODE", "(", "MVC_LOOP", ")", ";", "OPCODE", "(", "NC", ")", ";", "OPCODE", "(", "NC_LOOP", ")", ";", "OPCODE", "(", "OC", ")", ";", "OPCODE", "(", "OC_LOOP", ")", ";", "OPCODE", "(", "XC", ")", ";", "OPCODE", "(", "XC_LOOP", ")", ";", "OPCODE", "(", "CLC", ")", ";", "OPCODE", "(", "CLC_LOOP", ")", ";", "OPCODE", "(", "STPCPY", ")", ";", "OPCODE", "(", "STRCMP", ")", ";", "OPCODE", "(", "SEARCH_STRING", ")", ";", "OPCODE", "(", "IPM", ")", ";", "OPCODE", "(", "MEMBARRIER", ")", ";", "OPCODE", "(", "TBEGIN", ")", ";", "OPCODE", "(", "TBEGIN_NOFLOAT", ")", ";", "OPCODE", "(", "TEND", ")", ";", "OPCODE", "(", "BYTE_MASK", ")", ";", "OPCODE", "(", "ROTATE_MASK", ")", ";", "OPCODE", "(", "REPLICATE", ")", ";", "OPCODE", "(", "JOIN_DWORDS", ")", ";", "OPCODE", "(", "SPLAT", ")", ";", "OPCODE", "(", "MERGE_HIGH", ")", ";", "OPCODE", "(", "MERGE_LOW", ")", ";", "OPCODE", "(", "SHL_DOUBLE", ")", ";", "OPCODE", "(", "PERMUTE_DWORDS", ")", ";", "OPCODE", "(", "PERMUTE", ")", ";", "OPCODE", "(", "PACK", ")", ";", "OPCODE", "(", "PACKS_CC", ")", ";", "OPCODE", "(", "PACKLS_CC", ")", ";", "OPCODE", "(", "UNPACK_HIGH", ")", ";", "OPCODE", "(", "UNPACKL_HIGH", ")", ";", "OPCODE", "(", "UNPACK_LOW", ")", ";", "OPCODE", "(", "UNPACKL_LOW", ")", ";", "OPCODE", "(", "VSHL_BY_SCALAR", ")", ";", "OPCODE", "(", "VSRL_BY_SCALAR", ")", ";", "OPCODE", "(", "VSRA_BY_SCALAR", ")", ";", "OPCODE", "(", "VSUM", ")", ";", "OPCODE", "(", "VICMPE", ")", ";", "OPCODE", "(", "VICMPH", ")", ";", "OPCODE", "(", "VICMPHL", ")", ";", "OPCODE", "(", "VICMPES", ")", ";", "OPCODE", "(", "VICMPHS", ")", ";", "OPCODE", "(", "VICMPHLS", ")", ";", "OPCODE", "(", "VFCMPE", ")", ";", "OPCODE", "(", "VFCMPH", ")", ";", "OPCODE", "(", "VFCMPHE", ")", ";", "OPCODE", "(", "VFCMPES", ")", ";", "OPCODE", "(", "VFCMPHS", ")", ";", "OPCODE", "(", "VFCMPHES", ")", ";", "OPCODE", "(", "VFTCI", ")", ";", "OPCODE", "(", "VEXTEND", ")", ";", "OPCODE", "(", "VROUND", ")", ";", "OPCODE", "(", "VTM", ")", ";", "OPCODE", "(", "VFAE_CC", ")", ";", "OPCODE", "(", "VFAEZ_CC", ")", ";", "OPCODE", "(", "VFEE_CC", ")", ";", "OPCODE", "(", "VFEEZ_CC", ")", ";", "OPCODE", "(", "VFENE_CC", ")", ";", "OPCODE", "(", "VFENEZ_CC", ")", ";", "OPCODE", "(", "VISTR_CC", ")", ";", "OPCODE", "(", "VSTRC_CC", ")", ";", "OPCODE", "(", "VSTRCZ_CC", ")", ";", "OPCODE", "(", "TDC", ")", ";", "OPCODE", "(", "ATOMIC_SWAPW", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_ADD", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_SUB", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_AND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_OR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_XOR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_NAND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MAX", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMAX", ")", ";", "OPCODE", "(", "ATOMIC_CMP_SWAPW", ")", ";", "OPCODE", "(", "LRV", ")", ";", "OPCODE", "(", "STRV", ")", ";", "OPCODE", "(", "PREFETCH", ")", ";", "}", "return", "nullptr", ";", "}" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "VSELECT", ":" ]

[ "return", "performADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "performSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::" ]

[ "||", "GET_MODE_SIZE", "(", "mode", ")", "==", "<NUM_LIT>", ")", ";" ]

[ "static", "bool", "iq2000_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "GR_REGS", "?", "(", "regno", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "<NUM_LIT>", ":", "(", "regno", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>" ]

[ "]", ")" ]

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

[ "}" ]

[ "unsigned", "getLength", "(", ")", "const", "{", "return", "CurType", ".", "Length", ";" ]

[ "<FIXS>", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSeaIslands", "]", ">", ";", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSeaIslands", "]", ">", ";", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSeaIslands", "]", ">", ";", "<FIXE>" ]

[ "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSouthernIslands", "]", ">", ";", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSouthernIslands", "]", ">", ";", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSouthernIslands", "]", ">", ";", "<BUGS>", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSouthernIslands", "]", ">", ";", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSouthernIslands", "]", ">", ";", "def", ":", "Proc", "<STR_LIT>", ",", "SI_Itin", ",", "[", "FeatureSouthernIslands", "]", ">", ";", "<BUGE>" ]

[ "DstRegX", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "}", "}", "}", "else", "{", "for", "(", "auto", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MOP", ".", "isReg", "(", ")", "&&", "!", "MOP", ".", "isDebug", "(", ")", "&&", "MOP", ".", "getReg", "(", ")", "&&", "TRI", "->", "regsOverlap", "(", "MOP", ".", "getReg", "(", ")", ",", "RegToRename", ")", ")", "{", "assert", "(", "(", "MOP", ".", "isImplicit", "(", ")", "||", "(", "MOP", ".", "isRenamable", "(", ")", "&&", "!", "MOP", ".", "isEarlyClobber", "(", ")", ")", ")", "&&", "<STR_LIT>", "Need renamable operands", "<STR_LIT>", ")", ";", "MOP", ".", "setReg", "(", "GetMatchingSubReg", "(", "MOP", ".", "getReg", "(", ")", ")", ")", ";", "}", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Renamed ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "true", ";", "}", ";", "forAllMIsUntilDef", "(", "*", "I", ",", "RegToRename", ",", "TRI", ",", "LdStLimit", ",", "UpdateMIs", ")", ";", "for", "(", "auto", "&", "MI", ":", "iterator_range", "<", "MachineInstrBundleIterator", "<", "llvm", "::", "MachineInstr", ">>", "(", "std", "::", "next", "(", "I", ")", ",", "std", "::", "next", "(", "Paired", ")", ")", ")", "assert", "(", "all_of", "(", "MI", ".", "operands", "(", ")", ",", "[", "this", ",", "&", "RenameReg", "]", "(", "const", "MachineOperand", "&", "MOP", ")", "{", "return", "!", "MOP", ".", "isReg", "(", ")", "||", "MOP", ".", "isDebug", "(", ")", "||", "!", "MOP", ".", "getReg", "(", ")", "||", "!", "TRI", "->", "regsOverlap", "(", "MOP", ".", "getReg", "(", ")", ",", "*", "RenameReg", ")", ";", "}", ")", "&&", "<STR_LIT>", "Rename register used between paired instruction, trashing the ", "<STR_LIT>", "<STR_LIT>", "content", "<STR_LIT>", ")", ";", "}", "MachineBasicBlock", "::", "iterator", "InsertionPoint", "=", "MergeForward", "?", "Paired", ":", "I", ";", "const", "MachineOperand", "&", "BaseRegOp", "=", "MergeForward", "?", "getLdStBaseOp", "(", "*", "Paired", ")", ":", "getLdStBaseOp", "(", "*", "I", ")", ";", "int", "Offset", "=", "getLdStOffsetOp", "(", "*", "I", ")", ".", "getImm", "(", ")", ";", "int", "PairedOffset", "=", "getLdStOffsetOp", "(", "*", "Paired", ")", ".", "getImm", "(", ")", ";", "bool", "PairedIsUnscaled", "=", "TII", "->", "isUnscaledLdSt", "(", "Paired", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "IsUnscaled", "!=", "PairedIsUnscaled", ")", "{", "int", "MemSize", "=", "TII", "->", "getMemScale", "(", "*", "Paired", ")", ";", "if", "(", "PairedIsUnscaled", ")", "{", "assert", "(", "!", "(", "PairedOffset", "%", "TII", "->", "getMemScale", "(", "*", "Paired", ")", ")", "&&", "<STR_LIT>", "Offset should be a multiple of the stride!", "<STR_LIT>", ")", ";", "PairedOffset", "/", "=", "MemSize", ";", "}", "else", "{", "PairedOffset", "*=", "MemSize", ";", "}", "}", "MachineInstr", "*", "RtMI", ",", "*", "Rt2MI", ";", "if", "(", "Offset", "==", "PairedOffset", "+", "OffsetStride", ")", "{", "RtMI", "=", "&", "*", "Paired", ";", "Rt2MI", "=", "&", "*", "I", ";", "if", "(", "SExtIdx", "!=", "-", "<NUM_LIT>", ")", "SExtIdx", "=", "(", "SExtIdx", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ";", "}", "else", "{", "RtMI", "=", "&", "*", "I", ";", "Rt2MI", "=", "&", "*", "Paired", ";", "}", "int", "OffsetImm", "=", "getLdStOffsetOp", "(", "*", "RtMI", ")", ".", "getImm", "(", ")", ";", "if", "(", "TII", "->", "isUnscaledLdSt", "(", "RtMI", "->", "getOpcode", "(", ")", ")", ")", "{", "assert", "(", "!", "(", "OffsetImm", "%", "TII", "->", "getMemScale", "(", "*", "RtMI", ")", ")", "&&", "<STR_LIT>", "Unscaled offset cannot be scaled.", "<STR_LIT>", ")", ";", "OffsetImm", "/", "=", "TII", "->", "getMemScale", "(", "*", "RtMI", ")", ";", "}", "MachineInstrBuilder", "MIB", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "I", "->", "getParent", "(", ")", ";", "MachineOperand", "RegOp0", "=", "getLdStRegOp", "(", "*", "RtMI", ")", ";", "MachineOperand", "RegOp1", "=", "getLdStRegOp", "(", "*", "Rt2MI", ")", ";", "if", "(", "RegOp0", ".", "isUse", "(", ")", ")", "{", "if", "(", "!", "MergeForward", ")", "{", "RegOp0", ".", "setIsKill", "(", "false", ")", ";", "RegOp1", ".", "setIsKill", "(", "false", ")", ";", "}", "else", "{", "Register", "Reg", "=", "getLdStRegOp", "(", "*", "I", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "make_range", "(", "std", "::", "next", "(", "I", ")", ",", "Paired", ")", ")", "MI", ".", "clearRegisterKills", "(", "Reg", ",", "TRI", ")", ";", "}", "}", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "InsertionPoint", ",", "DL", ",", "TII", "->", "get", "(", "getMatchingPairOpcode", "(", "Opc", ")", ")", ")", ".", "add", "(", "RegOp0", ")", ".", "add", "(", "RegOp1", ")", ".", "add", "(", "BaseRegOp", ")", ".", "addImm", "(", "OffsetImm", ")", ".", "cloneMergedMemRefs", "(", "{", "&", "*", "I", ",", "&", "*", "Paired", "}", ")", ".", "setMIFlags", "(", "I", "->", "mergeFlagsWith", "(", "*", "Paired", ")", ")", ";", "(", "void", ")", "MIB", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Creating pair load/store. Replacing instructions:\\n ", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "I", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ")", ";", "LLVM_DEBUG", "(", "Paired", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " with instruction:\\n ", "<STR_LIT>", ")", ";", "if", "(", "SExtIdx", "!=", "-", "<NUM_LIT>", ")", "{", "MachineOperand", "&", "DstMO", "=", "MIB", "->", "getOperand", "(", "SExtIdx", ")", ";", "Register", "DstRegX", "=", "DstMO", ".", "getReg", "(", ")", ";", "Register", "DstRegW", "=", "TRI", "->", "getSubReg", "(", "DstRegX", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "DstMO", ".", "setReg", "(", "DstRegW", ")", ";", "LLVM_DEBUG", "(", "(", "(", "MachineInstr", "*", ")", "MIB", ")", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MachineInstrBuilder", "MIBKill", "=", "BuildMI", "(", "*", "MBB", ",", "InsertionPoint", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "KILL", ")", ",", "DstRegW", ")", ".", "addReg", "(", "DstRegW", ")", ".", "addReg", "(", "DstRegX", ",", "RegState", "::", "Define", ")", ";", "MIBKill", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImplicit", "(", ")", ";", "MachineInstrBuilder", "MIBSXTW", "=", "BuildMI", "(", "*", "MBB", ",", "InsertionPoint", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstRegX", ")", ".", "addReg", "(" ]

[ "if", "(", "spu_expand_mov", "(", "operands", ",", "<", "MODE", ">", "mode", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "ALL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ALL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{" ]

[ "}" ]

[ "for", "(", "auto", "I", "=", "B", ".", "livein_begin", "(", ")", ",", "E", "=", "B", ".", "livein_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "T", ".", "push_back", "(", "I", "->", "PhysReg", ")", ";", "for", "(", "auto", "I", ":", "T", ")", "B", ".", "removeLiveIn", "(", "I", ")", ";", "auto", "&", "LiveIns", "=", "LiveMap", "[", "&", "B", "]", ";", "for", "(", "auto", "I", ":", "LiveIns", ")", "{", "B", ".", "addLiveIn", "(", "{", "MCPhysReg", "(", "I", ".", "first", ")", ",", "I", ".", "second", "}", ")", ";", "}" ]

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

[ "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_cvtsi2ss64", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "_", "_" ]

[ "if", "(", "!", "(", "ValVT", ".", "isFloatingPoint", "(", ")", "||", "(", "ValVT", ".", "isVector", "(", ")", "&&", "ValVT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", ")", ")", "{" ]

[ "if", "(", "ArgFlags", ".", "isSecArgPass", "(", ")", ")", "{", "if", "(", "ArgFlags", ".", "isHva", "(", ")", ")", "return", "CC_X86_VectorCallAssignRegister", "(", "ValNo", ",", "ValVT", ",", "LocVT", ",", "LocInfo", ",", "ArgFlags", ",", "State", ")", ";", "return", "true", ";", "}" ]

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

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

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "<FIXS>", "(", "if_then_else", ":", "I", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "I", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "if_then_else", ":", "I", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "<BUGE>", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "I", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "output_address", "(", "mem_mode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "elsefprintf", "(", "file", ",", "<STR_LIT>", "++", "<STR_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PRE_MODIFY", ")", "<BUGS>", "output_address", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "print_address_offset", "(", "file", ",", "off", ",", "mem_mode", ")", ";", "break", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "SrcA", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Dest", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SrcExtra", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PredPolarity", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PredAddress", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "VectorPred", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Switches", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcA", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Dest", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredPolarity", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "PredAddress", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "VectorPred", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

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

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

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

[ "def", "A2_vavguh", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_6132ba3d", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

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

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

[ "Offset", "=", "DAG", ".", "getConstant", "(", "-", "RHSC", ",", "SDLoc", "(", "Ptr", ")", ",", "RHS", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "RHSC", ">", "<NUM_LIT>", "&&", "RHSC", "<", "<NUM_LIT>", ")", "{", "isInc", "=", "Ptr", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "RHSC", ",", "SDLoc", "(", "Ptr", ")", ",", "RHS", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";" ]

[ ";" ]

[ "poly8x8x2_t", "ret", ";", "_", "_", "builtin_aarch64_simd_oi", "_", "_", "o", ";", "_", "_", "o", "=", "_", "_", "builtin_aarch64_ld2v8qi", "(", "(", "const", "_", "_", "builtin_aarch64_simd_qi", "*", ")", "_", "_", "a", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "poly8x8_t", ")", "_", "_", "builtin_aarch64_get_dregoiv8qi", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "poly8x8_t", ")", "_", "_", "builtin_aarch64_get_dregoiv8qi", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";", "return", "ret" ]

[ "const", "override", "{" ]

[ "const", "PPCTargetLowering", "*", "getTargetLowering", "(", ")" ]

[ "=", "<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>", ";", "let", "isCommutable", "=", "<NUM_LIT>", ";", "let", "isCompare" ]

[ "<FIXS>", "if", "(", "no_callee_saved_registers", ")", "<FIXE>" ]

[ "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ")", "cfun", "->", "machine", "->", "call_saved_registers", "=", "TYPE_NO_CALLER_SAVED_REGISTERS", ";", "<BUGS>", "if", "(", "has_no_callee_saved_registers", ")", "<BUGE>", "{", "if", "(", "cfun", "->", "machine", "->", "call_saved_registers", "==", "TYPE_NO_CALLER_SAVED_REGISTERS", ")" ]

[ "}" ]

[ "ArrayRef", "<", "int", ">", "Mask", "=", "cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ")", "->", "getMask", "(", ")", ";", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "!=", "V0", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", "||", "VT", ".", "getVectorElementType", "(", ")", "!=", "V1", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", ")", "return", "SDValue", "(", ")", ";", "bool", "SplitV0", "=", "V0", ".", "getValueSizeInBits", "(", ")", "==", "<NUM_LIT>", ";", "if", "(", "!", "isConcatMask", "(", "Mask", ",", "VT", ",", "SplitV0", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "CastVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ".", "getVectorElementType", "(", ")", ",", "VT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ")", ";", "if", "(", "SplitV0", ")", "{", "V0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "CastVT", ",", "V0", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_sqrt_round_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_sqrtpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "mm512_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_" ]

[ "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "f64", ",", "MVT", "::", "f32", ",", "Expand", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "JumpTable", ",", "MVTPtr", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BlockAddress", ",", "MVTPtr", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "BRIND", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VASTART", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VAARG", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VACOPY", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VAEND", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "for", "(", "auto", "T", ":", "{", "MVT", "::", "f32", ",", "MVT", "::", "f64", "}", ")", "{", "setOperationAction", "(", "ISD", "::", "ConstantFP", ",", "T", ",", "Legal", ")", ";", "for", "(", "auto", "CC", ":", "{", "ISD", "::", "SETO", ",", "ISD", "::", "SETUO", ",", "ISD", "::", "SETUEQ", ",", "ISD", "::", "SETONE", ",", "ISD", "::", "SETULT", ",", "ISD", "::", "SETULE", ",", "ISD", "::", "SETUGT", ",", "ISD", "::", "SETUGE", "}", ")", "setCondCodeAction", "(", "CC", ",", "T", ",", "Expand", ")", ";", "for", "(", "auto", "Op", ":", "{", "ISD", "::", "FSIN", ",", "ISD", "::", "FCOS", ",", "ISD", "::", "FSINCOS", ",", "ISD", "::", "FPOWI", ",", "ISD", "::", "FPOW", ",", "ISD", "::", "FREM", ",", "ISD", "::", "FMA", "}", ")", "setOperationAction", "(", "Op", ",", "T", ",", "Expand", ")", ";", "for", "(", "auto", "Op", ":", "{", "ISD", "::", "FCEIL", ",", "ISD", "::", "FFLOOR", ",", "ISD", "::", "FTRUNC", ",", "ISD", "::", "FNEARBYINT", ",", "ISD", "::", "FRINT", "}", ")", "setOperationAction", "(", "Op", ",", "T", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FMINNAN", ",", "T", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FMAXNAN", ",", "T", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP16_TO_FP", ",", "T", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_FP16", ",", "T", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "T", ",", "MVT", "::", "f16", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "T", ",", "MVT", "::", "f16", ",", "Expand", ")", ";", "}", "for", "(", "auto", "T", ":", "{", "MVT", "::", "i32", ",", "MVT", "::", "i64", "}", ")", "{", "for", "(", "auto", "Op", ":", "{", "ISD", "::", "BSWAP", ",", "ISD", "::", "SMUL_LOHI", ",", "ISD", "::", "UMUL_LOHI", ",", "ISD", "::", "MULHS", ",", "ISD", "::", "MULHU", ",", "ISD", "::", "SDIVREM", ",", "ISD", "::", "UDIVREM", ",", "ISD", "::", "SHL_PARTS", ",", "ISD", "::", "SRA_PARTS", ",", "ISD", "::", "SRL_PARTS", ",", "ISD", "::", "ADDC", ",", "ISD", "::", "ADDE", ",", "ISD", "::", "SUBC", ",", "ISD", "::", "SUBE", "}", ")", "{", "setOperationAction", "(", "Op", ",", "T", ",", "Expand", ")", ";", "}", "}", "for", "(", "auto", "T", ":", "{", "MVT", "::", "i1", ",", "MVT", "::", "i8", ",", "MVT", "::", "i16", ",", "MVT", "::", "i32", "}", ")", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "T", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKSAVE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKRESTORE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "DYNAMIC_STACKALLOC", ",", "MVTPtr", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FrameIndex", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "CopyToReg", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "for", "(", "auto", "T", ":", "{", "MVT", "::", "i32", ",", "MVT", "::", "i64", ",", "MVT", "::", "f32", ",", "MVT", "::", "f64", "}", ")", "for", "(", "auto", "Op", ":", "{", "ISD", "::", "BR_CC", ",", "ISD", "::", "SELECT_CC", "}", ")", "setOperationAction", "(", "Op", ",", "T", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_JT", ",", "MVT", "::", "Other", ",", "Custom", ")", ";" ]

[ "return", "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "clz", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "CC_STATUS_INIT" ]

[ "ConstantSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "Base", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Offset", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "InlineAsm", "::", "ConstraintCode", "::", "m", ":", "if", "(", "CurDAG", "->", "isBaseWithConstantOffset", "(", "Op", ")", ")", "{", "ConstantSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "isIntN", "(", "<NUM_LIT>", ",", "CN", "->", "getSExtValue", "(", ")", ")", ")", "{", "Base", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Offset", "=", "CurDAG", "->", "getTargetConstant", "(", "CN", "->", "getZExtValue", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "}", "}", "break", ";", "case", "InlineAsm", "::", "ConstraintCode", "::", "ZB", ":", "break", ";", "case", "InlineAsm", "::", "ConstraintCode", "::", "ZC", ":", "if", "(", "CurDAG", "->", "isBaseWithConstantOffset", "(", "Op", ")", ")", "{" ]

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

[ "return", "(", "_", "_", "mmask32", ")", "_", "_", "builtin_ia32_ucmpb256_mask", "(", "(", "_", "_", "v32qi", ")", "_", "_", "X", ",", "(", "_", "_", "v32qi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask32" ]

[ "case", "MachineOperand", "::", "MO_RegisterMask", ":" ]

[ "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "return", "LowerSymbolOperand", "(", "MO", ",", "GetSymbolFromOperand", "(", "MO", ")", ")", ";", "case", "MachineOperand", "::", "MO_MCSymbol", ":", "return", "LowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMCSymbol", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "return", "LowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "return", "LowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "return", "LowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";" ]

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

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

[ "if", "(", "ElemTy", ".", "isPointerTy", "(", ")", ")", "{" ]

[ "static", "bool", "isVectorLaneType", "(", "llvm", "::", "Type", "&", "ElemTy", ")", "{", "if", "(", "ElemTy", ".", "isIntegerTy", "(", ")", ")", "{", "unsigned", "ScaBits", "=", "ElemTy", ".", "getScalarSizeInBits", "(", ")", ";", "return", "ScaBits", "==", "<NUM_LIT>", "||", "ScaBits", "==", "<NUM_LIT>", "||", "ScaBits", "==", "<NUM_LIT>", ";", "}" ]

[ "return", "doTransformation", "(", "M", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** preserve debuginfo type **********\\n", "<STR_LIT>", ")", ";", "if", "(", "M", ".", "debug_compile_units", "(", ")", ".", "empty", "(", ")", ")", "return", "false", ";" ]

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

[ "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "V4HI", "(", "vec_select", ":", "V4QI", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")" ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p1", "-", "isa", "(", "SLOTS", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpsubla1_h", "<STR_LIT>", ")", "(", "CPTYPE", "V4HI", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "<NUM_LIT>", "qqqqq", "ppppp", "<NUM_LIT>", "cpsubla1", ".", "h", "crqp", ",", "crpp", "(", "p0_1", ")", "(", "dni", "cpsubla1_h_P1", "<STR_LIT>", "cpsubla1.h $crqp,$crpp Pn", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p1", "-", "isa", "(", "SLOTS", "P1", ")", "(", "INTRINSIC", "<STR_LIT>", "cpsubla1_h", "<STR_LIT>", ")", "(", "CPTYPE", "V4HI", ")", ")", "<BUGE>", "<STR_LIT>", "cpsubla1.h $crqp,$crpp", "<STR_LIT>", "(", "+", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u0", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u8", "#", "x18", ")", "crqp", "crpp", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u23", "#", "xb", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u28", "<NUM_LIT>", ")", ")", "(", "sequence", "(", ")" ]